@juspay/neurolink
Version:
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
126 lines (125 loc) • 6.92 kB
JavaScript
import { ProviderFactory } from "./providerFactory.js";
// 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";
import { logger } from "../utils/logger.js";
/**
* Provider Registry - registers all providers with the factory
* This is where we migrate providers one by one to the new pattern
*/
export class ProviderRegistry {
static registered = false;
static options = {
enableManualMCP: false, // Default to disabled for safety
};
/**
* Register all providers with the factory
*/
static async registerAllProviders() {
if (this.registered) {
return;
}
try {
// 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) => {
const { GoogleAIStudioProvider } = await import("../providers/googleAiStudio.js");
return new GoogleAIStudioProvider(modelName, sdk);
}, GoogleAIModels.GEMINI_2_5_FLASH, ["googleAiStudio", "google", "gemini", "google-ai"]);
// Register OpenAI provider
ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, _providerName, sdk) => {
const { OpenAIProvider } = await import("../providers/openAI.js");
return new OpenAIProvider(modelName, sdk);
}, OpenAIModels.GPT_4O_MINI, ["gpt", "chatgpt"]);
// Register Anthropic provider
ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, _providerName, sdk) => {
const { AnthropicProvider } = await import("../providers/anthropic.js");
return new AnthropicProvider(modelName, sdk);
}, "claude-3-5-sonnet-20241022", ["claude", "anthropic"]);
// Register Amazon Bedrock provider
ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName) => {
const { AmazonBedrockProvider } = await import("../providers/amazonBedrock.js");
return new AmazonBedrockProvider(modelName);
}, undefined, // Let provider read BEDROCK_MODEL from .env
["bedrock", "aws"]);
// Register Azure OpenAI provider
ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName) => {
const { AzureOpenAIProvider } = await import("../providers/azureOpenai.js");
return new AzureOpenAIProvider(modelName);
}, process.env.AZURE_MODEL ||
process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
"gpt-4o-mini", ["azure", "azureOpenai"]);
// Register Google Vertex AI provider
ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName, providerName, sdk) => {
const { GoogleVertexProvider } = await import("../providers/googleVertex.js");
return new GoogleVertexProvider(modelName, providerName, sdk);
}, "claude-sonnet-4@20250514", ["vertex", "googleVertex"]);
// Register Hugging Face provider (Unified Router implementation)
ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName) => {
const { HuggingFaceProvider } = await import("../providers/huggingFace.js");
return new HuggingFaceProvider(modelName);
}, process.env.HUGGINGFACE_MODEL || "microsoft/DialoGPT-medium", ["huggingface", "hf"]);
// Register Mistral AI provider
ProviderFactory.registerProvider(AIProviderName.MISTRAL, async (modelName, _providerName, sdk) => {
const { MistralProvider } = await import("../providers/mistral.js");
return new MistralProvider(modelName, sdk);
}, "mistral-large-latest", ["mistral"]);
// Register Ollama provider
ProviderFactory.registerProvider(AIProviderName.OLLAMA, async (modelName) => {
const { OllamaProvider } = await import("../providers/ollama.js");
return new OllamaProvider(modelName);
}, process.env.OLLAMA_MODEL || "llama3.1:8b", ["ollama", "local"]);
// Register LiteLLM provider
ProviderFactory.registerProvider(AIProviderName.LITELLM, async (modelName, _providerName, sdk) => {
const { LiteLLMProvider } = await import("../providers/litellm.js");
return new LiteLLMProvider(modelName, sdk);
}, process.env.LITELLM_MODEL || "openai/gpt-4o-mini", ["litellm"]);
// Register OpenAI Compatible provider
ProviderFactory.registerProvider(AIProviderName.OPENAI_COMPATIBLE, async (modelName, _providerName, sdk) => {
const { OpenAICompatibleProvider } = await import("../providers/openaiCompatible.js");
return new OpenAICompatibleProvider(modelName, sdk);
}, process.env.OPENAI_COMPATIBLE_MODEL || undefined, // Enable auto-discovery when no model specified
["openai-compatible", "openrouter", "vllm", "compatible"]);
// Register Amazon SageMaker provider
ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, _providerName, _sdk) => {
const { AmazonSageMakerProvider } = await import("../providers/amazonSagemaker.js");
return new AmazonSageMakerProvider(modelName);
}, process.env.SAGEMAKER_MODEL || "sagemaker-model", ["sagemaker", "aws-sagemaker"]);
logger.debug("All providers registered successfully");
this.registered = true;
}
catch (error) {
logger.error("Failed to register providers:", error);
throw error;
}
}
/**
* Check if providers are registered
*/
static isRegistered() {
return this.registered;
}
/**
* Clear registrations (for testing)
*/
static clearRegistrations() {
ProviderFactory.clearRegistrations();
this.registered = false;
}
/**
* Set registry options (should be called before initialization)
*/
static setOptions(options) {
this.options = { ...this.options, ...options };
logger.debug("Provider registry options updated:", this.options);
}
/**
* Get current registry options
*/
static getOptions() {
return { ...this.options };
}
}
// Note: Providers are registered explicitly when needed to avoid circular dependencies