@juspay/neurolink 5.1.0 → 5.3.0

package/dist/core/factory.d.ts

@@ -5,7 +5,7 @@ declare const componentIdentifier = "aiProviderFactory";
  */
 export declare class AIProviderFactory {
     /**
-     * Normalize provider name to match dynamic model registry keys
+     * Normalize provider name using ProviderFactory
      */
     private static normalizeProviderName;
     /**
@@ -15,7 +15,7 @@ export declare class AIProviderFactory {
      * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns AIProvider instance
      */
-    static createProvider(providerName: string, modelName?: string | null, enableMCP?: boolean): Promise<AIProvider>;
+    static createProvider(providerName: string, modelName?: string | null, enableMCP?: boolean, sdk?: any): Promise<AIProvider>;
     /**
      * Create a provider instance with specific provider enum and model
      * @param provider - Provider enum value
@@ -30,7 +30,7 @@ export declare class AIProviderFactory {
      * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns AIProvider instance
      */
-    static createBestProvider(requestedProvider?: string, modelName?: string | null, enableMCP?: boolean): Promise<AIProvider>;
+    static createBestProvider(requestedProvider?: string, modelName?: string | null, enableMCP?: boolean, sdk?: any): Promise<AIProvider>;
     /**
      * Create primary and fallback provider instances
      * @param primaryProvider - Primary provider name

package/dist/core/factory.js

@@ -1,4 +1,7 @@
-import { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, GoogleAIStudio, HuggingFace, Ollama, MistralAI, } from "../providers/index.js";
+// ✅ CIRCULAR DEPENDENCY FIX: Remove barrel export import
+// Providers are now managed via ProviderFactory instead of direct imports
+import { ProviderFactory } from "../factories/provider-factory.js";
+import { ProviderRegistry } from "../factories/provider-registry.js";
 import { getBestProvider } from "../utils/providerUtils.js";
 import { logger } from "../utils/logger.js";
 import { dynamicModelProvider } from "./dynamic-models.js";
@@ -8,45 +11,16 @@ const componentIdentifier = "aiProviderFactory";
  */
 export class AIProviderFactory {
     /**
-     * Normalize provider name to match dynamic model registry keys
+     * Normalize provider name using ProviderFactory
      */
     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();
+        // Use ProviderFactory registration - no more legacy switch statements
+        const normalized = ProviderFactory.normalizeProviderName(providerName);
+        if (normalized) {
+            return normalized;
         }
+        // If not found in factory, return as-is (will be handled by factory error handling)
+        return providerName.toLowerCase();
     }
     /**
      * Create a provider instance for the specified provider type
@@ -55,8 +29,9 @@ export class AIProviderFactory {
      * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns AIProvider instance
      */
-    static async createProvider(providerName, modelName, enableMCP = true) {
-        const functionTag = "AIProviderFactory.createProvider";
+    static async createProvider(providerName, modelName, enableMCP = true, sdk) {
+        const functionTag = "AIawait ProviderFactory.createProvider";
+        // Providers are registered via ProviderFactory.initialize() on first use
         logger.debug(`[${functionTag}] Provider creation started`, {
             providerName,
             modelName: modelName || "default",
@@ -115,53 +90,18 @@ export class AIProviderFactory {
             //   }
             // }
             let provider;
-            switch (providerName.toLowerCase()) {
-                case "vertex":
-                case "google":
-                case "gemini":
-                    provider = new GoogleVertexAI(resolvedModelName === "default" ? null : resolvedModelName);
-                    break;
-                case "bedrock":
-                case "amazon":
-                case "aws":
-                    provider = new AmazonBedrock(resolvedModelName === "default" ? null : resolvedModelName);
-                    break;
-                case "openai":
-                case "gpt":
-                    provider = new OpenAI(resolvedModelName === "default" ? null : resolvedModelName);
-                    break;
-                case "anthropic":
-                case "claude":
-                    provider = new AnthropicProvider();
-                    break;
-                case "azure":
-                case "azure-openai":
-                    provider = new AzureOpenAIProvider();
-                    break;
-                case "google-ai":
-                case "google-studio":
-                    provider = new GoogleAIStudio(resolvedModelName === "default" ? null : resolvedModelName);
-                    break;
-                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(resolvedModelName === "default"
-                        ? undefined
-                        : resolvedModelName || undefined);
-                    break;
-                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`);
-            }
+            // PURE FACTORY PATTERN: No switch statements - use ProviderFactory exclusively
+            const normalizedName = this.normalizeProviderName(providerName);
+            const finalModelName = resolvedModelName === "default" || resolvedModelName === null
+                ? undefined
+                : resolvedModelName;
+            provider = await ProviderFactory.createProvider(normalizedName, finalModelName, sdk);
+            logger.debug(componentIdentifier, "Pure factory pattern provider created", {
+                providerName: normalizedName,
+                modelName: finalModelName,
+                factoryUsed: true,
+            });
+            // PURE FACTORY PATTERN: All providers handled by ProviderFactory - no switch statements needed
             // Wrap with MCP if enabled
             if (enableMCP) {
                 try {
@@ -183,7 +123,7 @@ export class AIProviderFactory {
             }
             logger.debug(`[${functionTag}] Provider creation succeeded`, {
                 providerName,
-                modelName: modelName || "default",
+                modelName: finalModelName || "default",
                 providerType: provider.constructor.name,
                 mcpEnabled: enableMCP,
             });
@@ -206,7 +146,7 @@ export class AIProviderFactory {
      * @returns AIProvider instance
      */
     static async createProviderWithModel(provider, model) {
-        const functionTag = "AIProviderFactory.createProviderWithModel";
+        const functionTag = "AIawait ProviderFactory.createProviderWithModel";
         logger.debug(`[${functionTag}] Provider model creation started`, {
             provider,
             model,
@@ -237,7 +177,7 @@ export class AIProviderFactory {
      * @param enableMCP - Optional flag to enable MCP integration (default: true)
      * @returns AIProvider instance
      */
-    static async createBestProvider(requestedProvider, modelName, enableMCP = true) {
+    static async createBestProvider(requestedProvider, modelName, enableMCP = true, sdk) {
         const functionTag = "AIProviderFactory.createBestProvider";
         try {
             const bestProvider = await getBestProvider(requestedProvider);
@@ -247,7 +187,7 @@ export class AIProviderFactory {
                 modelName: modelName || "default",
                 enableMCP,
             });
-            return await this.createProvider(bestProvider, modelName, enableMCP);
+            return await this.createProvider(bestProvider, modelName, enableMCP, sdk);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -267,7 +207,7 @@ export class AIProviderFactory {
      * @returns Object with primary and fallback providers
      */
     static async createProviderWithFallback(primaryProvider, fallbackProvider, modelName, enableMCP = true) {
-        const functionTag = "AIProviderFactory.createProviderWithFallback";
+        const functionTag = "AIawait ProviderFactory.createProviderWithFallback";
         logger.debug(`[${functionTag}] Fallback provider setup started`, {
             primaryProvider,
             fallbackProvider,

package/dist/core/service-registry.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Service Registry for Dependency Injection
+ * Breaks circular dependencies by providing lazy loading and centralized service management
+ */
+export interface ServiceFactory<T = any> {
+    (): T | Promise<T>;
+}
+export interface ServiceRegistration {
+    factory: ServiceFactory;
+    singleton: boolean;
+    instance?: any;
+}
+export declare class ServiceRegistry {
+    private static services;
+    private static initializing;
+    /**
+     * Register a service with optional singleton behavior
+     */
+    static register<T>(name: string, factory: ServiceFactory<T>, options?: {
+        singleton?: boolean;
+    }): void;
+    /**
+     * Get a service instance with circular dependency detection
+     */
+    static get<T>(name: string): Promise<T>;
+    /**
+     * Get a service synchronously (throws if async initialization required)
+     */
+    static getSync<T>(name: string): T;
+    /**
+     * Check if a service is registered
+     */
+    static has(name: string): boolean;
+    /**
+     * Clear all services (useful for testing)
+     */
+    static clear(): void;
+    /**
+     * Get all registered service names
+     */
+    static getRegisteredServices(): string[];
+    /**
+     * Register multiple services at once
+     */
+    static registerBatch(services: Record<string, ServiceFactory>): void;
+}
+export declare const serviceRegistry: typeof ServiceRegistry;

package/dist/core/service-registry.js

@@ -0,0 +1,112 @@
+/**
+ * Service Registry for Dependency Injection
+ * Breaks circular dependencies by providing lazy loading and centralized service management
+ */
+import { logger } from "../utils/logger.js";
+export class ServiceRegistry {
+    static services = new Map();
+    static initializing = new Set();
+    /**
+     * Register a service with optional singleton behavior
+     */
+    static register(name, factory, options = {}) {
+        if (this.services.has(name)) {
+            logger.warn(`Service ${name} is already registered. Overwriting.`);
+        }
+        this.services.set(name, {
+            factory,
+            singleton: options.singleton ?? true,
+            instance: undefined,
+        });
+        logger.debug(`Service registered: ${name} (singleton: ${options.singleton ?? true})`);
+    }
+    /**
+     * Get a service instance with circular dependency detection
+     */
+    static async get(name) {
+        const registration = this.services.get(name);
+        if (!registration) {
+            throw new Error(`Service ${name} not registered. Available services: ${Array.from(this.services.keys()).join(", ")}`);
+        }
+        // Check for circular dependency
+        if (this.initializing.has(name)) {
+            throw new Error(`Circular dependency detected: ${name} is already being initialized. Chain: ${Array.from(this.initializing).join(" -> ")} -> ${name}`);
+        }
+        // Return existing singleton instance if available
+        if (registration.singleton && registration.instance !== undefined) {
+            return registration.instance;
+        }
+        try {
+            // Mark as initializing to detect circular dependencies
+            this.initializing.add(name);
+            logger.debug(`Initializing service: ${name}`);
+            // Create new instance
+            const instance = await registration.factory();
+            // Store singleton instance
+            if (registration.singleton) {
+                registration.instance = instance;
+            }
+            logger.debug(`Service initialized: ${name}`);
+            return instance;
+        }
+        catch (error) {
+            logger.error(`Failed to initialize service ${name}:`, error);
+            throw error;
+        }
+        finally {
+            // Remove from initializing set
+            this.initializing.delete(name);
+        }
+    }
+    /**
+     * Get a service synchronously (throws if async initialization required)
+     */
+    static getSync(name) {
+        const registration = this.services.get(name);
+        if (!registration) {
+            throw new Error(`Service ${name} not registered`);
+        }
+        if (registration.singleton && registration.instance !== undefined) {
+            return registration.instance;
+        }
+        // Try synchronous initialization
+        const result = registration.factory();
+        if (result instanceof Promise) {
+            throw new Error(`Service ${name} requires asynchronous initialization. Use get() instead.`);
+        }
+        if (registration.singleton) {
+            registration.instance = result;
+        }
+        return result;
+    }
+    /**
+     * Check if a service is registered
+     */
+    static has(name) {
+        return this.services.has(name);
+    }
+    /**
+     * Clear all services (useful for testing)
+     */
+    static clear() {
+        this.services.clear();
+        this.initializing.clear();
+        logger.debug("Service registry cleared");
+    }
+    /**
+     * Get all registered service names
+     */
+    static getRegisteredServices() {
+        return Array.from(this.services.keys());
+    }
+    /**
+     * Register multiple services at once
+     */
+    static registerBatch(services) {
+        for (const [name, factory] of Object.entries(services)) {
+            this.register(name, factory);
+        }
+    }
+}
+// Export singleton instance for convenience
+export const serviceRegistry = ServiceRegistry;

package/dist/core/types.d.ts

@@ -26,6 +26,8 @@ export interface TextGenerationResult {
         server: string;
         category?: string;
     }>;
+    analytics?: any;
+    evaluation?: any;
 }
 /**
  * Supported AI Provider Names
@@ -100,7 +102,10 @@ export interface StreamingOptions {
  * Text generation options interface
  */
 export interface TextGenerationOptions {
-    prompt: string;
+    prompt?: string;
+    input?: {
+        text: string;
+    };
     provider?: AIProviderName;
     model?: string;
     temperature?: number;
@@ -109,6 +114,8 @@ export interface TextGenerationOptions {
     schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
     tools?: Record<string, Tool>;
     timeout?: number | string;
+    disableTools?: boolean;
+    maxSteps?: number;
     enableEvaluation?: boolean;
     enableAnalytics?: boolean;
     context?: Record<string, any>;

package/dist/factories/compatibility-factory.js

@@ -9,7 +9,7 @@ export class CompatibilityConversionFactory {
     static convertTextToGenerate(options) {
         const { prompt, ...rest } = options;
         return {
-            input: { text: prompt },
+            input: { text: prompt || "" },
             output: { format: "text" },
             provider: rest.provider,
             model: rest.model,

package/dist/factories/provider-factory.d.ts

@@ -0,0 +1,72 @@
+import type { AIProvider, AIProviderName } from "../core/types.js";
+/**
+ * Provider constructor interface - supports both sync constructors and async factory functions
+ */
+type ProviderConstructor = {
+    new (modelName?: string, providerName?: any, sdk?: any): AIProvider;
+} | ((modelName?: string, providerName?: any, sdk?: any) => Promise<AIProvider>);
+/**
+ * Provider registration entry
+ */
+interface ProviderRegistration {
+    constructor: ProviderConstructor;
+    defaultModel?: string;
+    aliases?: string[];
+}
+/**
+ * True Factory Pattern implementation for AI Providers
+ * Uses registration-based approach to eliminate switch statements
+ * and enable dynamic provider registration
+ */
+export declare class ProviderFactory {
+    private static readonly providers;
+    private static initialized;
+    /**
+     * Register a provider with the factory
+     */
+    static registerProvider(name: AIProviderName | string, constructor: ProviderConstructor, defaultModel?: string, // Optional - provider can read from env
+    aliases?: string[]): void;
+    /**
+     * Create a provider instance
+     */
+    static createProvider(providerName: AIProviderName | string, modelName?: string, sdk?: any): Promise<AIProvider>;
+    /**
+     * Check if a provider is registered
+     */
+    static hasProvider(providerName: string): boolean;
+    /**
+     * Get list of available providers
+     */
+    static getAvailableProviders(): string[];
+    /**
+     * Get provider registration info
+     */
+    static getProviderInfo(providerName: string): ProviderRegistration | undefined;
+    /**
+     * Normalize provider names using aliases (PHASE 1: Factory Pattern)
+     */
+    static normalizeProviderName(providerName: string): string | null;
+    /**
+     * Clear all registrations (mainly for testing)
+     */
+    static clearRegistrations(): void;
+    /**
+     * Ensure providers are initialized
+     */
+    private static ensureInitialized;
+    /**
+     * Initialize default providers
+     * NOTE: Providers are now registered by ProviderRegistry to avoid circular dependencies
+     */
+    private static initializeDefaultProviders;
+    /**
+     * Create the best available provider for the given name
+     * Used by NeuroLink SDK for streaming and generation
+     */
+    static createBestProvider(providerName: AIProviderName | string, modelName?: string, enableMCP?: boolean, sdk?: any): Promise<AIProvider>;
+}
+/**
+ * Helper function to create providers with backward compatibility
+ */
+export declare function createAIProvider(providerName: AIProviderName | string, modelName?: string): Promise<AIProvider>;
+export {};

package/dist/factories/provider-factory.js

@@ -0,0 +1,144 @@
+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
+        this.providers.set(name.toLowerCase(), registration);
+        // Register aliases
+        aliases.forEach((alias) => {
+            this.providers.set(alias.toLowerCase(), registration);
+        });
+        logger.debug(`Registered provider: ${name} with model ${defaultModel || "from-env"}`);
+    }
+    /**
+     * Create a provider instance
+     */
+    static async createProvider(providerName, modelName, sdk) {
+        // Note: Providers are registered explicitly by ProviderRegistry to avoid circular dependencies
+        const normalizedName = providerName.toLowerCase();
+        const registration = this.providers.get(normalizedName);
+        if (!registration) {
+            throw new Error(`Unknown provider: ${providerName}. Available providers: ${this.getAvailableProviders().join(", ")}`);
+        }
+        const model = modelName || registration.defaultModel;
+        try {
+            // Check if constructor is an async factory function or a class constructor
+            if (typeof registration.constructor === "function") {
+                // Check if it has a prototype (class constructor) or not (factory function)
+                if (registration.constructor.prototype &&
+                    registration.constructor.prototype.constructor ===
+                        registration.constructor) {
+                    // It's a class constructor
+                    return new registration.constructor(model, providerName, sdk);
+                }
+                else {
+                    // It's a factory function - call it and await if it returns a promise
+                    const result = registration.constructor(model, providerName, sdk);
+                    if (result && typeof result.then === "function") {
+                        // It's a Promise (async factory)
+                        return await result;
+                    }
+                    else {
+                        // It's a sync result, return it
+                        return result;
+                    }
+                }
+            }
+            else {
+                // Fallback - use as class constructor
+                return new registration.constructor(model, sdk);
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to create provider ${providerName}:`, error);
+            throw new Error(`Failed to create provider ${providerName}: ${error}`);
+        }
+    }
+    /**
+     * Check if a provider is registered
+     */
+    static hasProvider(providerName) {
+        return this.providers.has(providerName.toLowerCase());
+    }
+    /**
+     * Get list of available providers
+     */
+    static getAvailableProviders() {
+        return Array.from(this.providers.keys()).filter((name, index, arr) => arr.indexOf(name) === index);
+    }
+    /**
+     * Get provider registration info
+     */
+    static getProviderInfo(providerName) {
+        return this.providers.get(providerName.toLowerCase());
+    }
+    /**
+     * Normalize provider names using aliases (PHASE 1: Factory Pattern)
+     */
+    static normalizeProviderName(providerName) {
+        const normalized = providerName.toLowerCase();
+        // Check direct registration
+        if (this.providers.has(normalized)) {
+            return normalized;
+        }
+        // Check aliases from all registrations
+        for (const [name, registration] of this.providers.entries()) {
+            if (registration.aliases?.includes(normalized)) {
+                return name;
+            }
+        }
+        return null;
+    }
+    /**
+     * Clear all registrations (mainly for testing)
+     */
+    static clearRegistrations() {
+        this.providers.clear();
+        this.initialized = false;
+    }
+    /**
+     * Ensure providers are initialized
+     */
+    static ensureInitialized() {
+        if (!this.initialized) {
+            this.initializeDefaultProviders();
+            this.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 this.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/factories/provider-registry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Configuration options for the provider registry
+ */
+export interface ProviderRegistryOptions {
+    /**
+     * Enable loading of manual MCP configurations from .mcp-config.json
+     * Should only be true for CLI mode, false for SDK mode
+     */
+    enableManualMCP?: boolean;
+}
+/**
+ * Provider Registry - registers all providers with the factory
+ * This is where we migrate providers one by one to the new pattern
+ */
+export declare class ProviderRegistry {
+    private static registered;
+    private static options;
+    /**
+     * Register all providers with the factory
+     */
+    static registerAllProviders(): Promise<void>;
+    /**
+     * Check if providers are registered
+     */
+    static isRegistered(): boolean;
+    /**
+     * Clear registrations (for testing)
+     */
+    static clearRegistrations(): void;
+    /**
+     * Set registry options (should be called before initialization)
+     */
+    static setOptions(options: ProviderRegistryOptions): void;
+    /**
+     * Get current registry options
+     */
+    static getOptions(): ProviderRegistryOptions;
+}