@juspay/neurolink 5.0.0 → 5.2.0

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-generate-factory.d.ts

@@ -0,0 +1,20 @@
+import type { EnhancedProvider } from "../types/generate-types.js";
+import type { AIProvider } from "../core/types.js";
+/**
+ * Factory for enhancing providers with generate() capability using Proxy pattern
+ * Maintains 100% backward compatibility while adding new generate method
+ */
+export declare class ProviderGenerateFactory {
+    /**
+     * Enhance any provider with generate() method using TypeScript Proxy
+     */
+    static enhanceProvider<T extends AIProvider>(provider: T): T & EnhancedProvider;
+    /**
+     * Create the generate() method that internally uses generateText for performance parity
+     */
+    private static createGenerateMethod;
+    /**
+     * Enhance all providers from a registry
+     */
+    static enhanceAllProviders(providers: Map<string, AIProvider>): Map<string, AIProvider & EnhancedProvider>;
+}

package/dist/factories/provider-generate-factory.js

@@ -0,0 +1,87 @@
+import { CompatibilityConversionFactory } from "./compatibility-factory.js";
+/**
+ * Factory for enhancing providers with generate() capability using Proxy pattern
+ * Maintains 100% backward compatibility while adding new generate method
+ */
+export class ProviderGenerateFactory {
+    /**
+     * Enhance any provider with generate() method using TypeScript Proxy
+     */
+    static enhanceProvider(provider) {
+        return new Proxy(provider, {
+            get(target, prop, receiver) {
+                if (prop === "generate") {
+                    return ProviderGenerateFactory.createGenerateMethod(target);
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+            has(target, prop) {
+                if (prop === "generate") {
+                    return true;
+                }
+                return Reflect.has(target, prop);
+            },
+        });
+    }
+    /**
+     * Create the generate() method that internally uses generateText for performance parity
+     */
+    static createGenerateMethod(provider) {
+        return async (options) => {
+            // Validate input
+            if (!options.input?.text) {
+                throw new Error("Generate options must include input.text");
+            }
+            // Convert GenerateOptions to TextGenerationOptions
+            const textOptions = CompatibilityConversionFactory.convertGenerateToText_Options(options);
+            try {
+                // Use existing generate method for identical performance
+                const textResult = await provider.generate(textOptions);
+                // Convert back to GenerateResult format with type safety
+                const generateResult = {
+                    content: textResult?.content || "",
+                    outputs: { text: textResult?.content || "" },
+                    provider: textResult?.provider,
+                    model: textResult?.model,
+                    usage: textResult?.usage
+                        ? {
+                            inputTokens: textResult.usage?.promptTokens || 0,
+                            outputTokens: textResult.usage?.completionTokens || 0,
+                            totalTokens: textResult.usage?.totalTokens || 0,
+                        }
+                        : undefined,
+                    responseTime: textResult?.responseTime,
+                    toolsUsed: textResult?.toolsUsed,
+                    toolExecutions: textResult?.toolExecutions?.map((te) => ({
+                        name: te.toolName || te.name || "",
+                        input: te.input || {},
+                        output: te.output || te.result,
+                        duration: te.executionTime || te.duration || 0,
+                    })),
+                    enhancedWithTools: textResult?.enhancedWithTools,
+                    availableTools: textResult?.availableTools?.map((at) => ({
+                        name: at.name || "",
+                        description: at.description || "",
+                        parameters: at.parameters || {},
+                    })),
+                    analytics: textResult?.analytics,
+                    evaluation: textResult?.evaluation,
+                };
+                return generateResult;
+            }
+            catch (error) {
+                throw new Error(`Generate method failed: ${error}`);
+            }
+        };
+    }
+    /**
+     * Enhance all providers from a registry
+     */
+    static enhanceAllProviders(providers) {
+        const enhancedProviders = new Map();
+        for (const [name, provider] of providers) {
+            enhancedProviders.set(name, this.enhanceProvider(provider));
+        }
+        return enhancedProviders;
+    }
+}

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;
+}

package/dist/factories/provider-registry.js

@@ -0,0 +1,107 @@
+import { ProviderFactory } from "./provider-factory.js";
+// ✅ FINAL CIRCULAR DEPENDENCY FIX: Lazy loading all providers
+// 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 {
+            // ✅ LAZY LOADING: Register providers with dynamic import factory functions
+            const { ProviderFactory } = await import("./provider-factory.js");
+            // Register Google AI Studio Provider (our validated baseline)
+            ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, providerName, sdk) => {
+                const { GoogleAIStudioProvider } = await import("../providers/google-ai-studio.js");
+                return new GoogleAIStudioProvider(modelName, sdk);
+            }, GoogleAIModels.GEMINI_2_5_FLASH, ["google-ai-studio", "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);
+            }, 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/amazon-bedrock.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/azure-openai.js");
+                return new AzureOpenAIProvider(modelName);
+            }, "gpt-4o-mini", ["azure", "azure-openai"]);
+            // Register Google Vertex AI provider
+            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName) => {
+                const { GoogleVertexProvider } = await import("../providers/google-vertex.js");
+                return new GoogleVertexProvider(modelName);
+            }, "gemini-2.5-pro", ["vertex", "google-vertex"]);
+            // 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"]);
+            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

package/dist/index.d.ts

@@ -9,13 +9,16 @@
 import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
 export type { AIProvider, AIProviderName, ProviderConfig, StreamingOptions, ProviderAttempt, SupportedModelName, } from "./core/types.js";
