@juspay/neurolink 1.6.0 → 1.10.0

package/dist/lib/core/dynamic-models.js

@@ -0,0 +1,250 @@
+import { z } from "zod";
+import { logger } from "../utils/logger.js";
+/**
+ * Model configuration schema for validation
+ */
+const ModelConfigSchema = z.object({
+    id: z.string(),
+    displayName: z.string(),
+    capabilities: z.array(z.string()),
+    deprecated: z.boolean(),
+    pricing: z.object({
+        input: z.number(),
+        output: z.number(),
+    }),
+    contextWindow: z.number(),
+    releaseDate: z.string(),
+});
+const ModelRegistrySchema = z.object({
+    version: z.string(),
+    lastUpdated: z.string(),
+    models: z.record(z.record(ModelConfigSchema)),
+    aliases: z.record(z.string()).optional(),
+    defaults: z.record(z.string()).optional(),
+});
+/**
+ * Dynamic Model Provider
+ * Loads and manages model configurations from external sources
+ */
+export class DynamicModelProvider {
+    static instance;
+    modelRegistry = null;
+    lastFetch = 0;
+    CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
+    constructor() { }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new DynamicModelProvider();
+        }
+        return this.instance;
+    }
+    /**
+     * Initialize the model registry from multiple sources
+     */
+    async initialize() {
+        const sources = [
+            process.env.MODEL_CONFIG_URL || "http://localhost:3001/api/v1/models",
+            "https://raw.githubusercontent.com/sachinsharma92/neurolink/main/config/models.json",
+            "./config/models.json", // Local fallback
+        ];
+        for (const source of sources) {
+            try {
+                logger.debug(`[DynamicModelProvider] Attempting to load from: ${source}`);
+                const config = await this.loadFromSource(source);
+                // Validate the configuration
+                const validatedConfig = ModelRegistrySchema.parse(config);
+                this.modelRegistry = validatedConfig;
+                this.lastFetch = Date.now();
+                logger.info(`[DynamicModelProvider] Successfully loaded model registry from: ${source}`, {
+                    modelCount: this.getTotalModelCount(),
+                    providerCount: Object.keys(validatedConfig.models).length,
+                });
+                return; // Success, stop trying other sources
+            }
+            catch (error) {
+                logger.warn(`[DynamicModelProvider] Failed to load from ${source}:`, error);
+                continue;
+            }
+        }
+        throw new Error("Failed to load model configuration from any source");
+    }
+    /**
+     * Load configuration from a source (URL or file path)
+     */
+    async loadFromSource(source) {
+        if (source.startsWith("http")) {
+            // Load from URL
+            const response = await fetch(source, {
+                headers: {
+                    "User-Agent": "NeuroLink/1.0 (+https://github.com/sachinsharma92/neurolink)",
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            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);
+        }
+    }
+    /**
+     * Get all available models for a provider
+     */
+    getModelsForProvider(provider) {
+        this.ensureInitialized();
+        return this.modelRegistry?.models[provider] || {};
+    }
+    /**
+     * Resolve a model by provider and model hint
+     */
+    resolveModel(provider, modelHint) {
+        this.ensureInitialized();
+        const providerModels = this.getModelsForProvider(provider);
+        if (!modelHint) {
+            // Use default model for provider
+            const defaultModel = this.modelRegistry?.defaults?.[provider];
+            return defaultModel ? providerModels[defaultModel] : null;
+        }
+        // Check for exact match
+        if (providerModels[modelHint]) {
+            return providerModels[modelHint];
+        }
+        // Check aliases
+        const aliasTarget = this.modelRegistry?.aliases?.[modelHint];
+        if (aliasTarget) {
+            const [aliasProvider, aliasModel] = aliasTarget.split("/");
+            return this.resolveModel(aliasProvider, aliasModel);
+        }
+        // Fuzzy matching (partial string match)
+        const fuzzyMatch = Object.keys(providerModels).find((key) => key.toLowerCase().includes(modelHint.toLowerCase()) ||
+            modelHint.toLowerCase().includes(key.toLowerCase()));
+        return fuzzyMatch ? providerModels[fuzzyMatch] : null;
+    }
+    /**
+     * Search models by capabilities
+     */
+    searchByCapability(capability, options = {}) {
+        this.ensureInitialized();
+        const results = [];
+        for (const [providerName, models] of Object.entries(this.modelRegistry.models)) {
+            if (options.provider && providerName !== options.provider) {
+                continue;
+            }
+            for (const [modelName, modelConfig] of Object.entries(models)) {
+                if (options.excludeDeprecated && modelConfig.deprecated) {
+                    continue;
+                }
+                if (options.maxPrice && modelConfig.pricing.input > options.maxPrice) {
+                    continue;
+                }
+                if (!modelConfig.capabilities.includes(capability)) {
+                    continue;
+                }
+                results.push({
+                    provider: providerName,
+                    model: modelName,
+                    config: modelConfig,
+                });
+            }
+        }
+        // Sort by price (cheapest first)
+        return results.sort((a, b) => a.config.pricing.input - b.config.pricing.input);
+    }
+    /**
+     * Get the best model for a specific use case
+     */
+    getBestModelFor(useCase) {
+        this.ensureInitialized();
+        switch (useCase) {
+            case "coding":
+                return (this.searchByCapability("function-calling", {
+                    excludeDeprecated: true,
+                })[0] || null);
+            case "analysis":
+                return (this.searchByCapability("analysis", { excludeDeprecated: true })[0] ||
+                    null);
+            case "vision":
+                return (this.searchByCapability("vision", { excludeDeprecated: true })[0] ||
+                    null);
+            case "fastest":
+                // Return cheapest as proxy for fastest (usually correlates)
+                return (this.getAllModels()
+                    .filter((m) => !m.config.deprecated)
+                    .sort((a, b) => a.config.pricing.input - b.config.pricing.input)[0] || null);
+            case "cheapest":
+                return (this.getAllModels()
+                    .filter((m) => !m.config.deprecated)
+                    .sort((a, b) => a.config.pricing.input - b.config.pricing.input)[0] || null);
+            default:
+                return null;
+        }
+    }
+    /**
+     * Get all models across all providers
+     */
+    getAllModels() {
+        this.ensureInitialized();
+        const results = [];
+        for (const [providerName, models] of Object.entries(this.modelRegistry.models)) {
+            for (const [modelName, modelConfig] of Object.entries(models)) {
+                results.push({
+                    provider: providerName,
+                    model: modelName,
+                    config: modelConfig,
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Get total number of models
+     */
+    getTotalModelCount() {
+        if (!this.modelRegistry) {
+            return 0;
+        }
+        return Object.values(this.modelRegistry.models).reduce((total, providerModels) => total + Object.keys(providerModels).length, 0);
+    }
+    /**
+     * Check if cache needs refresh
+     */
+    needsRefresh() {
+        return Date.now() - this.lastFetch > this.CACHE_DURATION;
+    }
+    /**
+     * Force refresh the model registry
+     */
+    async refresh() {
+        this.modelRegistry = null;
+        await this.initialize();
+    }
+    /**
+     * Ensure the registry is initialized
+     */
+    ensureInitialized() {
+        if (!this.modelRegistry) {
+            throw new Error("Model registry not initialized. Call initialize() first.");
+        }
+    }
+    /**
+     * Get registry metadata
+     */
+    getMetadata() {
+        if (!this.modelRegistry) {
+            return null;
+        }
+        return {
+            version: this.modelRegistry.version,
+            lastUpdated: this.modelRegistry.lastUpdated,
+            modelCount: this.getTotalModelCount(),
+        };
+    }
+}
+// Export singleton instance
+export const dynamicModelProvider = DynamicModelProvider.getInstance();

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

@@ -1,40 +1,47 @@
-import type { AIProvider, AIProviderName, SupportedModelName } from './types.js';
+import type { AIProvider, AIProviderName, SupportedModelName } from "./types.js";
 declare const componentIdentifier = "aiProviderFactory";
 /**
  * Factory for creating AI provider instances with centralized configuration
  */
 export declare class AIProviderFactory {
+    /**
+     * Normalize provider name to match dynamic model registry keys
+     */
+    private static normalizeProviderName;
     /**
      * Create a provider instance for the specified provider type
      * @param providerName - Name of the provider ('vertex', 'bedrock', 'openai')
      * @param modelName - Optional model name override
+     * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns AIProvider instance
      */
-    static createProvider(providerName: string, modelName?: string | null): AIProvider;
+    static createProvider(providerName: string, modelName?: string | null, enableMCP?: boolean): Promise<AIProvider>;
     /**
      * Create a provider instance with specific provider enum and model
      * @param provider - Provider enum value
      * @param model - Specific model enum value
      * @returns AIProvider instance
      */
-    static createProviderWithModel(provider: AIProviderName, model: SupportedModelName): AIProvider;
+    static createProviderWithModel(provider: AIProviderName, model: SupportedModelName): Promise<AIProvider>;
     /**
      * Create the best available provider automatically
      * @param requestedProvider - Optional preferred provider
      * @param modelName - Optional model name override
+     * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns AIProvider instance
      */
-    static createBestProvider(requestedProvider?: string, modelName?: string | null): AIProvider;
+    static createBestProvider(requestedProvider?: string, modelName?: string | null, enableMCP?: boolean): Promise<AIProvider>;
     /**
      * Create primary and fallback provider instances
      * @param primaryProvider - Primary provider name
      * @param fallbackProvider - Fallback provider name
      * @param modelName - Optional model name override
+     * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns Object with primary and fallback providers
      */
-    static createProviderWithFallback(primaryProvider: string, fallbackProvider: string, modelName?: string | null): {
+    static createProviderWithFallback(primaryProvider: string, fallbackProvider: string, modelName?: string | null, enableMCP?: boolean): Promise<{
         primary: AIProvider;
         fallback: AIProvider;
-    };
+    }>;
 }
 export { componentIdentifier };

package/dist/lib/core/factory.js

@@ -1,74 +1,184 @@
-import { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, GoogleAIStudio, HuggingFace, Ollama, MistralAI } from '../providers/index.js';
-import { getBestProvider } from '../utils/providerUtils.js';
-import { logger } from '../utils/logger.js';
-const componentIdentifier = 'aiProviderFactory';
+import { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, GoogleAIStudio, HuggingFace, Ollama, MistralAI, } from "../providers/index.js";
+import { getBestProviderSync } from "../utils/providerUtils.js";
+import { logger } from "../utils/logger.js";
+import { dynamicModelProvider } from "./dynamic-models.js";
+const componentIdentifier = "aiProviderFactory";
 /**
  * Factory for creating AI provider instances with centralized configuration
  */
 export class AIProviderFactory {
+    /**
+     * Normalize provider name to match dynamic model registry keys
+     */
+    static normalizeProviderName(providerName) {
+        switch (providerName.toLowerCase()) {
+            case "vertex":
+            case "google":
+            case "gemini":
+                return "google";
+            case "bedrock":
+            case "amazon":
+            case "aws":
+                return "bedrock";
+            case "openai":
+            case "gpt":
+                return "openai";
+            case "anthropic":
+            case "claude":
+                return "anthropic";
+            case "azure":
+            case "azure-openai":
+                return "openai"; // Azure uses OpenAI models
+            case "google-ai":
+            case "google-studio":
+                return "google";
+            case "huggingface":
+            case "hugging-face":
+            case "hf":
+                return "huggingface";
+            case "ollama":
+            case "local":
+            case "local-ollama":
+                return "ollama";
+            case "mistral":
+            case "mistral-ai":
+            case "mistralai":
+                return "mistral";
+            default:
+                return providerName.toLowerCase();
+        }
+    }
     /**
      * Create a provider instance for the specified provider type
      * @param providerName - Name of the provider ('vertex', 'bedrock', 'openai')
      * @param modelName - Optional model name override
+     * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns AIProvider instance
      */
-    static createProvider(providerName, modelName) {
-        const functionTag = 'AIProviderFactory.createProvider';
+    static async createProvider(providerName, modelName, enableMCP = true) {
+        const functionTag = "AIProviderFactory.createProvider";
         logger.debug(`[${functionTag}] Provider creation started`, {
             providerName,
-            modelName: modelName || 'default'
+            modelName: modelName || "default",
+            enableMCP,
         });
         try {
+            // EMERGENCY FIX: Skip dynamic model provider initialization to prevent hanging
+            // TODO: Fix the hanging dynamic model provider.initialize()
+            // Initialize dynamic model provider if not already done
+            // try {
+            //   if (dynamicModelProvider.needsRefresh()) {
+            //     // Add timeout to prevent hanging
+            //     await Promise.race([
+            //       dynamicModelProvider.initialize(),
+            //       new Promise((_, reject) =>
+            //         setTimeout(() => reject(new Error('Dynamic model provider timeout')), 3000)
+            //       )
+            //     ]);
+            //   }
+            // } catch (dynamicError) {
+            //   logger.warn(`[${functionTag}] Dynamic model provider initialization failed, using fallback`, {
+            //     error: dynamicError instanceof Error ? dynamicError.message : String(dynamicError),
+            //   });
+            // }
+            // Resolve dynamic model if available
+            let resolvedModelName = modelName;
+            if (!modelName || modelName === "default") {
+                try {
+                    const normalizedProvider = this.normalizeProviderName(providerName);
+                    const dynamicModel = dynamicModelProvider.resolveModel(normalizedProvider, modelName || undefined);
+                    if (dynamicModel) {
+                        resolvedModelName = dynamicModel.id;
+                        logger.debug(`[${functionTag}] Resolved dynamic model`, {
+                            provider: normalizedProvider,
+                            requestedModel: modelName || "default",
+                            resolvedModel: resolvedModelName,
+                            displayName: dynamicModel.displayName,
+                            pricing: dynamicModel.pricing.input,
+                        });
+                    }
+                }
+                catch (resolveError) {
+                    logger.debug(`[${functionTag}] Dynamic model resolution failed, using fallback`, {
+                        error: resolveError instanceof Error
+                            ? resolveError.message
+                            : String(resolveError),
+                    });
+                }
+            }
             let provider;
             switch (providerName.toLowerCase()) {
-                case 'vertex':
-                case 'google':
-                case 'gemini':
-                    provider = new GoogleVertexAI(modelName);
+                case "vertex":
+                case "google":
+                case "gemini":
+                    provider = new GoogleVertexAI(resolvedModelName === "default" ? null : resolvedModelName);
                     break;
-                case 'bedrock':
-                case 'amazon':
-                case 'aws':
-                    provider = new AmazonBedrock(modelName);
+                case "bedrock":
+                case "amazon":
+                case "aws":
+                    provider = new AmazonBedrock(resolvedModelName === "default" ? null : resolvedModelName);
                     break;
-                case 'openai':
-                case 'gpt':
-                    provider = new OpenAI(modelName);
+                case "openai":
+                case "gpt":
+                    provider = new OpenAI(resolvedModelName === "default" ? null : resolvedModelName);
                     break;
-                case 'anthropic':
-                case 'claude':
+                case "anthropic":
+                case "claude":
                     provider = new AnthropicProvider();
                     break;
-                case 'azure':
-                case 'azure-openai':
+                case "azure":
+                case "azure-openai":
                     provider = new AzureOpenAIProvider();
                     break;
-                case 'google-ai':
-                case 'google-studio':
-                    provider = new GoogleAIStudio(modelName);
+                case "google-ai":
+                case "google-studio":
+                    provider = new GoogleAIStudio(resolvedModelName === "default" ? null : resolvedModelName);
                     break;
-                case 'huggingface':
-                case 'hugging-face':
-                case 'hf':
-                    provider = new HuggingFace(modelName);
+                case "huggingface":
+                case "hugging-face":
+                case "hf":
+                    provider = new HuggingFace(resolvedModelName === "default" ? null : resolvedModelName);
                     break;
-                case 'ollama':
-                case 'local':
-                case 'local-ollama':
-                    provider = new Ollama(modelName || undefined);
+                case "ollama":
+                case "local":
+                case "local-ollama":
+                    provider = new Ollama(resolvedModelName === "default"
+                        ? undefined
+                        : resolvedModelName || undefined);
                     break;
-                case 'mistral':
-                case 'mistral-ai':
-                case 'mistralai':
-                    provider = new MistralAI(modelName);
+                case "mistral":
+                case "mistral-ai":
+                case "mistralai":
+                    provider = new MistralAI(resolvedModelName === "default" ? null : resolvedModelName);
                     break;
                 default:
                     throw new Error(`Unknown provider: ${providerName}. Supported providers: vertex, bedrock, openai, anthropic, azure, google-ai, huggingface, ollama, mistral`);
             }
+            // Wrap with MCP if enabled
+            if (enableMCP) {
+                try {
+                    // TEMPORARY: Disable MCP wrapping to test for hanging issues
+                    logger.debug(`[${functionTag}] MCP wrapping temporarily disabled for debugging`);
+                    // const { createMCPAwareProviderV3 } = await import("../providers/function-calling-provider.js");
+                    // provider = createMCPAwareProviderV3(provider, {
+                    //   providerName,
+                    //   modelName: resolvedModelName || undefined,
+                    //   enableMCP: true,
+                    //   enableFunctionCalling: true,
+                    // });
+                    // logger.debug(`[${functionTag}] Provider wrapped with MCP support`);
+                }
+                catch (mcpError) {
+                    logger.warn(`[${functionTag}] Failed to wrap with MCP, using base provider`, {
+                        error: mcpError instanceof Error ? mcpError.message : String(mcpError),
+                    });
+                }
+            }
             logger.debug(`[${functionTag}] Provider creation succeeded`, {
                 providerName,
-                modelName: modelName || 'default',
-                providerType: provider.constructor.name
+                modelName: modelName || "default",
+                providerType: provider.constructor.name,
+                mcpEnabled: enableMCP,
             });
             return provider;
         }
@@ -76,8 +186,8 @@ export class AIProviderFactory {
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.debug(`[${functionTag}] Provider creation failed`, {
                 providerName,
-                modelName: modelName || 'default',
-                error: errorMessage
+                modelName: modelName || "default",
+                error: errorMessage,
             });
             throw error;
         }
@@ -88,18 +198,18 @@ export class AIProviderFactory {
      * @param model - Specific model enum value
      * @returns AIProvider instance
      */
-    static createProviderWithModel(provider, model) {
-        const functionTag = 'AIProviderFactory.createProviderWithModel';
+    static async createProviderWithModel(provider, model) {
+        const functionTag = "AIProviderFactory.createProviderWithModel";
         logger.debug(`[${functionTag}] Provider model creation started`, {
             provider,
-            model
+            model,
         });
         try {
-            const providerInstance = this.createProvider(provider, model);
+            const providerInstance = await this.createProvider(provider, model);
             logger.debug(`[${functionTag}] Provider model creation succeeded`, {
                 provider,
                 model,
-                providerType: providerInstance.constructor.name
+                providerType: providerInstance.constructor.name,
             });
             return providerInstance;
         }
@@ -108,7 +218,7 @@ export class AIProviderFactory {
             logger.debug(`[${functionTag}] Provider model creation failed`, {
                 provider,
                 model,
-                error: errorMessage
+                error: errorMessage,
             });
             throw error;
         }
@@ -117,24 +227,26 @@ export class AIProviderFactory {
      * Create the best available provider automatically
      * @param requestedProvider - Optional preferred provider
      * @param modelName - Optional model name override
+     * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns AIProvider instance
      */
-    static createBestProvider(requestedProvider, modelName) {
-        const functionTag = 'AIProviderFactory.createBestProvider';
+    static async createBestProvider(requestedProvider, modelName, enableMCP = true) {
+        const functionTag = "AIProviderFactory.createBestProvider";
         try {
-            const bestProvider = getBestProvider(requestedProvider);
+            const bestProvider = getBestProviderSync(requestedProvider);
             logger.debug(`[${functionTag}] Best provider selected`, {
-                requestedProvider: requestedProvider || 'auto',
+                requestedProvider: requestedProvider || "auto",
                 selectedProvider: bestProvider,
-                modelName: modelName || 'default'
+                modelName: modelName || "default",
+                enableMCP,
             });
-            return this.createProvider(bestProvider, modelName);
+            return await this.createProvider(bestProvider, modelName, enableMCP);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.debug(`[${functionTag}] Best provider selection failed`, {
-                requestedProvider: requestedProvider || 'auto',
-                error: errorMessage
+                requestedProvider: requestedProvider || "auto",
+                error: errorMessage,
             });
             throw error;
         }
@@ -144,22 +256,25 @@ export class AIProviderFactory {
      * @param primaryProvider - Primary provider name
      * @param fallbackProvider - Fallback provider name
      * @param modelName - Optional model name override
+     * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns Object with primary and fallback providers
      */
-    static createProviderWithFallback(primaryProvider, fallbackProvider, modelName) {
-        const functionTag = 'AIProviderFactory.createProviderWithFallback';
+    static async createProviderWithFallback(primaryProvider, fallbackProvider, modelName, enableMCP = true) {
+        const functionTag = "AIProviderFactory.createProviderWithFallback";
         logger.debug(`[${functionTag}] Fallback provider setup started`, {
             primaryProvider,
             fallbackProvider,
-            modelName: modelName || 'default'
+            modelName: modelName || "default",
+            enableMCP,
         });
         try {
-            const primary = this.createProvider(primaryProvider, modelName);
-            const fallback = this.createProvider(fallbackProvider, modelName);
+            const primary = await this.createProvider(primaryProvider, modelName, enableMCP);
+            const fallback = await this.createProvider(fallbackProvider, modelName, enableMCP);
             logger.debug(`[${functionTag}] Fallback provider setup succeeded`, {
                 primaryProvider,
                 fallbackProvider,
-                modelName: modelName || 'default'
+                modelName: modelName || "default",
+                enableMCP,
             });
             return { primary, fallback };
         }
@@ -168,7 +283,7 @@ export class AIProviderFactory {
             logger.debug(`[${functionTag}] Fallback provider setup failed`, {
                 primaryProvider,
                 fallbackProvider,
-                error: errorMessage
+                error: errorMessage,
             });
             throw error;
         }

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

@@ -1,5 +1,5 @@
-import type { ZodType, ZodTypeDef } from 'zod';
-import type { StreamTextResult, ToolSet, Schema, GenerateTextResult } from 'ai';
+import type { ZodType, ZodTypeDef } from "zod";
+import type { StreamTextResult, ToolSet, Schema, GenerateTextResult, Tool } from "ai";
 /**
  * Supported AI Provider Names
  */
@@ -79,6 +79,7 @@ export interface TextGenerationOptions {
     maxTokens?: number;
     systemPrompt?: string;
     schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
+    tools?: Record<string, Tool>;
 }
 /**
  * Stream text options interface
@@ -90,6 +91,7 @@ export interface StreamTextOptions {
     maxTokens?: number;
     systemPrompt?: string;
     schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
+    tools?: Record<string, Tool>;
 }
 /**
  * AI Provider interface with flexible parameter support