@juspay/neurolink 7.6.1 → 7.7.1

package/dist/core/baseProvider.js

@@ -1,6 +1,7 @@
 import { logger } from "../utils/logger.js";
 import { SYSTEM_LIMITS } from "../core/constants.js";
 import { directAgentTools } from "../agent/directTools.js";
+import { getSafeMaxTokens } from "../utils/tokenLimits.js";
 /**
  * Validates if a result contains a valid toolsObject structure
  * @param result - The result object to validate
@@ -192,6 +193,29 @@ export class BaseProvider {
             }
             // Remove duplicates
             const uniqueToolsUsed = [...new Set(toolsUsed)];
+            // ✅ Extract tool executions from AI SDK result
+            const toolExecutions = [];
+            // Extract tool executions from AI SDK result steps
+            // Extract tool executions from steps (where tool results are stored)
+            if (result.steps &&
+                Array.isArray(result.steps)) {
+                for (const step of result.steps ||
+                    []) {
+                    // Focus only on tool results (which have complete execution data)
+                    // Tool calls are just the requests, tool results contain the actual execution data
+                    if (step?.toolResults && Array.isArray(step.toolResults)) {
+                        for (const toolResult of step.toolResults) {
+                            const trRecord = toolResult;
+                            toolExecutions.push({
+                                name: trRecord.toolName || "unknown",
+                                input: trRecord.args || {},
+                                output: trRecord.result || "success",
+                                duration: 0, // AI SDK doesn't track duration
+                            });
+                        }
+                    }
+                }
+            }
             // Format the result with tool executions included
             const enhancedResult = {
                 content: result.text,
@@ -217,6 +241,7 @@ export class BaseProvider {
                     : [],
                 toolResults: result.toolResults,
                 toolsUsed: uniqueToolsUsed,
+                toolExecutions, // ✅ Add extracted tool executions
             };
             // Enhanced result with analytics and evaluation
             return await this.enhanceResult(enhancedResult, options, startTime);
@@ -327,33 +352,47 @@ export class BaseProvider {
     // ===================
     normalizeTextOptions(optionsOrPrompt) {
         if (typeof optionsOrPrompt === "string") {
+            const safeMaxTokens = getSafeMaxTokens(this.providerName, this.modelName);
             return {
                 prompt: optionsOrPrompt,
                 provider: this.providerName,
                 model: this.modelName,
+                maxTokens: safeMaxTokens,
             };
         }
         // Handle both prompt and input.text formats
         const prompt = optionsOrPrompt.prompt || optionsOrPrompt.input?.text || "";
+        const modelName = optionsOrPrompt.model || this.modelName;
+        const providerName = optionsOrPrompt.provider || this.providerName;
+        // Apply safe maxTokens based on provider and model
+        const safeMaxTokens = getSafeMaxTokens(providerName, modelName, optionsOrPrompt.maxTokens);
         return {
             ...optionsOrPrompt,
             prompt,
-            provider: optionsOrPrompt.provider || this.providerName,
-            model: optionsOrPrompt.model || this.modelName,
+            provider: providerName,
+            model: modelName,
+            maxTokens: safeMaxTokens,
         };
     }
     normalizeStreamOptions(optionsOrPrompt) {
         if (typeof optionsOrPrompt === "string") {
+            const safeMaxTokens = getSafeMaxTokens(this.providerName, this.modelName);
             return {
                 input: { text: optionsOrPrompt },
                 provider: this.providerName,
                 model: this.modelName,
+                maxTokens: safeMaxTokens,
             };
         }
+        const modelName = optionsOrPrompt.model || this.modelName;
+        const providerName = optionsOrPrompt.provider || this.providerName;
+        // Apply safe maxTokens based on provider and model
+        const safeMaxTokens = getSafeMaxTokens(providerName, modelName, optionsOrPrompt.maxTokens);
         return {
             ...optionsOrPrompt,
-            provider: optionsOrPrompt.provider || this.providerName,
-            model: optionsOrPrompt.model || this.modelName,
+            provider: providerName,
+            model: modelName,
+            maxTokens: safeMaxTokens,
         };
     }
     async enhanceResult(result, options, startTime) {

package/dist/core/constants.d.ts

@@ -24,6 +24,52 @@ export declare const PROVIDER_CONFIG: {
         temperature: number;
     };
 };
+export declare const PROVIDER_MAX_TOKENS: {
+    anthropic: {
+        "claude-3-haiku-20240307": number;
+        "claude-3-5-sonnet-20241022": number;
+        "claude-3-opus-20240229": number;
+        "claude-3-5-sonnet-20240620": number;
+        default: number;
+    };
+    openai: {
+        "gpt-4o": number;
+        "gpt-4o-mini": number;
+        "gpt-3.5-turbo": number;
+        "gpt-4": number;
+        "gpt-4-turbo": number;
+        default: number;
+    };
+    "google-ai": {
+        "gemini-1.5-pro": number;
+        "gemini-1.5-flash": number;
+        "gemini-2.5-pro": number;
+        "gemini-2.5-flash": number;
+        "gemini-pro": number;
+        default: number;
+    };
+    vertex: {
+        "gemini-1.5-pro": number;
+        "gemini-1.5-flash": number;
+        "gemini-2.5-pro": number;
+        "gemini-2.5-flash": number;
+        "claude-4.0-sonnet": number;
+        default: number;
+    };
+    bedrock: {
+        "anthropic.claude-3-sonnet-20240229-v1:0": number;
+        "anthropic.claude-3-haiku-20240307-v1:0": number;
+        "anthropic.claude-3-5-sonnet-20240620-v1:0": number;
+        default: number;
+    };
+    ollama: {
+        default: number;
+    };
+    litellm: {
+        default: number;
+    };
+    default: number;
+};
 export declare const CLI_LIMITS: {
     maxTokens: {
         min: number;

package/dist/core/constants.js

@@ -27,6 +27,53 @@ export const PROVIDER_CONFIG = {
         temperature: 0.4,
     },
 };
+// Provider-specific maxTokens limits (discovered through testing)
+export const PROVIDER_MAX_TOKENS = {
+    anthropic: {
+        "claude-3-haiku-20240307": 4096,
+        "claude-3-5-sonnet-20241022": 4096,
+        "claude-3-opus-20240229": 4096,
+        "claude-3-5-sonnet-20240620": 4096,
+        default: 4096, // Conservative default for Anthropic
+    },
+    openai: {
+        "gpt-4o": 16384,
+        "gpt-4o-mini": 16384,
+        "gpt-3.5-turbo": 4096,
+        "gpt-4": 8192,
+        "gpt-4-turbo": 4096,
+        default: 8192, // OpenAI generally supports higher limits
+    },
+    "google-ai": {
+        "gemini-1.5-pro": 8192,
+        "gemini-1.5-flash": 8192,
+        "gemini-2.5-pro": 8192,
+        "gemini-2.5-flash": 8192,
+        "gemini-pro": 4096,
+        default: 4096, // Conservative default due to 500 errors at high limits
+    },
+    vertex: {
+        "gemini-1.5-pro": 8192,
+        "gemini-1.5-flash": 8192,
+        "gemini-2.5-pro": 8192,
+        "gemini-2.5-flash": 8192,
+        "claude-4.0-sonnet": 4096,
+        default: 4096,
+    },
+    bedrock: {
+        "anthropic.claude-3-sonnet-20240229-v1:0": 4096,
+        "anthropic.claude-3-haiku-20240307-v1:0": 4096,
+        "anthropic.claude-3-5-sonnet-20240620-v1:0": 4096,
+        default: 4096,
+    },
+    ollama: {
+        default: 8192, // Ollama typically supports higher limits
+    },
+    litellm: {
+        default: 4096, // Conservative default
+    },
+    default: 4096, // Safe default across all providers
+};
 // CLI Validation Limits
 export const CLI_LIMITS = {
     maxTokens: {

package/dist/core/dynamicModels.d.ts

@@ -102,8 +102,8 @@ declare const ModelRegistrySchema: z.ZodObject<{
         releaseDate: string;
     }>>;
     lastUpdated: string;
-    aliases?: Record<string, string> | undefined;
     defaults?: Record<string, string> | undefined;
+    aliases?: Record<string, string> | undefined;
 }, {
     version: string;
     models: Record<string, Record<string, {
@@ -119,8 +119,8 @@ declare const ModelRegistrySchema: z.ZodObject<{
         releaseDate: string;
     }>>;
     lastUpdated: string;
-    aliases?: Record<string, string> | undefined;
     defaults?: Record<string, string> | undefined;
+    aliases?: Record<string, string> | undefined;
 }>;
 export type ModelConfig = z.infer<typeof ModelConfigSchema>;
 export type ModelRegistry = z.infer<typeof ModelRegistrySchema>;
@@ -136,11 +136,23 @@ export declare class DynamicModelProvider {
     private constructor();
     static getInstance(): DynamicModelProvider;
     /**
-     * Initialize the model registry from multiple sources
+     * Initialize the model registry from multiple sources with timeout handling
+     * Addresses hanging issues when localhost:3001 is not running or GitHub URLs timeout
      */
     initialize(): Promise<void>;
     /**
-     * Load configuration from a source (URL or file path)
+     * Load configuration from a source with timeout handling
+     * Prevents hanging when local servers are down or network requests timeout
+     */
+    private loadFromSourceWithTimeout;
+    /**
+     * Quick health check for localhost endpoints
+     * Prevents hanging on non-responsive local servers
+     */
+    private healthCheckLocalhost;
+    /**
+     * Load configuration from a source (URL or file path) - Legacy method for compatibility
+     * @deprecated Use loadFromSourceWithTimeout instead
      */
     private loadFromSource;
     /**

package/dist/core/dynamicModels.js

@@ -39,60 +39,164 @@ export class DynamicModelProvider {
         return this.instance;
     }
     /**
-     * Initialize the model registry from multiple sources
+     * Initialize the model registry from multiple sources with timeout handling
+     * Addresses hanging issues when localhost:3001 is not running or GitHub URLs timeout
      */
     async initialize() {
         const sources = [
-            process.env.MODEL_CONFIG_URL || "http://localhost:3001/api/v1/models",
-            `https://raw.githubusercontent.com/${process.env.MODEL_CONFIG_GITHUB_REPO || "juspay/neurolink"}/${process.env.MODEL_CONFIG_GITHUB_BRANCH || "release"}/config/models.json`,
-            "./config/models.json", // Local fallback
+            {
+                url: process.env.MODEL_CONFIG_URL || "http://localhost:3001/api/v1/models",
+                timeout: 3000, // 3s for localhost
+                name: "local-server",
+            },
+            {
+                url: `https://raw.githubusercontent.com/${process.env.MODEL_CONFIG_GITHUB_REPO || "juspay/neurolink"}/${process.env.MODEL_CONFIG_GITHUB_BRANCH || "release"}/config/models.json`,
+                timeout: 5000, // 5s for GitHub
+                name: "github-raw",
+            },
+            {
+                url: "./config/models.json",
+                timeout: 1000, // 1s for local file
+                name: "local-file",
+            },
         ];
+        const errors = [];
         for (const source of sources) {
             try {
-                logger.debug(`[DynamicModelProvider] Attempting to load from: ${source}`);
-                const config = await this.loadFromSource(source);
+                logger.debug(`[DynamicModelProvider] Attempting to load from: ${source.url} (timeout: ${source.timeout}ms)`);
+                const config = await this.loadFromSourceWithTimeout(source.url, source.timeout);
                 // Validate the configuration
                 const validatedConfig = ModelRegistrySchema.parse(config);
                 this.modelRegistry = validatedConfig;
                 this.lastFetch = Date.now();
-                logger.info(`[DynamicModelProvider] Successfully loaded model registry from: ${source}`, {
+                logger.info(`[DynamicModelProvider] Successfully loaded model registry from: ${source.name}`, {
+                    source: source.url,
                     modelCount: this.getTotalModelCount(),
                     providerCount: Object.keys(validatedConfig.models).length,
+                    loadTime: `<${source.timeout}ms`,
                 });
                 return; // Success, stop trying other sources
             }
             catch (error) {
-                logger.warn(`[DynamicModelProvider] Failed to load from ${source}:`, error);
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                errors.push({ source: source.name, error: errorMessage });
+                logger.warn(`[DynamicModelProvider] Failed to load from ${source.name} (${source.url}):`, {
+                    error: errorMessage,
+                    timeout: source.timeout,
+                });
                 continue;
             }
         }
-        throw new Error("Failed to load model configuration from any source");
+        // Log all failures for debugging
+        logger.warn(`[DynamicModelProvider] All model configuration sources failed`, { errors });
+        throw new Error(`Failed to load model configuration from any source. Attempted: ${errors.map((e) => e.source).join(", ")}`);
     }
     /**
-     * Load configuration from a source (URL or file path)
+     * Load configuration from a source with timeout handling
+     * Prevents hanging when local servers are down or network requests timeout
      */
-    async loadFromSource(source) {
+    async loadFromSourceWithTimeout(source, timeoutMs) {
         if (source.startsWith("http")) {
-            // Load from URL
-            const response = await fetch(source, {
-                headers: {
-                    "User-Agent": "NeuroLink/1.0 (+https://github.com/juspay/neurolink)",
-                },
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            // Setup timeout and abort controller
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            try {
+                // Add health check for localhost before attempting full request
+                if (source.includes("localhost") || source.includes("127.0.0.1")) {
+                    await this.healthCheckLocalhost(source, Math.min(timeoutMs, 1000));
+                }
+                const response = await fetch(source, {
+                    headers: {
+                        "User-Agent": "NeuroLink/1.0 (+https://github.com/sachinsharma92/neurolink)",
+                        Accept: "application/json",
+                        "Cache-Control": "no-cache",
+                    },
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                const data = await response.json();
+                return data;
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                if (error instanceof Error && error.name === "AbortError") {
+                    throw new Error(`Request timeout after ${timeoutMs}ms`);
+                }
+                throw error;
             }
-            return response.json();
         }
         else {
-            // Load from local file
-            const fs = await import("fs");
-            const path = await import("path");
-            const fullPath = path.resolve(source);
-            const content = fs.readFileSync(fullPath, "utf8");
-            return JSON.parse(content);
+            // Load from local file with timeout (for very large files)
+            return new Promise((resolve, reject) => {
+                const timeoutId = setTimeout(() => {
+                    reject(new Error(`File read timeout after ${timeoutMs}ms`));
+                }, timeoutMs);
+                (async () => {
+                    try {
+                        const fs = await import("fs");
+                        const path = await import("path");
+                        const fullPath = path.resolve(source);
+                        // Check if file exists first
+                        if (!fs.existsSync(fullPath)) {
+                            throw new Error(`File not found: ${fullPath}`);
+                        }
+                        const content = fs.readFileSync(fullPath, "utf8");
+                        const data = JSON.parse(content);
+                        clearTimeout(timeoutId);
+                        resolve(data);
+                    }
+                    catch (error) {
+                        clearTimeout(timeoutId);
+                        reject(error);
+                    }
+                })();
+            });
         }
     }
+    /**
+     * Quick health check for localhost endpoints
+     * Prevents hanging on non-responsive local servers
+     */
+    async healthCheckLocalhost(url, timeoutMs) {
+        const healthUrl = url.replace(/\/api\/.*$/, "/health") || `${url}/health`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(healthUrl, {
+                method: "HEAD", // Lightweight request
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            // Don't throw on 404 - the main endpoint might still work
+            if (response.status >= 500) {
+                throw new Error(`Server error: ${response.status}`);
+            }
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new Error(`Localhost health check timeout - server may not be running`);
+            }
+            // For connection refused, throw a more specific error
+            if (error instanceof Error && error.message.includes("ECONNREFUSED")) {
+                throw new Error(`Localhost server not running at ${url}`);
+            }
+            // For other errors, let the main request handle them
+            logger.debug(`Health check failed for ${url}, proceeding with main request`, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Load configuration from a source (URL or file path) - Legacy method for compatibility
+     * @deprecated Use loadFromSourceWithTimeout instead
+     */
+    async loadFromSource(source) {
+        return this.loadFromSourceWithTimeout(source, 10000); // 10s default timeout
+    }
     /**
      * Get all available models for a provider
      */

package/dist/core/evaluation.js

@@ -5,6 +5,7 @@ import { logger } from "../utils/logger.js";
 import { AIProviderFactory } from "./factory.js";
 import { z } from "zod";
 import { ProviderRegistry } from "../factories/providerRegistry.js";
+import { modelConfig } from "./modelConfiguration.js";
 // Zod schema for validation
 const UnifiedEvaluationSchema = z.object({
     relevance: z.number().min(1).max(10),
@@ -152,7 +153,10 @@ export async function generateUnifiedEvaluation(context) {
         await ProviderRegistry.registerAllProviders();
         // Get evaluation provider
         const evaluationProvider = process.env.NEUROLINK_EVALUATION_PROVIDER || "google-ai";
-        const evaluationModel = process.env.NEUROLINK_EVALUATION_MODEL || "gemini-2.5-flash";
+        // Use configurable model selection instead of hardcoded default
+        const evaluationModel = process.env.NEUROLINK_EVALUATION_MODEL ||
+            modelConfig.getModelForTier(evaluationProvider, "fast") ||
+            "gemini-2.5-flash"; // Ultimate fallback
         logger.debug(`[${functionTag}] Using provider: ${evaluationProvider}, model: ${evaluationModel}`);
         const provider = await AIProviderFactory.createProvider(evaluationProvider, evaluationModel);
         if (!provider) {

package/dist/core/evaluationProviders.d.ts

@@ -1,15 +1,17 @@
 import type { ProviderModelConfig } from "./types.js";
 /**
- * Comprehensive provider configurations for evaluation
- * All 9 NeuroLink providers with cost and performance data
+ * Dynamic provider configurations for evaluation
+ * Now uses configurable system instead of hardcoded values
  */
 export declare const EVALUATION_PROVIDER_CONFIGS: Record<string, ProviderModelConfig>;
 /**
  * Get provider configuration by name
+ * Now uses the configurable system
  */
 export declare function getProviderConfig(providerName: string): ProviderModelConfig | null;
 /**
  * Get all available providers with required API keys present
+ * Now uses the configurable system
  */
 export declare function getAvailableProviders(): ProviderModelConfig[];
 /**
@@ -18,10 +20,12 @@ export declare function getAvailableProviders(): ProviderModelConfig[];
 export declare function sortProvidersByPreference(providers: ProviderModelConfig[], preferCheap?: boolean): ProviderModelConfig[];
 /**
  * Estimate cost for a specific provider and token usage
+ * Now uses the configurable system
  */
 export declare function estimateProviderCost(providerName: string, inputTokens: number, outputTokens: number): number;
 /**
  * Check if a provider is available (has required API keys)
+ * Now uses the configurable system
  */
 export declare function isProviderAvailable(providerName: string): boolean;
 /**