@juspay/neurolink 7.6.1 → 7.7.0

package/dist/core/types.d.ts

@@ -77,12 +77,16 @@ export declare enum OpenAIModels {
  */
 export declare enum VertexModels {
     CLAUDE_4_0_SONNET = "claude-sonnet-4@20250514",
-    GEMINI_2_5_FLASH = "gemini-2.5-flash-preview-05-20"
+    GEMINI_2_0_FLASH_001 = "gemini-2.0-flash-001",
+    GEMINI_2_5_PRO = "gemini-2.5-pro",
+    GEMINI_2_5_FLASH = "gemini-2.5-flash",
+    GEMINI_2_5_FLASH_LITE = "gemini-2.5-flash-lite"
 }
 /**
  * Supported Models for Google AI Studio
  */
 export declare enum GoogleAIModels {
+    GEMINI_2_0_FLASH_001 = "gemini-2.0-flash-001",
     GEMINI_2_5_PRO = "gemini-2.5-pro",
     GEMINI_2_5_FLASH = "gemini-2.5-flash",
     GEMINI_1_5_FLASH_LITE = "gemini-2.5-flash-lite"
@@ -152,8 +156,8 @@ export interface AnalyticsData {
     context?: Record<string, JsonValue>;
 }
 /**
- * Response quality evaluation scores (Lighthouse-Compatible Schema)
- * Updated to match Lighthouse's exact evaluation interface for consistency
+ * Response quality evaluation scores
+ * Comprehensive evaluation interface for response quality assessment
  */
 export interface EvaluationData {
     relevance: number;
@@ -169,6 +173,7 @@ export interface EvaluationData {
     suggestedImprovements?: string;
     evaluationModel: string;
     evaluationTime: number;
+    evaluationDomain?: string;
     evaluationProvider?: string;
     evaluationAttempt?: number;
     evaluationConfig?: {
@@ -176,6 +181,20 @@ export interface EvaluationData {
         fallbackUsed: boolean;
         costEstimate: number;
     };
+    domainConfig?: {
+        domainName: string;
+        domainDescription: string;
+        keyTerms: string[];
+        failurePatterns: string[];
+        successPatterns: string[];
+        evaluationCriteria?: Record<string, unknown>;
+    };
+    domainEvaluation?: {
+        domainRelevance: number;
+        terminologyAccuracy: number;
+        domainExpertise: number;
+        domainSpecificInsights: string[];
+    };
 }
 /**
  * BACKWARD COMPATIBILITY: Legacy evaluation interface

package/dist/core/types.js

@@ -43,13 +43,17 @@ export var OpenAIModels;
 export var VertexModels;
 (function (VertexModels) {
     VertexModels["CLAUDE_4_0_SONNET"] = "claude-sonnet-4@20250514";
-    VertexModels["GEMINI_2_5_FLASH"] = "gemini-2.5-flash-preview-05-20";
+    VertexModels["GEMINI_2_0_FLASH_001"] = "gemini-2.0-flash-001";
+    VertexModels["GEMINI_2_5_PRO"] = "gemini-2.5-pro";
+    VertexModels["GEMINI_2_5_FLASH"] = "gemini-2.5-flash";
+    VertexModels["GEMINI_2_5_FLASH_LITE"] = "gemini-2.5-flash-lite";
 })(VertexModels || (VertexModels = {}));
 /**
  * Supported Models for Google AI Studio
  */
 export var GoogleAIModels;
 (function (GoogleAIModels) {
+    GoogleAIModels["GEMINI_2_0_FLASH_001"] = "gemini-2.0-flash-001";
     GoogleAIModels["GEMINI_2_5_PRO"] = "gemini-2.5-pro";
     GoogleAIModels["GEMINI_2_5_FLASH"] = "gemini-2.5-flash";
     GoogleAIModels["GEMINI_1_5_FLASH_LITE"] = "gemini-2.5-flash-lite";

package/dist/factories/providerRegistry.js

@@ -1,5 +1,5 @@
 import { ProviderFactory } from "./providerFactory.js";
-// ✅ FINAL CIRCULAR DEPENDENCY FIX: Lazy loading all providers
+// Lazy loading all providers to avoid circular dependencies
 // Removed all static imports - providers loaded dynamically when needed
 // This breaks the circular dependency chain completely
 import { AIProviderName, GoogleAIModels, OpenAIModels } from "../core/types.js";
@@ -21,7 +21,7 @@ export class ProviderRegistry {
             return;
         }
         try {
-            // ✅ LAZY LOADING: Register providers with dynamic import factory functions
+            // Register providers with dynamic import factory functions
             const { ProviderFactory } = await import("./providerFactory.js");
             // Register Google AI Studio Provider (our validated baseline)
             ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, providerName, sdk) => {
@@ -55,7 +55,7 @@ export class ProviderRegistry {
             ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName) => {
                 const { GoogleVertexProvider } = await import("../providers/googleVertex.js");
                 return new GoogleVertexProvider(modelName);
-            }, "gemini-2.5-pro", ["vertex", "googleVertex"]);
+            }, "gemini-2.5-flash", ["vertex", "googleVertex"]);
             // Register Hugging Face provider (Unified Router implementation)
             ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName) => {
                 const { HuggingFaceProvider } = await import("../providers/huggingFace.js");

package/dist/index.d.ts

@@ -4,7 +4,7 @@
  * A unified AI provider interface with support for multiple providers,
  * automatic fallback, streaming, and tool integration.
  *
- * Extracted from lighthouse project's proven AI functionality.
+ * Provides comprehensive AI functionality with proven patterns.
  */
 import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };

package/dist/index.js

@@ -4,7 +4,7 @@
  * A unified AI provider interface with support for multiple providers,
  * automatic fallback, streaming, and tool integration.
  *
- * Extracted from lighthouse project's proven AI functionality.
+ * Provides comprehensive AI functionality with proven patterns.
  */
 // Core exports
 import { AIProviderFactory } from "./core/factory.js";

package/dist/lib/core/analytics.js

@@ -5,6 +5,7 @@
  * including tokens, costs, performance metrics, and custom context.
  */
 import { logger } from "../utils/logger.js";
+import { modelConfig } from "./modelConfiguration.js";
 /**
  * Create analytics data structure from AI response
  */
@@ -89,35 +90,14 @@ function extractTokenUsage(result) {
  */
 function estimateCost(provider, model, tokens) {
     try {
-        // Cost per 1K tokens (USD) - approximate rates as of 2024
-        const costMap = {
-            openai: {
-                "gpt-4": { input: 0.03, output: 0.06 },
-                "gpt-4-turbo": { input: 0.01, output: 0.03 },
-                "gpt-3.5-turbo": { input: 0.0015, output: 0.002 },
-            },
-            anthropic: {
-                "claude-3-opus": { input: 0.015, output: 0.075 },
-                "claude-3-sonnet": { input: 0.003, output: 0.015 },
-                "claude-3-haiku": { input: 0.00025, output: 0.00125 },
-            },
-            "google-ai": {
-                "gemini-pro": { input: 0.00035, output: 0.00105 },
-                "gemini-2.5-flash": { input: 0.000075, output: 0.0003 },
-            },
-        };
-        const providerCosts = costMap[provider.toLowerCase()];
-        if (!providerCosts) {
-            return undefined;
-        }
-        // Find best matching model
-        const modelKey = Object.keys(providerCosts).find((key) => model.toLowerCase().includes(key) || key.includes(model.toLowerCase()));
-        if (!modelKey) {
+        // Use the new configuration system instead of hardcoded costs
+        const costInfo = modelConfig.getCostInfo(provider.toLowerCase(), model);
+        if (!costInfo) {
             return undefined;
         }
-        const rates = providerCosts[modelKey];
-        const inputCost = (tokens.input / 1000) * rates.input;
-        const outputCost = (tokens.output / 1000) * rates.output;
+        // Calculate cost using the configuration system
+        const inputCost = (tokens.input / 1000) * costInfo.input;
+        const outputCost = (tokens.output / 1000) * costInfo.output;
         return Math.round((inputCost + outputCost) * 100000) / 100000; // Round to 5 decimal places
     }
     catch (error) {

package/dist/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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) {