@juspay/neurolink 9.31.2 → 9.32.1

package/dist/client/factories/providerFactory.js

@@ -1,166 +0,0 @@
-import { logger } from "../utils/logger.js";
-/**
- * True Factory Pattern implementation for AI Providers
- * Uses registration-based approach to eliminate switch statements
- * and enable dynamic provider registration
- */
-export class ProviderFactory {
-    static providers = new Map();
-    static initialized = false;
-    /**
-     * Register a provider with the factory
-     */
-    static registerProvider(name, constructor, defaultModel, // Optional - provider can read from env
-    aliases = []) {
-        const registration = {
-            constructor,
-            defaultModel,
-            aliases,
-        };
-        // Register main name
-        ProviderFactory.providers.set(name.toLowerCase(), registration);
-        // Register aliases
-        aliases.forEach((alias) => {
-            ProviderFactory.providers.set(alias.toLowerCase(), registration);
-        });
-        logger.debug(`Registered provider: ${name} with model ${defaultModel || "from-env"}`);
-    }
-    /**
-     * Create a provider instance
-     * @param providerName - Provider name (optional, uses NEUROLINK_PROVIDER env var or 'vertex' as default)
-     * @param modelName - Model name (optional, uses provider-specific env var or registry default)
-     */
-    static async createProvider(providerName, modelName, sdk, region) {
-        // Note: Providers are registered explicitly by ProviderRegistry to avoid circular dependencies
-        // Use environment variable or default if not specified
-        const resolvedProviderName = providerName ||
-            process.env.NEUROLINK_PROVIDER ||
-            process.env.AI_PROVIDER ||
-            "vertex";
-        const normalizedName = resolvedProviderName.toLowerCase();
-        const registration = ProviderFactory.providers.get(normalizedName);
-        if (!registration) {
-            throw new Error(`Unknown provider: ${resolvedProviderName}. Available providers: ${ProviderFactory.getAvailableProviders().join(", ")}`);
-        }
-        // Respect environment variables before falling back to registry default
-        let model = modelName;
-        if (!model) {
-            // Check for provider-specific environment variables
-            if (resolvedProviderName.toLowerCase().includes("vertex")) {
-                // Use gemini-2.5-flash as default - latest GA model with best price-performance
-                model = process.env.VERTEX_MODEL || "gemini-2.5-flash";
-            }
-            else if (resolvedProviderName.toLowerCase().includes("bedrock")) {
-                model = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
-            }
-            // Fallback to registry default if no env var
-            model = model || registration.defaultModel;
-        }
-        try {
-            if (typeof registration.constructor !== "function") {
-                throw new Error(`Invalid constructor for provider ${providerName}: not a function`);
-            }
-            let result;
-            try {
-                const factoryResult = registration.constructor(model, resolvedProviderName, sdk, region);
-                // Handle both sync and async results
-                result =
-                    factoryResult instanceof Promise
-                        ? await factoryResult
-                        : factoryResult;
-            }
-            catch (factoryError) {
-                if (registration.constructor.prototype &&
-                    registration.constructor.prototype.constructor ===
-                        registration.constructor) {
-                    try {
-                        result = new registration.constructor(model, resolvedProviderName, sdk, region);
-                    }
-                    catch (constructorError) {
-                        throw new Error(`Both factory function and constructor failed. Factory error: ${factoryError}. Constructor error: ${constructorError}`, { cause: constructorError });
-                    }
-                }
-                else {
-                    throw factoryError;
-                }
-            }
-            return result;
-        }
-        catch (error) {
-            logger.error(`Failed to create provider ${resolvedProviderName}:`, error);
-            throw new Error(`Failed to create provider ${resolvedProviderName}: ${error}`, { cause: error });
-        }
-    }
-    /**
-     * Check if a provider is registered
-     */
-    static hasProvider(providerName) {
-        return ProviderFactory.providers.has(providerName.toLowerCase());
-    }
-    /**
-     * Get list of available providers
-     */
-    static getAvailableProviders() {
-        return Array.from(ProviderFactory.providers.keys()).filter((name, index, arr) => arr.indexOf(name) === index);
-    }
-    /**
-     * Get provider registration info
-     */
-    static getProviderInfo(providerName) {
-        return ProviderFactory.providers.get(providerName.toLowerCase());
-    }
-    /**
-     * Normalize provider names using aliases (PHASE 1: Factory Pattern)
-     */
-    static normalizeProviderName(providerName) {
-        const normalized = providerName.toLowerCase();
-        // Check direct registration
-        if (ProviderFactory.providers.has(normalized)) {
-            return normalized;
-        }
-        // Check aliases from all registrations
-        for (const [name, registration] of ProviderFactory.providers.entries()) {
-            if (registration.aliases?.includes(normalized)) {
-                return name;
-            }
-        }
-        return null;
-    }
-    /**
-     * Clear all registrations (mainly for testing)
-     */
-    static clearRegistrations() {
-        ProviderFactory.providers.clear();
-        ProviderFactory.initialized = false;
-    }
-    /**
-     * Ensure providers are initialized
-     */
-    static ensureInitialized() {
-        if (!ProviderFactory.initialized) {
-            ProviderFactory.initializeDefaultProviders();
-            ProviderFactory.initialized = true;
-        }
-    }
-    /**
-     * Initialize default providers
-     * NOTE: Providers are now registered by ProviderRegistry to avoid circular dependencies
-     */
-    static initializeDefaultProviders() {
-        logger.debug("BaseProvider factory pattern ready - providers registered by ProviderRegistry");
-        // No hardcoded registrations - all done dynamically by ProviderRegistry
-    }
-    /**
-     * Create the best available provider for the given name
-     * Used by NeuroLink SDK for streaming and generation
-     */
-    static async createBestProvider(providerName, modelName, enableMCP, sdk) {
-        return await ProviderFactory.createProvider(providerName, modelName, sdk);
-    }
-}
-/**
- * Helper function to create providers with backward compatibility
- */
-export async function createAIProvider(providerName, modelName) {
-    return await ProviderFactory.createProvider(providerName, modelName);
-}

