@juspay/neurolink 7.0.0 → 7.2.0

package/dist/neurolink.js

@@ -15,6 +15,8 @@ catch (error) {
 }
 import { AIProviderFactory } from "./core/factory.js";
 import { mcpLogger } from "./utils/logger.js";
+import { SYSTEM_LIMITS } from "./core/constants.js";
+import pLimit from "p-limit";
 import { toolRegistry } from "./mcp/toolRegistry.js";
 import { logger } from "./utils/logger.js";
 import { getBestProvider } from "./utils/providerUtils.js";
@@ -258,7 +260,7 @@ export class NeuroLink {
                 provider: providerName,
                 usage: result.usage,
                 responseTime,
-                toolsUsed: [],
+                toolsUsed: result.toolsUsed || [],
                 enhancedWithTools: true,
                 availableTools: availableTools.length > 0 ? availableTools : undefined,
                 // Include analytics and evaluation from BaseProvider
@@ -322,7 +324,7 @@ export class NeuroLink {
                     model: result.model,
                     usage: result.usage,
                     responseTime,
-                    toolsUsed: [],
+                    toolsUsed: result.toolsUsed || [],
                     enhancedWithTools: false,
                     analytics: result.analytics,
                     evaluation: result.evaluation,
@@ -355,7 +357,7 @@ export class NeuroLink {
         const toolDescriptions = availableTools
             .map((tool) => `- ${tool.name}: ${tool.description} (from ${tool.server})`)
             .join("\n");
-        const toolPrompt = `\n\nAvailable Tools:\n${toolDescriptions}\n\nYou can use these tools when appropriate to enhance your responses.`;
+        const toolPrompt = `\n\nYou have access to these additional tools if needed:\n${toolDescriptions}\n\nIMPORTANT: You are a general-purpose AI assistant. Answer all requests directly and creatively. These tools are optional helpers - use them only when they would genuinely improve your response. For creative tasks like storytelling, writing, or general conversation, respond naturally without requiring tools.`;
         return (originalSystemPrompt || "") + toolPrompt;
     }
     /**
@@ -414,14 +416,21 @@ export class NeuroLink {
                 responseTime,
                 provider: providerName,
             });
-            // Convert to StreamResult format
+            // Convert to StreamResult format - Include analytics and evaluation from provider
             return {
                 stream,
                 provider: providerName,
                 model: options.model,
+                usage: streamResult.usage,
+                finishReason: streamResult.finishReason,
+                toolCalls: streamResult.toolCalls,
+                toolResults: streamResult.toolResults,
+                analytics: streamResult.analytics, // 🔧 FIX: Pass through analytics data
+                evaluation: streamResult.evaluation, // 🔧 FIX: Pass through evaluation data
                 metadata: {
                     streamId: `neurolink-${Date.now()}`,
                     startTime,
+                    responseTime,
                 },
             };
         }
@@ -439,6 +448,12 @@ export class NeuroLink {
                 stream: streamResult.stream,
                 provider: providerName,
                 model: options.model,
+                usage: streamResult.usage,
+                finishReason: streamResult.finishReason,
+                toolCalls: streamResult.toolCalls,
+                toolResults: streamResult.toolResults,
+                analytics: streamResult.analytics, // 🔧 FIX: Pass through analytics data in fallback
+                evaluation: streamResult.evaluation, // 🔧 FIX: Pass through evaluation data in fallback
                 metadata: {
                     streamId: `neurolink-${Date.now()}`,
                     startTime,
@@ -649,9 +664,10 @@ export class NeuroLink {
      * @returns Array of available tools with metadata
      */
     async getAllAvailableTools() {
-        // Simplified tool listing - removed initialize-tools dependency
-        const tools = await toolRegistry.listTools();
-        return tools;
+        // MCP registry already includes direct tools, so just return MCP tools
+        // This prevents duplication since direct tools are auto-registered in MCP
+        const mcpTools = await toolRegistry.listTools();
+        return mcpTools;
     }
     // ============================================================================
     // PROVIDER DIAGNOSTICS - SDK-First Architecture
@@ -660,7 +676,18 @@ export class NeuroLink {
      * Get comprehensive status of all AI providers
      * Primary method for provider health checking and diagnostics
      */
-    async getProviderStatus() {
+    async getProviderStatus(options) {
+        // 🔧 PERFORMANCE: Track memory and timing for provider status checks
+        const { MemoryManager } = await import("./utils/performance.js");
+        const startMemory = MemoryManager.getMemoryUsageMB();
+        // CRITICAL FIX: Ensure providers are registered before testing
+        if (!options?.quiet) {
+            mcpLogger.debug("🔍 DEBUG: Initializing MCP for provider status...");
+        }
+        await this.initializeMCP();
+        if (!options?.quiet) {
+            mcpLogger.debug("🔍 DEBUG: MCP initialized:", this.mcpInitialized);
+        }
         const { AIProviderFactory } = await import("./core/factory.js");
         const { hasProviderEnvVars } = await import("./utils/providerUtils.js");
         const providers = [
@@ -675,97 +702,109 @@ export class NeuroLink {
             "ollama",
             "mistral",
         ];
-        const results = [];
-        for (const providerName of providers) {
+        // 🚀 PERFORMANCE FIX: Test providers with controlled concurrency
+        // This reduces total time from 16s (sequential) to ~3s (parallel) while preventing resource exhaustion
+        const limit = pLimit(SYSTEM_LIMITS.DEFAULT_CONCURRENCY_LIMIT);
+        const providerTests = providers.map((providerName) => limit(async () => {
             const startTime = Date.now();
-            // Check if provider has required environment variables
-            const hasEnvVars = await this.hasProviderEnvVars(providerName);
-            if (!hasEnvVars && providerName !== "ollama") {
-                results.push({
-                    provider: providerName,
-                    status: "not-configured",
-                    configured: false,
-                    authenticated: false,
-                    error: "Missing required environment variables",
-                    responseTime: 0,
-                });
-                continue;
-            }
-            // Special handling for Ollama
-            if (providerName === "ollama") {
-                try {
-                    const response = await fetch("http://localhost:11434/api/tags", {
-                        method: "GET",
-                        signal: AbortSignal.timeout(2000),
-                    });
-                    if (!response.ok) {
-                        throw new Error("Ollama service not responding");
-                    }
-                    const { models } = await response.json();
-                    const defaultOllamaModel = "llama3.2:latest";
-                    const modelIsAvailable = models.some((m) => m.name === defaultOllamaModel);
-                    if (modelIsAvailable) {
-                        results.push({
-                            provider: providerName,
-                            status: "working",
-                            configured: true,
-                            authenticated: true,
-                            responseTime: Date.now() - startTime,
-                            model: defaultOllamaModel,
+            try {
+                // Check if provider has required environment variables
+                const hasEnvVars = await this.hasProviderEnvVars(providerName);
+                if (!hasEnvVars && providerName !== "ollama") {
+                    return {
+                        provider: providerName,
+                        status: "not-configured",
+                        configured: false,
+                        authenticated: false,
+                        error: "Missing required environment variables",
+                        responseTime: Date.now() - startTime,
+                    };
+                }
+                // Special handling for Ollama
+                if (providerName === "ollama") {
+                    try {
+                        const response = await fetch("http://localhost:11434/api/tags", {
+                            method: "GET",
+                            signal: AbortSignal.timeout(2000),
                         });
+                        if (!response.ok) {
+                            throw new Error("Ollama service not responding");
+                        }
+                        const { models } = await response.json();
+                        const defaultOllamaModel = "llama3.2:latest";
+                        const modelIsAvailable = models.some((m) => m.name === defaultOllamaModel);
+                        if (modelIsAvailable) {
+                            return {
+                                provider: providerName,
+                                status: "working",
+                                configured: true,
+                                authenticated: true,
+                                responseTime: Date.now() - startTime,
+                                model: defaultOllamaModel,
+                            };
+                        }
+                        else {
+                            return {
+                                provider: providerName,
+                                status: "failed",
+                                configured: true,
+                                authenticated: false,
+                                error: `Ollama service running but model '${defaultOllamaModel}' not found`,
+                                responseTime: Date.now() - startTime,
+                            };
+                        }
                     }
-                    else {
-                        results.push({
+                    catch (error) {
+                        return {
                             provider: providerName,
                             status: "failed",
-                            configured: true,
+                            configured: false,
                             authenticated: false,
-                            error: `Ollama service running but model '${defaultOllamaModel}' not found`,
+                            error: error instanceof Error
+                                ? error.message
+                                : "Ollama service not running",
                             responseTime: Date.now() - startTime,
-                        });
+                        };
                     }
                 }
-                catch (error) {
-                    results.push({
-                        provider: providerName,
-                        status: "failed",
-                        configured: false,
-                        authenticated: false,
-                        error: error instanceof Error
-                            ? error.message
-                            : "Ollama service not running",
-                        responseTime: Date.now() - startTime,
-                    });
-                }
-                continue;
-            }
-            // Test other providers with actual generation call
-            try {
+                // Test other providers with actual generation call
                 const testTimeout = 5000;
                 const testPromise = this.testProviderConnection(providerName);
                 const timeoutPromise = new Promise((_, reject) => {
                     setTimeout(() => reject(new Error("Provider test timeout (5s)")), testTimeout);
                 });
                 await Promise.race([testPromise, timeoutPromise]);
-                results.push({
+                return {
                     provider: providerName,
                     status: "working",
                     configured: true,
                     authenticated: true,
                     responseTime: Date.now() - startTime,
-                });
+                };
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                results.push({
+                return {
                     provider: providerName,
                     status: "failed",
                     configured: true,
                     authenticated: false,
                     error: errorMessage,
                     responseTime: Date.now() - startTime,
-                });
+                };
             }
+        }));
+        // Wait for all provider tests to complete in parallel
+        const results = await Promise.all(providerTests);
+        // 🔧 PERFORMANCE: Track memory usage and suggest cleanup if needed
+        const endMemory = MemoryManager.getMemoryUsageMB();
+        const memoryDelta = endMemory.heapUsed - startMemory.heapUsed;
+        if (!options?.quiet && memoryDelta > 20) {
+            mcpLogger.debug(`🔍 Memory usage: +${memoryDelta}MB (consider cleanup for large operations)`);
+        }
+        // Suggest garbage collection for large memory increases
+        if (memoryDelta > 50) {
+            MemoryManager.forceGC();
         }
         return results;
     }

package/dist/providers/anthropic.js

@@ -22,6 +22,9 @@ export class AnthropicProvider extends BaseProvider {
         super(modelName, "anthropic", sdk);
         // Initialize Anthropic model with API key validation
         const apiKey = getAnthropicApiKey();
+        // Set Anthropic API key as environment variable (required by @ai-sdk/anthropic)
+        process.env.ANTHROPIC_API_KEY = apiKey;
+        // Initialize Anthropic with proper configuration
         this.model = anthropic(this.modelName || getDefaultAnthropicModel());
         logger.debug("Anthropic Provider v2 initialized", {
             modelName: this.modelName,

package/dist/providers/googleAiStudio.js

@@ -6,6 +6,7 @@ import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 // Environment variable setup
 if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY &&
     process.env.GOOGLE_AI_API_KEY) {
@@ -62,6 +63,7 @@ export class GoogleAIStudioProvider extends BaseProvider {
     // executeGenerate removed - BaseProvider handles all generation with tools
     async executeStream(options, analysisSchema) {
         this.validateStreamOptions(options);
+        const startTime = Date.now();
         const apiKey = this.getApiKey();
         const google = createGoogleGenerativeAI({ apiKey });
         const model = google(this.modelName);
@@ -85,13 +87,24 @@ export class GoogleAIStudioProvider extends BaseProvider {
                     yield { content: chunk };
                 }
             };
+            // Create analytics promise that resolves after stream completion
+            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
+                requestId: `google-ai-stream-${Date.now()}`,
+                streamingMode: true,
+            });
             return {
                 stream: transformedStream(),
                 provider: this.providerName,
                 model: this.modelName,
+                analytics: analyticsPromise,
+                metadata: {
+                    startTime,
+                    streamId: `google-ai-${Date.now()}`,
+                },
             };
         }
         catch (error) {
+            timeoutController?.cleanup();
             throw this.handleProviderError(error);
         }
     }

package/dist/providers/huggingFace.js

@@ -54,9 +54,21 @@ export class HuggingFaceProvider extends BaseProvider {
      * @returns false to disable tools by default until proper implementation
      */
     supportsTools() {
-        // TODO: Implement proper HuggingFace tool calling support
-        // Requires: Custom tool schema formatting, response parsing, execution flow
-        // Track models that support function calling: CodeLlama, Llama variants
+        // IMPLEMENTATION STATUS (2025): HuggingFace tool calling remains limited
+        //
+        // Current State:
+        // - Function calling varies significantly across HF models
+        // - Many models treat tool schemas as conversation context
+        // - Requires model-specific implementation per architecture
+        //
+        // To Enable Tools:
+        // 1. Detect model capability via HF model card metadata
+        // 2. Implement model-specific tool schema formatting
+        // 3. Add custom response parsing for function call extraction
+        // 4. Create validation framework for tool parameter handling
+        // 5. Test extensively with supported models (Code Llama, Llama 3.1+)
+        //
+        // Until comprehensive implementation, tools disabled for reliability
         return false;
     }
     // executeGenerate removed - BaseProvider handles all generation with tools

package/dist/providers/mistral.js

@@ -4,6 +4,7 @@ import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createAnalytics } from "../core/analytics.js";
 import { validateApiKey, createMistralConfig, getProviderModel, } from "../utils/providerConfig.js";
+import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 // Configuration helpers - now using consolidated utility
 const getMistralApiKey = () => {
     return validateApiKey(createMistralConfig());
@@ -86,22 +87,33 @@ export class MistralProvider extends BaseProvider {
     async executeStream(options) {
         const startTime = Date.now();
         try {
-            const stream = await streamText({
+            const result = await streamText({
                 model: this.model,
-                prompt: options.prompt || "",
+                prompt: options.input.text,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens,
+                tools: options.tools,
+                toolChoice: "auto",
+            });
+            // Transform stream to match StreamResult interface
+            const transformedStream = async function* () {
+                for await (const chunk of result.textStream) {
+                    yield { content: chunk };
+                }
+            };
+            // Create analytics promise that resolves after stream completion
+            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
+                requestId: `mistral-stream-${Date.now()}`,
+                streamingMode: true,
             });
             return {
-                stream: (async function* () {
-                    for await (const chunk of stream.textStream) {
-                        yield { content: chunk };
-                    }
-                })(),
+                stream: transformedStream(),
                 provider: this.providerName,
                 model: this.modelName,
+                analytics: analyticsPromise,
                 metadata: {
                     startTime,
+                    streamId: `mistral-${Date.now()}`,
                 },
             };
         }

package/dist/providers/ollama.js

@@ -58,6 +58,9 @@ class OllamaLanguageModel {
         const messages = options
             .messages || [];
         const prompt = this.convertMessagesToPrompt(messages);
+        // Debug: Log what's being sent to Ollama
+        logger.debug("[OllamaLanguageModel] Messages:", JSON.stringify(messages, null, 2));
+        logger.debug("[OllamaLanguageModel] Converted Prompt:", JSON.stringify(prompt));
         const response = await fetch(`${this.baseUrl}/api/generate`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -77,12 +80,15 @@ class OllamaLanguageModel {
             throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
         }
         const data = await response.json();
+        // Debug: Log Ollama API response to understand empty content issue
+        logger.debug("[OllamaLanguageModel] API Response:", JSON.stringify(data, null, 2));
         return {
             text: data.response,
             usage: {
-                promptTokens: this.estimateTokens(prompt),
-                completionTokens: this.estimateTokens(data.response),
-                totalTokens: this.estimateTokens(prompt) + this.estimateTokens(data.response),
+                promptTokens: data.prompt_eval_count || this.estimateTokens(prompt),
+                completionTokens: data.eval_count || this.estimateTokens(data.response),
+                totalTokens: (data.prompt_eval_count || this.estimateTokens(prompt)) +
+                    (data.eval_count || this.estimateTokens(data.response)),
             },
             finishReason: "stop",
             rawCall: {
@@ -179,7 +185,8 @@ class OllamaLanguageModel {
                                     type: "finish",
                                     finishReason: "stop",
                                     usage: {
-                                        promptTokens: this.estimateTokens(data.context || ""),
+                                        promptTokens: data.prompt_eval_count ||
+                                            this.estimateTokens(data.context || ""),
                                         completionTokens: data.eval_count || 0,
                                     },
                                 };
@@ -263,9 +270,26 @@ export class OllamaProvider extends BaseProvider {
      * @returns false to disable tools by default
      */
     supportsTools() {
-        // TODO: Fix the OllamaLanguageModel integration with BaseProvider for tool support.
-        //       Track progress on resolving this issue. See the detailed steps above.
-        //       Issue tracking required for enabling tool support
+        // IMPLEMENTATION STATUS (2025): Ollama function calling actively evolving
+        //
+        // Current State:
+        // - Function calling added in Ollama 2024, improving in 2025
+        // - Requires compatible models (Llama 3.1+, Code Llama variants)
+        // - AI SDK integration needs custom adapter for Ollama's tool format
+        //
+        // Technical Requirements:
+        // 1. Replace AI SDK with direct Ollama API tool calls
+        // 2. Implement Ollama-specific tool schema conversion
+        // 3. Add function response parsing from Ollama's JSON format
+        // 4. Handle streaming tool calls with incremental parsing
+        // 5. Validate model compatibility before enabling tools
+        //
+        // Implementation Path:
+        // - Use Ollama's chat API with 'tools' parameter
+        // - Parse tool_calls from response.message.tool_calls
+        // - Execute functions and return results to conversation
+        //
+        // Until Ollama-specific implementation, tools disabled for compatibility
         return false;
     }
     // executeGenerate removed - BaseProvider handles all generation with tools

package/dist/providers/openAI.js

@@ -6,6 +6,7 @@ import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
 import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
 import { validateApiKey, createOpenAIConfig, getProviderModel, } from "../utils/providerConfig.js";
+import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 // Configuration helpers - now using consolidated utility
 const getOpenAIApiKey = () => {
     return validateApiKey(createOpenAIConfig());
@@ -69,6 +70,7 @@ export class OpenAIProvider extends BaseProvider {
      */
     async executeStream(options, analysisSchema) {
         this.validateStreamOptions(options);
+        const startTime = Date.now();
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
@@ -89,10 +91,20 @@ export class OpenAIProvider extends BaseProvider {
                     yield { content: chunk };
                 }
             };
+            // Create analytics promise that resolves after stream completion
+            const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
+                requestId: `openai-stream-${Date.now()}`,
+                streamingMode: true,
+            });
             return {
                 stream: transformedStream(),
                 provider: this.providerName,
                 model: this.modelName,
+                analytics: analyticsPromise,
+                metadata: {
+                    startTime,
+                    streamId: `openai-${Date.now()}`,
+                },
             };
         }
         catch (error) {

package/dist/sdk/toolRegistration.js

@@ -140,6 +140,13 @@ export function validateTool(name, tool) {
             `Received: ${typeof tool.execute}. ` +
             `Example: { execute: async (params) => { return { success: true, data: result }; } }`);
     }
+    // Check for common mistake: using 'schema' instead of 'parameters'
+    if ("schema" in tool && !("parameters" in tool)) {
+        throw new Error(`Tool '${name}' uses 'schema' property, but NeuroLink expects 'parameters'. ` +
+            `Please change 'schema' to 'parameters' and use a Zod schema: ` +
+            `{ parameters: z.object({ ... }), execute: ... } ` +
+            `See documentation: https://docs.neurolink.com/tools`);
+    }
     // Validate parameters schema if provided - support both Zod and custom schemas
     if (tool.parameters) {
         if (typeof tool.parameters !== "object") {
@@ -151,6 +158,16 @@ export function validateTool(name, tool) {
         const hasValidationMethod = typeof params.parse === "function" ||
             typeof params.validate === "function" ||
             "_def" in params; // Zod schemas have _def property
+        // Check for plain JSON schema objects (common mistake)
+        if ("type" in params && "properties" in params && !hasValidationMethod) {
+            throw new Error(`Tool '${name}' appears to use a plain JSON schema object as parameters. ` +
+                `NeuroLink requires a Zod schema for proper type validation and tool integration. ` +
+                `Please change from:\n` +
+                `  { type: 'object', properties: { ... } }\n` +
+                `To:\n` +
+                `  z.object({ fieldName: z.string() })\n` +
+                `Import Zod with: import { z } from 'zod'`);
+        }
         if (!hasValidationMethod) {
             const errorMessage = typeof params.parse === "function" || "_def" in params
                 ? `Tool '${name}' has a Zod-like schema but validation failed. Ensure it's a valid Zod schema: z.object({ ... })`

package/dist/types/cli.d.ts

@@ -67,21 +67,76 @@ export interface StreamCommandArgs extends BaseCommandArgs {
     disableTools?: boolean;
 }
 /**
- * MCP command arguments
+ * MCP command arguments - Enhanced with transport and server management
  */
 export interface MCPCommandArgs extends BaseCommandArgs {
     /** MCP server name */
     server?: string;
+    /** MCP server name (alias for server) */
+    serverName?: string;
     /** Tool name to execute */
     tool?: string;
     /** Tool parameters as JSON string */
     params?: string;
     /** List available tools */
     list?: boolean;
+    /** List only specific category */
+    listOnly?: boolean;
     /** Discover MCP servers */
     discover?: boolean;
     /** Show server information */
     info?: boolean;
+    /** Transport type for server connection */
+    transport?: "stdio" | "websocket" | "tcp" | "unix";
+    /** Server description */
+    description?: string;
+    /** Command/executable for stdio transport */
+    command?: string;
+    /** Arguments for server command */
+    args?: string[];
+    /** Environment variables for server (JSON string) */
+    env?: string;
+    /** Server URL for network transports */
+    url?: string;
+    /** Server name for add command */
+    name?: string;
+    /** Show detailed information */
+    detailed?: boolean;
+    /** Force operation without confirmation */
+    force?: boolean;
+    /** Auto install discovered servers */
+    autoInstall?: boolean;
+    /** Discovery source */
+    source?: string;
+    /** Connection timeout */
+    timeout?: number;
+}
+/**
+ * Models command arguments - Enhanced for model management
+ */
+export interface ModelsCommandArgs extends BaseCommandArgs {
+    /** AI provider to query */
+    provider?: string;
+    /** Model capability filter */
+    query?: string;
+    /** Model use case filter */
+    useCase?: string;
+    /** Require vision capability */
+    requireVision?: boolean;
+    /** Require function calling capability */
+    requireFunctionCalling?: boolean;
+    /** List all available models */
+    list?: boolean;
+    /** Show model statistics */
+    stats?: boolean;
+    /** Show model pricing */
+    pricing?: boolean;
+    /** Resolve best model for criteria */
+    resolve?: boolean;
+    /** Maximum cost filter */
+    maxCost?: number;
+    /** Maximum tokens filter */
+    maxTokens?: number;
 }
 /**
  * Ollama command arguments