+export type { GenerateOptions, GenerateResult, EnhancedProvider, } from "./types/generate-types.js";
+export { CompatibilityConversionFactory } from "./factories/compatibility-factory.js";
+export { ProviderGenerateFactory } from "./factories/provider-generate-factory.js";
+export type { SimpleTool, ToolContext } from "./sdk/tool-registration.js";
+export { createTool, createTypedTool, validateTool, } from "./sdk/tool-registration.js";
+export type { InMemoryMCPServerConfig, InMemoryToolInfo, InMemoryToolResult, } from "./types/mcp-types.js";
 export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./core/types.js";
-export { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, } from "./providers/index.js";
-export type { ProviderName } from "./providers/index.js";
-export { PROVIDERS, AVAILABLE_PROVIDERS } from "./providers/index.js";
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 export { NeuroLink } from "./neurolink.js";
-export type { TextGenerationOptions, StreamTextOptions, TextGenerationResult, } from "./neurolink.js";
+export type { ProviderStatus, MCPStatus, MCPServerInfo } from "./neurolink.js";
 export declare const VERSION = "1.0.0";
 /**
  * Quick start factory function
@@ -25,7 +28,7 @@ export declare const VERSION = "1.0.0";
  * import { createAIProvider } from '@juspay/neurolink';
  *
  * const provider = await createAIProvider('bedrock');
- * const result = await provider.streamText('Hello, AI!');
+ * const result = await provider.stream({ input: { text: 'Hello, AI!' } });
  * ```
  */
 export declare function createAIProvider(providerName?: string, modelName?: string): Promise<import("./core/types.js").AIProvider>;

package/dist/index.js

@@ -9,14 +9,14 @@
 // Core exports
 import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
+export { CompatibilityConversionFactory } from "./factories/compatibility-factory.js";
+export { ProviderGenerateFactory } from "./factories/provider-generate-factory.js";
+export { createTool, createTypedTool, validateTool, } from "./sdk/tool-registration.js";
 // Model enums
 export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./core/types.js";
-// Provider exports
-export { GoogleVertexAI, AmazonBedrock, OpenAI, AnthropicProvider, AzureOpenAIProvider, } from "./providers/index.js";
-export { PROVIDERS, AVAILABLE_PROVIDERS } from "./providers/index.js";
 // Utility exports
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
-// Main NeuroLink wrapper class
+// Main NeuroLink wrapper class and diagnostic types
 export { NeuroLink } from "./neurolink.js";
 // Version
 export const VERSION = "1.0.0";
@@ -28,7 +28,7 @@ export const VERSION = "1.0.0";
  * import { createAIProvider } from '@juspay/neurolink';
  *
  * const provider = await createAIProvider('bedrock');
- * const result = await provider.streamText('Hello, AI!');
+ * const result = await provider.stream({ input: { text: 'Hello, AI!' } });
  * ```
  */
 export async function createAIProvider(providerName, modelName) {

package/dist/lib/agent/direct-tools.d.ts

@@ -220,8 +220,8 @@ export declare const directAgentTools: {
         mode: z.ZodDefault<z.ZodEnum<["create", "overwrite", "append"]>>;
     }, "strip", z.ZodTypeAny, {
         path: string;
-        mode: "create" | "overwrite" | "append";
         content: string;
+        mode: "create" | "overwrite" | "append";
     }, {
         path: string;
         content: string;
@@ -250,8 +250,8 @@ export declare const directAgentTools: {
     }> & {
         execute: (args: {
             path: string;
-            mode: "create" | "overwrite" | "append";
             content: string;
+            mode: "create" | "overwrite" | "append";
         }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
             success: boolean;
             error: string;
@@ -563,8 +563,8 @@ export declare function getToolsForCategory(category?: "basic" | "filesystem" |
         mode: z.ZodDefault<z.ZodEnum<["create", "overwrite", "append"]>>;
     }, "strip", z.ZodTypeAny, {
         path: string;
-        mode: "create" | "overwrite" | "append";
         content: string;
+        mode: "create" | "overwrite" | "append";
     }, {
         path: string;
         content: string;
@@ -593,8 +593,8 @@ export declare function getToolsForCategory(category?: "basic" | "filesystem" |
     }> & {
         execute: (args: {
             path: string;
-            mode: "create" | "overwrite" | "append";
             content: string;
+            mode: "create" | "overwrite" | "append";
         }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
             success: boolean;
             error: string;
@@ -907,8 +907,8 @@ export declare function getToolsForCategory(category?: "basic" | "filesystem" |
         mode: z.ZodDefault<z.ZodEnum<["create", "overwrite", "append"]>>;
     }, "strip", z.ZodTypeAny, {
         path: string;
-        mode: "create" | "overwrite" | "append";
         content: string;
+        mode: "create" | "overwrite" | "append";
     }, {
         path: string;
         content: string;
@@ -937,8 +937,8 @@ export declare function getToolsForCategory(category?: "basic" | "filesystem" |
     }> & {
         execute: (args: {
             path: string;
-            mode: "create" | "overwrite" | "append";
             content: string;
+            mode: "create" | "overwrite" | "append";
         }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
             success: boolean;
             error: string;

package/dist/lib/chat/sse-handler.js

@@ -42,14 +42,15 @@ export class SSEChatHandler {
                     data: { type: "start", sessionId, messageId: userMessage.id },
                 });
                 // Generate AI response with streaming
-                const aiResponse = await this.provider.streamText({
-                    prompt: message,
+                const aiResponse = await this.provider.stream({
+                    input: { text: message },
                     temperature: options.temperature,
                     maxTokens: options.maxTokens,
                     systemPrompt: options.systemPrompt,
                 });
-                if (aiResponse?.textStream) {
-                    const reader = aiResponse.textStream.getReader();
+                if (aiResponse?.stream) {
+                    // Convert async iterable to readable stream
+                    const reader = aiResponse.stream;
                     let fullResponse = "";
                     try {
                         while (true) {