@juspay/neurolink 5.1.0 → 5.3.0

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

@@ -12,12 +12,13 @@ export type { AIProvider, AIProviderName, ProviderConfig, StreamingOptions, Prov
 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 { ProviderStatus, MCPStatus, MCPServerInfo } from "./neurolink.js";
 export declare const VERSION = "1.0.0";
 /**
  * Quick start factory function

package/dist/index.js

@@ -11,14 +11,12 @@ 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";

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/core/base-provider.d.ts

@@ -0,0 +1,423 @@
+import type { ZodType, ZodTypeDef } from "zod";
+import type { Schema } from "ai";
+import type { Tool } from "ai";
+import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult, AnalyticsData, AIProviderName } from "../core/types.js";
+import type { StreamOptions, StreamResult } from "../types/stream-types.js";
+/**
+ * Abstract base class for all AI providers
+ * Tools are integrated as first-class citizens - always available by default
+ */
+export declare abstract class BaseProvider implements AIProvider {
+    protected readonly modelName: string;
+    protected readonly providerName: AIProviderName;
+    protected readonly defaultTimeout: number;
+    protected readonly directTools: {
+        getCurrentTime: Tool<import("zod").ZodObject<{
+            timezone: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strip", import("zod").ZodTypeAny, {
+            timezone?: string | undefined;
+        }, {
+            timezone?: string | undefined;
+        }>, {
+            success: boolean;
+            time: string;
+            timezone: string;
+            iso: string;
+            timestamp?: undefined;
+            error?: undefined;
+        } | {
+            success: boolean;
+            time: string;
+            iso: string;
+            timestamp: number;
+            timezone?: undefined;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            time?: undefined;
+            timezone?: undefined;
+            iso?: undefined;
+            timestamp?: undefined;
+        }> & {
+            execute: (args: {
+                timezone?: string | undefined;
+            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+                success: boolean;
+                time: string;
+                timezone: string;
+                iso: string;
+                timestamp?: undefined;
+                error?: undefined;
+            } | {
+                success: boolean;
+                time: string;
+                iso: string;
+                timestamp: number;
+                timezone?: undefined;
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                time?: undefined;
+                timezone?: undefined;
+                iso?: undefined;
+                timestamp?: undefined;
+            }>;
+        };
+        readFile: Tool<import("zod").ZodObject<{
+            path: import("zod").ZodString;
+        }, "strip", import("zod").ZodTypeAny, {
+            path: string;
+        }, {
+            path: string;
+        }>, {
+            success: boolean;
+            error: string;
+            content?: undefined;
+            size?: undefined;
+            path?: undefined;
+            lastModified?: undefined;
+        } | {
+            success: boolean;
+            content: string;
+            size: number;
+            path: string;
+            lastModified: string;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            path: string;
+            content?: undefined;
+            size?: undefined;
+            lastModified?: undefined;
+        }> & {
+            execute: (args: {
+                path: string;
+            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+                success: boolean;
+                error: string;
+                content?: undefined;
+                size?: undefined;
+                path?: undefined;
+                lastModified?: undefined;
+            } | {
+                success: boolean;
+                content: string;
+                size: number;
+                path: string;
+                lastModified: string;
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                path: string;
+                content?: undefined;
+                size?: undefined;
+                lastModified?: undefined;
+            }>;
+        };
+        listDirectory: Tool<import("zod").ZodObject<{
+            path: import("zod").ZodString;
+            includeHidden: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            path: string;
+            includeHidden: boolean;
+        }, {
+            path: string;
+            includeHidden?: boolean | undefined;
+        }>, {
+            success: boolean;
+            path: string;
+            items: {
+                name: string;
+                type: string;
+                size: number | undefined;
+                lastModified: string;
+            }[];
+            count: number;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            path: string;
+            items?: undefined;
+            count?: undefined;
+        }> & {
+            execute: (args: {
+                path: string;
+                includeHidden: boolean;
+            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+                success: boolean;
+                path: string;
+                items: {
+                    name: string;
+                    type: string;
+                    size: number | undefined;
+                    lastModified: string;
+                }[];
+                count: number;
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                path: string;
+                items?: undefined;
+                count?: undefined;
+            }>;
+        };
+        calculateMath: Tool<import("zod").ZodObject<{
+            expression: import("zod").ZodString;
+            precision: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            expression: string;
+            precision: number;
+        }, {
+            expression: string;
+            precision?: number | undefined;
+        }>, {
+            success: boolean;
+            error: string;
+            expression?: undefined;
+            result?: undefined;
+            type?: undefined;
+        } | {
+            success: boolean;
+            expression: string;
+            result: any;
+            type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            expression: string;
+            result?: undefined;
+            type?: undefined;
+        }> & {
+            execute: (args: {
+                expression: string;
+                precision: number;
+            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+                success: boolean;
+                error: string;
+                expression?: undefined;
+                result?: undefined;
+                type?: undefined;
+            } | {
+                success: boolean;
+                expression: string;
+                result: any;
+                type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                expression: string;
+                result?: undefined;
+                type?: undefined;
+            }>;
+        };
+        writeFile: Tool<import("zod").ZodObject<{
+            path: import("zod").ZodString;
+            content: import("zod").ZodString;
+            mode: import("zod").ZodDefault<import("zod").ZodEnum<["create", "overwrite", "append"]>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            path: string;
+            content: string;
+            mode: "create" | "overwrite" | "append";
+        }, {
+            path: string;
+            content: string;
+            mode?: "create" | "overwrite" | "append" | undefined;
+        }>, {
+            success: boolean;
+            error: string;
+            path?: undefined;
+            mode?: undefined;
+            size?: undefined;
+            written?: undefined;
+        } | {
+            success: boolean;
+            path: string;
+            mode: "create" | "overwrite" | "append";
+            size: number;
+            written: number;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            path: string;
+            mode?: undefined;
+            size?: undefined;
+            written?: undefined;
+        }> & {
+            execute: (args: {
+                path: string;
+                content: string;
+                mode: "create" | "overwrite" | "append";
+            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+                success: boolean;
+                error: string;
+                path?: undefined;
+                mode?: undefined;
+                size?: undefined;
+                written?: undefined;
+            } | {
+                success: boolean;
+                path: string;
+                mode: "create" | "overwrite" | "append";
+                size: number;
+                written: number;
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                path: string;
+                mode?: undefined;
+                size?: undefined;
+                written?: undefined;
+            }>;
+        };
+        searchFiles: Tool<import("zod").ZodObject<{
+            directory: import("zod").ZodString;
+            pattern: import("zod").ZodString;
+            recursive: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        }, "strip", import("zod").ZodTypeAny, {
+            directory: string;
+            pattern: string;
+            recursive: boolean;
+        }, {
+            directory: string;
+            pattern: string;
+            recursive?: boolean | undefined;
+        }>, {
+            success: boolean;
+            error: string;
+            directory?: undefined;
+            pattern?: undefined;
+            matches?: undefined;
+            count?: undefined;
+        } | {
+            success: boolean;
+            directory: string;
+            pattern: string;
+            matches: {
+                name: string;
+                path: string;
+                size: number;
+                lastModified: string;
+            }[];
+            count: number;
+            error?: undefined;
+        } | {
+            success: boolean;
+            error: string;
+            directory: string;
+            pattern: string;
+            matches?: undefined;
+            count?: undefined;
+        }> & {
+            execute: (args: {
+                directory: string;
+                pattern: string;
+                recursive: boolean;
+            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+                success: boolean;
+                error: string;
+                directory?: undefined;
+                pattern?: undefined;
+                matches?: undefined;
+                count?: undefined;
+            } | {
+                success: boolean;
+                directory: string;
+                pattern: string;
+                matches: {
+                    name: string;
+                    path: string;
+                    size: number;
+                    lastModified: string;
+                }[];
+                count: number;
+                error?: undefined;
+            } | {
+                success: boolean;
+                error: string;
+                directory: string;
+                pattern: string;
+                matches?: undefined;
+                count?: undefined;
+            }>;
+        };
+    };
+    protected mcpTools?: Record<string, Tool>;
+    protected sessionId?: string;
+    protected userId?: string;
+    protected sdk?: any;
+    constructor(modelName?: string, providerName?: AIProviderName, sdk?: any);
+    /**
+     * Check if this provider supports tool/function calling
+     * Override in subclasses to disable tools for specific providers or models
+     * @returns true by default, providers can override to return false
+     */
+    supportsTools(): boolean;
+    /**
+     * Primary streaming method - implements AIProvider interface
+     * When tools are involved, falls back to generate() with synthetic streaming
+     */
+    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    /**
+     * Text generation method - implements AIProvider interface
+     * Tools are always available unless explicitly disabled
+     */
+    generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
+    /**
+     * Alias for generate method - implements AIProvider interface
+     */
+    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
+    /**
+     * Provider-specific streaming implementation (only used when tools are disabled)
+     */
+    protected abstract executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    /**
+     * Get the provider name
+     */
+    protected abstract getProviderName(): AIProviderName;
+    /**
+     * Get the default model for this provider
+     */
+    protected abstract getDefaultModel(): string;
+    /**
+     * REQUIRED: Every provider MUST implement this method
+     * Returns the Vercel AI SDK model instance for this provider
+     */
+    protected abstract getAISDKModel(): any | Promise<any>;
+    /**
+     * Get all available tools - direct tools are ALWAYS available
+     * MCP tools are added when available (without blocking)
+     */
+    protected getAllTools(): Promise<Record<string, Tool>>;
+    /**
+     * Set session context for MCP tools
+     */
+    setSessionContext(sessionId?: string, userId?: string): void;
+    /**
+     * Provider-specific error handling
+     */
+    protected abstract handleProviderError(error: any): Error;
+    protected normalizeTextOptions(optionsOrPrompt: TextGenerationOptions | string): TextGenerationOptions;
+    protected normalizeStreamOptions(optionsOrPrompt: StreamOptions | string): StreamOptions;
+    protected enhanceResult(result: EnhancedGenerateResult, options: TextGenerationOptions, startTime: number): Promise<EnhancedGenerateResult>;
+    protected createAnalytics(result: EnhancedGenerateResult, responseTime: number, options: TextGenerationOptions): Promise<AnalyticsData>;
+    protected createEvaluation(result: EnhancedGenerateResult, options: TextGenerationOptions): Promise<any>;
+    protected validateOptions(options: TextGenerationOptions): void;
+    protected getProviderInfo(): {
+        provider: string;
+        model: string;
+    };
+    /**
+     * Get timeout value in milliseconds
+     */
+    getTimeout(options: TextGenerationOptions | StreamOptions): number;
+}