@juspay/neurolink 7.25.0 → 7.26.1

package/dist/cli/index.js

@@ -11,8 +11,6 @@ import chalk from "chalk";
 import _fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
-import { addOllamaCommands } from "./commands/ollama.js";
-import { addSageMakerCommands } from "./commands/sagemaker.js";
 import { CLICommandFactory } from "./factories/commandFactory.js";
 import { AuthenticationError, AuthorizationError, NetworkError, RateLimitError, } from "../lib/types/errors.js";
 import { logger } from "../lib/utils/logger.js";
@@ -178,11 +176,11 @@ const cli = yargs(args)
     // Validate Command (alias for config validate)
     .command(CLICommandFactory.createValidateCommand())
     // Completion Command - Using CLICommandFactory
-    .command(CLICommandFactory.createCompletionCommand());
-// Add Ollama Commands
-addOllamaCommands(cli);
-// Add SageMaker Commands
-addSageMakerCommands(cli);
+    .command(CLICommandFactory.createCompletionCommand())
+    // Ollama Command Group - Using CLICommandFactory
+    .command(CLICommandFactory.createOllamaCommands())
+    // SageMaker Command Group - Using CLICommandFactory
+    .command(CLICommandFactory.createSageMakerCommands());
 // Execute CLI
 (async () => {
     try {

package/dist/core/baseProvider.js

@@ -9,6 +9,8 @@ import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { buildMessagesArray } from "../utils/messageBuilder.js";
 import { getKeysAsString, getKeyCount } from "../utils/transformationUtils.js";
 import { validateStreamOptions as validateStreamOpts, validateTextGenerationOptions, ValidationError, createValidationSummary, } from "../utils/parameterValidation.js";
+import { recordProviderPerformanceFromMetrics, getPerformanceOptimizedProvider, } from "./evaluationProviders.js";
+import { modelConfig } from "./modelConfiguration.js";
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -182,6 +184,46 @@ export class BaseProvider {
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || 8192,
             });
+            const responseTime = Date.now() - startTime;
+            try {
+                // Calculate actual cost based on token usage and provider configuration
+                const calculateActualCost = () => {
+                    try {
+                        const costInfo = modelConfig.getCostInfo(this.providerName, this.modelName);
+                        if (!costInfo) {
+                            return 0; // No cost info available
+                        }
+                        const promptTokens = result.usage?.promptTokens || 0;
+                        const completionTokens = result.usage?.completionTokens || 0;
+                        // Calculate cost per 1K tokens
+                        const inputCost = (promptTokens / 1000) * costInfo.input;
+                        const outputCost = (completionTokens / 1000) * costInfo.output;
+                        return inputCost + outputCost;
+                    }
+                    catch (error) {
+                        logger.debug(`Cost calculation failed for ${this.providerName}:`, error);
+                        return 0; // Fallback to 0 on any error
+                    }
+                };
+                const actualCost = calculateActualCost();
+                recordProviderPerformanceFromMetrics(this.providerName, {
+                    responseTime,
+                    tokensGenerated: result.usage?.totalTokens || 0,
+                    cost: actualCost,
+                    success: true,
+                });
+                // Show what the system learned (updated to include cost)
+                const optimizedProvider = getPerformanceOptimizedProvider("speed");
+                logger.debug(`🚀 Performance recorded for ${this.providerName}:`, {
+                    responseTime: `${responseTime}ms`,
+                    tokens: result.usage?.totalTokens || 0,
+                    estimatedCost: `$${actualCost.toFixed(6)}`,
+                    recommendedSpeedProvider: optimizedProvider?.provider || "none",
+                });
+            }
+            catch (perfError) {
+                logger.warn("⚠️ Performance recording failed:", perfError);
+            }
             // Extract tool names from tool calls for tracking
             // AI SDK puts tool calls in steps array for multi-step generation
             const toolsUsed = [];

package/dist/core/evaluationProviders.d.ts

@@ -32,3 +32,29 @@ export declare function isProviderAvailable(providerName: string): boolean;
  * Get the best available provider based on preference
  */
 export declare function getBestAvailableProvider(preferCheap?: boolean): ProviderModelConfig | null;
+/**
+ Record actual provider performance for optimization
+ */
+export declare function recordProviderPerformanceFromMetrics(providerName: string, metrics: {
+    responseTime: number;
+    tokensGenerated: number;
+    cost: number;
+    success: boolean;
+}): void;
+/**
+ * Get performance-optimized provider based on real metrics
+ */
+export declare function getPerformanceOptimizedProvider(priority?: "speed" | "cost" | "reliability"): ProviderModelConfig | null;
+export declare function getProviderPerformanceAnalytics(): Record<string, {
+    avgResponseTime: number;
+    successRate: number;
+    tokenThroughput: number;
+    costEfficiency: number;
+    recommendation: string;
+    sampleCount: number;
+}>;
+/**
+ * Reset performance metrics for a provider or all providers.
+ * @param providerName - (Optional) The name of the provider to reset. If omitted, resets all providers.
+ */
+export declare function resetProviderMetrics(providerName?: string): void;

package/dist/core/evaluationProviders.js

@@ -1,4 +1,11 @@
 import { modelConfig } from "./modelConfiguration.js";
+const PERFORMANCE_THRESHOLDS = {
+    EXCELLENT_SUCCESS_RATE: 0.95,
+    EXCELLENT_RESPONSE_TIME_MS: 2000,
+    GOOD_SUCCESS_RATE: 0.9,
+    FAIR_SUCCESS_RATE: 0.8,
+};
+const providerMetrics = new Map();
 /**
  * Convert new configuration format to legacy format for backwards compatibility
  */
@@ -101,3 +108,156 @@ export function getBestAvailableProvider(preferCheap = true) {
     const sortedProviders = sortProvidersByPreference(availableProviders, preferCheap);
     return sortedProviders[0];
 }
+/**
+ Record actual provider performance for optimization
+ */
+export function recordProviderPerformanceFromMetrics(providerName, metrics) {
+    const existing = providerMetrics.get(providerName) || {
+        responseTime: [],
+        successRate: 0,
+        tokenThroughput: 0,
+        costEfficiency: 0,
+        lastUpdated: new Date(),
+        sampleCount: 0,
+    };
+    // Keep rolling window of last 50 response times
+    existing.responseTime.push(metrics.responseTime);
+    if (existing.responseTime.length > 50) {
+        existing.responseTime.shift();
+    }
+    // Update success rate
+    const totalSamples = existing.sampleCount + 1;
+    existing.successRate =
+        (existing.successRate * existing.sampleCount + (metrics.success ? 1 : 0)) /
+            totalSamples;
+    // Update throughput (tokens per second)
+    if (metrics.responseTime > 0) {
+        const tokensPerSecond = metrics.tokensGenerated / (metrics.responseTime / 1000);
+        existing.tokenThroughput =
+            (existing.tokenThroughput * existing.sampleCount + tokensPerSecond) /
+                totalSamples;
+    }
+    // If responseTime is 0, skip updating tokenThroughput for this sample
+    // but still update other metrics
+    // Update cost efficiency (tokens per dollar)
+    if (metrics.cost > 0) {
+        const tokensPerDollar = metrics.tokensGenerated / metrics.cost;
+        existing.costEfficiency =
+            (existing.costEfficiency * existing.sampleCount + tokensPerDollar) /
+                totalSamples;
+    }
+    existing.sampleCount = totalSamples;
+    existing.lastUpdated = new Date();
+    providerMetrics.set(providerName, existing);
+}
+/**
+ * Get performance-optimized provider based on real metrics
+ */
+export function getPerformanceOptimizedProvider(priority = "speed") {
+    const availableProviders = getAvailableProviders();
+    if (availableProviders.length === 0) {
+        return null;
+    }
+    // Score providers based on real performance data
+    const scoredProviders = availableProviders.map((provider) => {
+        const metrics = providerMetrics.get(provider.provider);
+        if (!metrics || metrics.sampleCount < 3) {
+            // Fall back to static performance ratings for providers without data
+            return {
+                provider,
+                score: getStaticPerformanceScore(provider, priority),
+                metrics: null,
+            };
+        }
+        let score = 0;
+        switch (priority) {
+            case "speed": {
+                const avgResponseTime = metrics.responseTime.reduce((a, b) => a + b, 0) /
+                    metrics.responseTime.length;
+                score =
+                    metrics.tokenThroughput * 0.6 +
+                        (5000 / Math.max(avgResponseTime, 100)) * 0.4;
+                break;
+            }
+            case "cost": {
+                score = metrics.costEfficiency * 0.7 + metrics.successRate * 0.3;
+                break;
+            }
+            case "reliability": {
+                score = metrics.successRate * 0.8 + (metrics.sampleCount / 100) * 0.2;
+                break;
+            }
+        }
+        return { provider, score, metrics };
+    });
+    // Sort by score and return best
+    scoredProviders.sort((a, b) => b.score - a.score);
+    return scoredProviders[0].provider;
+}
+/**
+ * Helper function for providers without performance data
+ */
+function getStaticPerformanceScore(provider, priority) {
+    switch (priority) {
+        case "speed": {
+            const speedScore = provider.performance?.speed || 1;
+            return speedScore;
+        }
+        case "cost": {
+            const costScore = provider.performance?.cost || 1;
+            return costScore;
+        }
+        case "reliability": {
+            const qualityScore = provider.performance?.quality || 1;
+            return qualityScore;
+        }
+        default: {
+            throw new Error(`Invalid priority: "${priority}". Must be one of: speed, cost, reliability`);
+        }
+    }
+}
+export function getProviderPerformanceAnalytics() {
+    const analytics = {};
+    for (const [providerName, metrics] of providerMetrics.entries()) {
+        if (metrics.sampleCount === 0) {
+            continue;
+        }
+        const avgResponseTime = metrics.responseTime.reduce((a, b) => a + b, 0) /
+            metrics.responseTime.length;
+        let recommendation = "";
+        if (metrics.successRate > PERFORMANCE_THRESHOLDS.EXCELLENT_SUCCESS_RATE &&
+            avgResponseTime < PERFORMANCE_THRESHOLDS.EXCELLENT_RESPONSE_TIME_MS) {
+            recommendation = "Excellent - Recommended for production";
+        }
+        else if (metrics.successRate > PERFORMANCE_THRESHOLDS.GOOD_SUCCESS_RATE) {
+            recommendation = "Good - Suitable for most tasks";
+        }
+        else if (metrics.successRate > PERFORMANCE_THRESHOLDS.FAIR_SUCCESS_RATE) {
+            recommendation = "Fair - Monitor closely";
+        }
+        else {
+            recommendation = "Poor - Consider alternative providers";
+        }
+        analytics[providerName] = {
+            avgResponseTime,
+            successRate: metrics.successRate,
+            tokenThroughput: metrics.tokenThroughput,
+            costEfficiency: metrics.costEfficiency,
+            recommendation,
+            sampleCount: metrics.sampleCount,
+        };
+    }
+    return analytics;
+}
+/**
+ * Reset performance metrics for a provider or all providers.
+ * @param providerName - (Optional) The name of the provider to reset. If omitted, resets all providers.
+ */
+export function resetProviderMetrics(providerName) {
+    if (providerName) {
+        providerMetrics.delete(providerName);
+    }
+    else {
+        providerMetrics.clear();
+    }
+}

package/dist/lib/core/baseProvider.js

@@ -9,6 +9,8 @@ import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { buildMessagesArray } from "../utils/messageBuilder.js";
 import { getKeysAsString, getKeyCount } from "../utils/transformationUtils.js";
 import { validateStreamOptions as validateStreamOpts, validateTextGenerationOptions, ValidationError, createValidationSummary, } from "../utils/parameterValidation.js";
+import { recordProviderPerformanceFromMetrics, getPerformanceOptimizedProvider, } from "./evaluationProviders.js";
+import { modelConfig } from "./modelConfiguration.js";
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -182,6 +184,46 @@ export class BaseProvider {
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || 8192,
             });
+            const responseTime = Date.now() - startTime;
+            try {
+                // Calculate actual cost based on token usage and provider configuration
+                const calculateActualCost = () => {
+                    try {
+                        const costInfo = modelConfig.getCostInfo(this.providerName, this.modelName);
+                        if (!costInfo) {
+                            return 0; // No cost info available
+                        }
+                        const promptTokens = result.usage?.promptTokens || 0;
+                        const completionTokens = result.usage?.completionTokens || 0;
+                        // Calculate cost per 1K tokens
+                        const inputCost = (promptTokens / 1000) * costInfo.input;
+                        const outputCost = (completionTokens / 1000) * costInfo.output;
+                        return inputCost + outputCost;
+                    }
+                    catch (error) {
+                        logger.debug(`Cost calculation failed for ${this.providerName}:`, error);
+                        return 0; // Fallback to 0 on any error
+                    }
+                };
+                const actualCost = calculateActualCost();
+                recordProviderPerformanceFromMetrics(this.providerName, {
+                    responseTime,
+                    tokensGenerated: result.usage?.totalTokens || 0,
+                    cost: actualCost,
+                    success: true,
+                });
+                // Show what the system learned (updated to include cost)
+                const optimizedProvider = getPerformanceOptimizedProvider("speed");
+                logger.debug(`🚀 Performance recorded for ${this.providerName}:`, {
+                    responseTime: `${responseTime}ms`,
+                    tokens: result.usage?.totalTokens || 0,
+                    estimatedCost: `$${actualCost.toFixed(6)}`,
+                    recommendedSpeedProvider: optimizedProvider?.provider || "none",
+                });
+            }
+            catch (perfError) {
+                logger.warn("⚠️ Performance recording failed:", perfError);
+            }
             // Extract tool names from tool calls for tracking
             // AI SDK puts tool calls in steps array for multi-step generation
             const toolsUsed = [];

package/dist/lib/core/evaluationProviders.d.ts

@@ -32,3 +32,29 @@ export declare function isProviderAvailable(providerName: string): boolean;
  * Get the best available provider based on preference
  */
 export declare function getBestAvailableProvider(preferCheap?: boolean): ProviderModelConfig | null;
+/**
+ Record actual provider performance for optimization
+ */
+export declare function recordProviderPerformanceFromMetrics(providerName: string, metrics: {
+    responseTime: number;
+    tokensGenerated: number;
+    cost: number;
+    success: boolean;
+}): void;
+/**
+ * Get performance-optimized provider based on real metrics
+ */
+export declare function getPerformanceOptimizedProvider(priority?: "speed" | "cost" | "reliability"): ProviderModelConfig | null;
+export declare function getProviderPerformanceAnalytics(): Record<string, {
+    avgResponseTime: number;
+    successRate: number;
+    tokenThroughput: number;
+    costEfficiency: number;
+    recommendation: string;
+    sampleCount: number;
+}>;
+/**
+ * Reset performance metrics for a provider or all providers.
+ * @param providerName - (Optional) The name of the provider to reset. If omitted, resets all providers.
+ */
+export declare function resetProviderMetrics(providerName?: string): void;

package/dist/lib/core/evaluationProviders.js

@@ -1,4 +1,11 @@
 import { modelConfig } from "./modelConfiguration.js";
+const PERFORMANCE_THRESHOLDS = {
+    EXCELLENT_SUCCESS_RATE: 0.95,
+    EXCELLENT_RESPONSE_TIME_MS: 2000,
+    GOOD_SUCCESS_RATE: 0.9,
+    FAIR_SUCCESS_RATE: 0.8,
+};
+const providerMetrics = new Map();
 /**
  * Convert new configuration format to legacy format for backwards compatibility
  */
@@ -101,3 +108,156 @@ export function getBestAvailableProvider(preferCheap = true) {
     const sortedProviders = sortProvidersByPreference(availableProviders, preferCheap);
     return sortedProviders[0];
 }
+/**
+ Record actual provider performance for optimization
+ */
+export function recordProviderPerformanceFromMetrics(providerName, metrics) {
+    const existing = providerMetrics.get(providerName) || {
+        responseTime: [],
+        successRate: 0,
+        tokenThroughput: 0,
+        costEfficiency: 0,
+        lastUpdated: new Date(),
+        sampleCount: 0,
+    };
+    // Keep rolling window of last 50 response times
+    existing.responseTime.push(metrics.responseTime);
+    if (existing.responseTime.length > 50) {
+        existing.responseTime.shift();
+    }
+    // Update success rate
+    const totalSamples = existing.sampleCount + 1;
+    existing.successRate =
+        (existing.successRate * existing.sampleCount + (metrics.success ? 1 : 0)) /
+            totalSamples;
+    // Update throughput (tokens per second)
+    if (metrics.responseTime > 0) {
+        const tokensPerSecond = metrics.tokensGenerated / (metrics.responseTime / 1000);
+        existing.tokenThroughput =
+            (existing.tokenThroughput * existing.sampleCount + tokensPerSecond) /
+                totalSamples;
+    }
+    // If responseTime is 0, skip updating tokenThroughput for this sample
+    // but still update other metrics
+    // Update cost efficiency (tokens per dollar)
+    if (metrics.cost > 0) {
+        const tokensPerDollar = metrics.tokensGenerated / metrics.cost;
+        existing.costEfficiency =
+            (existing.costEfficiency * existing.sampleCount + tokensPerDollar) /
+                totalSamples;
+    }
+    existing.sampleCount = totalSamples;
+    existing.lastUpdated = new Date();
+    providerMetrics.set(providerName, existing);
+}
+/**
+ * Get performance-optimized provider based on real metrics
+ */
+export function getPerformanceOptimizedProvider(priority = "speed") {
+    const availableProviders = getAvailableProviders();
+    if (availableProviders.length === 0) {
+        return null;
+    }
+    // Score providers based on real performance data
+    const scoredProviders = availableProviders.map((provider) => {
+        const metrics = providerMetrics.get(provider.provider);
+        if (!metrics || metrics.sampleCount < 3) {
+            // Fall back to static performance ratings for providers without data
+            return {
+                provider,
+                score: getStaticPerformanceScore(provider, priority),
+                metrics: null,
+            };
+        }
+        let score = 0;
+        switch (priority) {
+            case "speed": {
+                const avgResponseTime = metrics.responseTime.reduce((a, b) => a + b, 0) /
+                    metrics.responseTime.length;
+                score =
+                    metrics.tokenThroughput * 0.6 +
+                        (5000 / Math.max(avgResponseTime, 100)) * 0.4;
+                break;
+            }
+            case "cost": {
+                score = metrics.costEfficiency * 0.7 + metrics.successRate * 0.3;
+                break;
+            }
+            case "reliability": {
+                score = metrics.successRate * 0.8 + (metrics.sampleCount / 100) * 0.2;
+                break;
+            }
+        }
+        return { provider, score, metrics };
+    });
+    // Sort by score and return best
+    scoredProviders.sort((a, b) => b.score - a.score);
+    return scoredProviders[0].provider;
+}
+/**
+ * Helper function for providers without performance data
+ */
+function getStaticPerformanceScore(provider, priority) {
+    switch (priority) {
+        case "speed": {
+            const speedScore = provider.performance?.speed || 1;
+            return speedScore;
+        }
+        case "cost": {
+            const costScore = provider.performance?.cost || 1;
+            return costScore;
+        }
+        case "reliability": {
+            const qualityScore = provider.performance?.quality || 1;
+            return qualityScore;
+        }
+        default: {
+            throw new Error(`Invalid priority: "${priority}". Must be one of: speed, cost, reliability`);
+        }
+    }
+}
+export function getProviderPerformanceAnalytics() {
+    const analytics = {};
+    for (const [providerName, metrics] of providerMetrics.entries()) {
+        if (metrics.sampleCount === 0) {
+            continue;
+        }
+        const avgResponseTime = metrics.responseTime.reduce((a, b) => a + b, 0) /
+            metrics.responseTime.length;
+        let recommendation = "";
+        if (metrics.successRate > PERFORMANCE_THRESHOLDS.EXCELLENT_SUCCESS_RATE &&
+            avgResponseTime < PERFORMANCE_THRESHOLDS.EXCELLENT_RESPONSE_TIME_MS) {
+            recommendation = "Excellent - Recommended for production";
+        }
+        else if (metrics.successRate > PERFORMANCE_THRESHOLDS.GOOD_SUCCESS_RATE) {
+            recommendation = "Good - Suitable for most tasks";
+        }
+        else if (metrics.successRate > PERFORMANCE_THRESHOLDS.FAIR_SUCCESS_RATE) {
+            recommendation = "Fair - Monitor closely";
+        }
+        else {
+            recommendation = "Poor - Consider alternative providers";
+        }
+        analytics[providerName] = {
+            avgResponseTime,
+            successRate: metrics.successRate,
+            tokenThroughput: metrics.tokenThroughput,
+            costEfficiency: metrics.costEfficiency,
+            recommendation,
+            sampleCount: metrics.sampleCount,
+        };
+    }
+    return analytics;
+}
+/**
+ * Reset performance metrics for a provider or all providers.
+ * @param providerName - (Optional) The name of the provider to reset. If omitted, resets all providers.
+ */
+export function resetProviderMetrics(providerName) {
+    if (providerName) {
+        providerMetrics.delete(providerName);
+    }
+    else {
+        providerMetrics.clear();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.25.0",
+  "version": "7.26.1",
   "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",

package/dist/cli/commands/ollama.d.ts

@@ -1,3 +0,0 @@
-import type { Argv } from "yargs";
-export declare function addOllamaCommands(cli: Argv): void;
-export default addOllamaCommands;