package/dist/client/factories/providerRegistry.js

@@ -1,166 +0,0 @@
-import { ProviderFactory } from "./providerFactory.js";
-import { logger } from "../utils/logger.js";
-import { AIProviderName, GoogleAIModels, OpenAIModels, AnthropicModels, VertexModels, MistralModels, OllamaModels, LiteLLMModels, HuggingFaceModels, } from "../constants/enums.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 registrationPromise = null;
-    static options = {
-        enableManualMCP: false, // Default to disabled for safety
-    };
-    /**
-     * Register all providers with the factory
-     */
-    static async registerAllProviders() {
-        if (this.registered) {
-            return;
-        }
-        if (this.registrationPromise) {
-            return this.registrationPromise;
-        }
-        this.registrationPromise = this._doRegister();
-        try {
-            await this.registrationPromise;
-        }
-        catch (error) {
-            this.registrationPromise = null; // Allow retry on failure
-            throw error;
-        }
-    }
-    /**
-     * Internal registration implementation
-     */
-    static async _doRegister() {
-        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", "google-ai-studio"]);
-            // 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);
-            }, AnthropicModels.CLAUDE_SONNET_4_6, ["claude", "anthropic"]);
-            // Register Amazon Bedrock provider
-            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName, _providerName, sdk, region) => {
-                const { AmazonBedrockProvider } = await import("../providers/amazonBedrock.js");
-                return new AmazonBedrockProvider(modelName, sdk, region);
-            }, undefined, // Let provider read BEDROCK_MODEL from .env
-            ["bedrock", "aws"]);
-            // Register Azure OpenAI provider
-            ProviderFactory.registerProvider(AIProviderName.AZURE, async (modelName, _providerName, sdk) => {
-                const { AzureOpenAIProvider } = await import("../providers/azureOpenai.js");
-                return new AzureOpenAIProvider(modelName, sdk);
-            }, process.env.AZURE_MODEL ||
-                process.env.AZURE_OPENAI_MODEL ||
-                process.env.AZURE_OPENAI_DEPLOYMENT ||
-                process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
-                "gpt-4o-mini", ["azure", "azureOpenai"]);
-            // Register Google Vertex AI provider
-            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName, providerName, sdk, region) => {
-                const { GoogleVertexProvider } = await import("../providers/googleVertex.js");
-                return new GoogleVertexProvider(modelName, providerName, sdk, region);
-            }, VertexModels.CLAUDE_4_6_SONNET, ["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 ||
-                HuggingFaceModels.QWEN_2_5_72B_INSTRUCT, ["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);
-            }, MistralModels.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 || OllamaModels.LLAMA3_2_LATEST, ["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 || LiteLLMModels.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", "vllm", "compatible"]);
-            // Register OpenRouter provider (300+ models from 60+ providers)
-            ProviderFactory.registerProvider(AIProviderName.OPENROUTER, async (modelName, _providerName, sdk) => {
-                const { OpenRouterProvider } = await import("../providers/openRouter.js");
-                return new OpenRouterProvider(modelName, sdk);
-            }, process.env.OPENROUTER_MODEL || "anthropic/claude-3-5-sonnet", ["openrouter", "or"]);
-            // Register Amazon SageMaker provider
-            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, _providerName, _sdk, region) => {
-                const { AmazonSageMakerProvider } = await import("../providers/amazonSagemaker.js");
-                return new AmazonSageMakerProvider(modelName, undefined, region);
-            }, process.env.SAGEMAKER_MODEL || "sagemaker-model", ["sagemaker", "aws-sagemaker"]);
-            logger.debug("All providers registered successfully");
-            this.registered = true;
-            // ===== TTS HANDLER REGISTRATION =====
-            try {
-                // Create handler instance and register explicitly
-                const { GoogleTTSHandler } = await import("../adapters/tts/googleTTSHandler.js");
-                const { TTSProcessor } = await import("../utils/ttsProcessor.js");
-                const googleHandler = new GoogleTTSHandler();
-                TTSProcessor.registerHandler("google-ai", googleHandler);
-                TTSProcessor.registerHandler("vertex", googleHandler);
-                logger.debug("TTS handlers registered successfully", {
-                    providers: ["google-ai", "vertex"],
-                });
-            }
-            catch (ttsError) {
-                logger.warn("Failed to register TTS handlers - TTS functionality will be unavailable", {
-                    error: ttsError instanceof Error ? ttsError.message : String(ttsError),
-                });
-                // Don't throw - TTS is optional functionality
-            }
-        }
-        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;
-        this.registrationPromise = null;
-    }
-    /**
-     * 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