@juspay/neurolink 7.28.0 → 7.29.0

package/dist/middleware/factory.d.ts

@@ -1,36 +1,51 @@
 import type { LanguageModelV1 } from "ai";
-import type { MiddlewareContext, MiddlewareConfig, MiddlewareFactoryOptions, MiddlewareChainStats } from "./types.js";
+import type { MiddlewareContext, MiddlewareConfig, MiddlewareFactoryOptions, MiddlewareChainStats, MiddlewarePreset, NeuroLinkMiddleware, MiddlewareRegistrationOptions } from "./types.js";
+import { MiddlewareRegistry } from "./registry.js";
 /**
- * Middleware factory for creating and applying middleware chains
+ * Middleware factory for creating and applying middleware chains.
+ * Each factory instance manages its own registry and configuration.
  */
 export declare class MiddlewareFactory {
+    registry: MiddlewareRegistry;
+    presets: Map<string, MiddlewarePreset>;
+    private options;
+    constructor(options?: MiddlewareFactoryOptions);
+    /**
+     * Initialize the factory with built-in middleware and presets
+     */
+    private initialize;
+    /**
+     * Register a custom preset
+     */
+    registerPreset(preset: MiddlewarePreset, replace?: boolean): void;
+    /**
+     * Register a custom middleware
+     */
+    register(middleware: NeuroLinkMiddleware, options?: MiddlewareRegistrationOptions): void;
     /**
      * Apply middleware to a language model
      */
-    static applyMiddleware(model: LanguageModelV1, context: MiddlewareContext, options?: MiddlewareFactoryOptions): LanguageModelV1;
+    applyMiddleware(model: LanguageModelV1, context: MiddlewareContext, options?: MiddlewareFactoryOptions): LanguageModelV1;
+    private getCreator;
     /**
      * Build middleware configuration from factory options
      */
-    private static buildMiddlewareConfig;
+    private buildMiddlewareConfig;
     /**
      * Get preset configuration
      */
-    private static getPresetConfig;
-    /**
-     * Get built-in preset configurations
-     */
-    private static getBuiltInPresets;
+    private getPresetConfig;
     /**
      * Create middleware context from provider and options
      */
-    static createContext(provider: string, model: string, options?: Record<string, unknown>, session?: {
+    createContext(provider: string, model: string, options?: Record<string, unknown>, session?: {
         sessionId?: string;
         userId?: string;
     }): MiddlewareContext;
     /**
      * Validate middleware configuration
      */
-    static validateConfig(config: Record<string, MiddlewareConfig>): {
+    validateConfig(config: Record<string, MiddlewareConfig>): {
         isValid: boolean;
         errors: string[];
         warnings: string[];
@@ -38,7 +53,7 @@ export declare class MiddlewareFactory {
     /**
      * Get available presets
      */
-    static getAvailablePresets(): Array<{
+    getAvailablePresets(): Array<{
         name: string;
         description: string;
         middleware: string[];
@@ -46,9 +61,9 @@ export declare class MiddlewareFactory {
     /**
      * Get middleware chain statistics
      */
-    static getChainStats(context: MiddlewareContext, config: Record<string, MiddlewareConfig>): MiddlewareChainStats;
+    getChainStats(context: MiddlewareContext, config: Record<string, MiddlewareConfig>): MiddlewareChainStats;
     /**
      * Create a middleware-enabled model factory function
      */
-    static createModelFactory(baseModelFactory: () => Promise<LanguageModelV1>, defaultOptions?: MiddlewareFactoryOptions): (context: MiddlewareContext, options?: MiddlewareFactoryOptions) => Promise<LanguageModelV1>;
+    createModelFactory(baseModelFactory: () => Promise<LanguageModelV1>, defaultOptions?: MiddlewareFactoryOptions): (context: MiddlewareContext, options?: MiddlewareFactoryOptions) => Promise<LanguageModelV1>;
 }

package/dist/middleware/factory.js

@@ -1,20 +1,104 @@
 import { wrapLanguageModel } from "ai";
-import { middlewareRegistry } from "./registry.js";
+import { MiddlewareRegistry } from "./registry.js";
+import { createAnalyticsMiddleware } from "./builtin/analytics.js";
+import { createGuardrailsMiddleware } from "./builtin/guardrails.js";
 import { logger } from "../utils/logger.js";
 /**
- * Middleware factory for creating and applying middleware chains
+ * Middleware factory for creating and applying middleware chains.
+ * Each factory instance manages its own registry and configuration.
  */
 export class MiddlewareFactory {
+    registry;
+    presets = new Map();
+    options;
+    constructor(options = {}) {
+        this.options = options;
+        this.registry = new MiddlewareRegistry();
+        this.initialize(options);
+    }
+    /**
+     * Initialize the factory with built-in middleware and presets
+     */
+    initialize(options) {
+        // Register built-in middleware creators
+        const builtInMiddlewareCreators = {
+            analytics: createAnalyticsMiddleware,
+            guardrails: createGuardrailsMiddleware,
+        };
+        // Register built-in presets
+        this.registerPreset({
+            name: "default",
+            description: "Default preset with analytics enabled.",
+            config: { analytics: { enabled: true } },
+        });
+        this.registerPreset({
+            name: "all",
+            description: "Enables all available middleware.",
+            config: { analytics: { enabled: true }, guardrails: { enabled: true } },
+        });
+        this.registerPreset({
+            name: "security",
+            description: "Focuses on security with guardrails.",
+            config: { guardrails: { enabled: true } },
+        });
+        // Register custom middleware if provided
+        if (options.middleware) {
+            for (const customMiddleware of options.middleware) {
+                this.register(customMiddleware);
+            }
+        }
+        // Register all built-in middleware so they are available to be configured
+        for (const middlewareId in builtInMiddlewareCreators) {
+            if (!this.registry.has(middlewareId)) {
+                const creator = builtInMiddlewareCreators[middlewareId];
+                const config = options.middlewareConfig?.[middlewareId]?.config;
+                this.registry.register(creator(config));
+            }
+        }
+    }
+    /**
+     * Register a custom preset
+     */
+    registerPreset(preset, replace = false) {
+        if (this.presets.has(preset.name) && !replace) {
+            throw new Error(`Preset with name '${preset.name}' already exists. Use replace: true to override.`);
+        }
+        this.presets.set(preset.name, preset);
+    }
+    /**
+     * Register a custom middleware
+     */
+    register(middleware, options) {
+        this.registry.register(middleware, options);
+    }
     /**
      * Apply middleware to a language model
      */
-    static applyMiddleware(model, context, options = {}) {
+    applyMiddleware(model, context, options = {}) {
         const startTime = Date.now();
         try {
+            // Merge constructor options with call-time options
+            const mergedOptions = {
+                ...this.options,
+                ...options,
+                middlewareConfig: {
+                    ...this.options.middlewareConfig,
+                    ...options.middlewareConfig,
+                },
+            };
             // Build middleware configuration
-            const middlewareConfig = this.buildMiddlewareConfig(options);
+            const middlewareConfig = this.buildMiddlewareConfig(mergedOptions);
+            // Re-register middleware with the correct configuration for this call
+            for (const [id, config] of Object.entries(middlewareConfig)) {
+                if (config.enabled && this.registry.has(id)) {
+                    const creator = this.getCreator(id);
+                    if (creator) {
+                        this.registry.register(creator(config.config), { replace: true });
+                    }
+                }
+            }
             // Build middleware chain
-            const middlewareChain = middlewareRegistry.buildChain(context, middlewareConfig);
+            const middlewareChain = this.registry.buildChain(context, middlewareConfig);
             if (middlewareChain.length === 0) {
                 logger.debug("No middleware to apply", { provider: context.provider });
                 return model;
@@ -47,25 +131,47 @@ export class MiddlewareFactory {
             return model;
         }
     }
+    getCreator(id) {
+        const builtInMiddlewareCreators = {
+            analytics: createAnalyticsMiddleware,
+            guardrails: createGuardrailsMiddleware,
+        };
+        return builtInMiddlewareCreators[id];
+    }
     /**
      * Build middleware configuration from factory options
      */
-    static buildMiddlewareConfig(options) {
+    buildMiddlewareConfig(options) {
         const config = {};
-        // Start with all registered middleware
-        const allMiddleware = middlewareRegistry.list();
+        const allMiddleware = this.registry.list();
+        // Initialize all middleware as disabled. Configuration will enable them.
         for (const middleware of allMiddleware) {
-            // Default configuration
             config[middleware.metadata.id] = {
-                enabled: middleware.metadata.defaultEnabled || false,
+                enabled: false,
                 config: {},
             };
         }
-        // Apply preset configuration if specified
-        if (options.preset) {
-            const presetConfig = this.getPresetConfig(options.preset);
+        // Determine which preset to use.
+        let presetName = options.preset;
+        // If no preset is given, and no other specific middleware config is provided, use the default.
+        if (!presetName &&
+            (!options.middlewareConfig ||
+                Object.keys(options.middlewareConfig).length === 0) &&
+            (!options.enabledMiddleware || options.enabledMiddleware.length === 0)) {
+            presetName = "default";
+        }
+        // Apply preset configuration
+        if (presetName) {
+            const presetConfig = this.getPresetConfig(presetName);
             if (presetConfig) {
-                Object.assign(config, presetConfig);
+                for (const [middlewareId, middlewareConfig] of Object.entries(presetConfig)) {
+                    if (config[middlewareId]) {
+                        config[middlewareId] = {
+                            ...config[middlewareId],
+                            ...middlewareConfig,
+                        };
+                    }
+                }
             }
         }
         // Apply explicit middleware configurations
@@ -98,59 +204,14 @@ export class MiddlewareFactory {
     /**
      * Get preset configuration
      */
-    static getPresetConfig(presetName) {
-        const presets = this.getBuiltInPresets();
-        return presets[presetName] || null;
-    }
-    /**
-     * Get built-in preset configurations
-     */
-    static getBuiltInPresets() {
-        return {
-            // Development preset - logging and basic analytics
-            development: {
-                logging: { enabled: true },
-                analytics: { enabled: true },
-            },
-            // Production preset - analytics, caching, rate limiting
-            production: {
-                analytics: { enabled: true },
-                caching: { enabled: true },
-                rateLimit: { enabled: true },
-                retry: { enabled: true },
-            },
-            // Security preset - guardrails and content filtering
-            security: {
-                guardrails: { enabled: true },
-                logging: { enabled: true },
-                rateLimit: { enabled: true },
-            },
-            // Performance preset - caching and optimization
-            performance: {
-                caching: { enabled: true },
-                retry: { enabled: true },
-                timeout: { enabled: true },
-            },
-            // Enterprise preset - all middleware enabled
-            enterprise: {
-                analytics: { enabled: true },
-                guardrails: { enabled: true },
-                logging: { enabled: true },
-                caching: { enabled: true },
-                rateLimit: { enabled: true },
-                retry: { enabled: true },
-                timeout: { enabled: true },
-            },
-            // Minimal preset - only essential middleware
-            minimal: {
-                analytics: { enabled: true },
-            },
-        };
+    getPresetConfig(presetName) {
+        const preset = this.presets.get(presetName);
+        return preset ? preset.config : null;
     }
     /**
      * Create middleware context from provider and options
      */
-    static createContext(provider, model, options = {}, session) {
+    createContext(provider, model, options = {}, session) {
         return {
             provider,
             model,
@@ -165,12 +226,12 @@ export class MiddlewareFactory {
     /**
      * Validate middleware configuration
      */
-    static validateConfig(config) {
+    validateConfig(config) {
         const errors = [];
         const warnings = [];
         for (const [middlewareId, middlewareConfig] of Object.entries(config)) {
             // Check if middleware is registered
-            if (!middlewareRegistry.has(middlewareId)) {
+            if (!this.registry.has(middlewareId)) {
                 errors.push(`Middleware '${middlewareId}' is not registered`);
                 continue;
             }
@@ -198,54 +259,19 @@ export class MiddlewareFactory {
     /**
      * Get available presets
      */
-    static getAvailablePresets() {
-        return [
-            {
-                name: "development",
-                description: "Logging and basic analytics for development",
-                middleware: ["logging", "analytics"],
-            },
-            {
-                name: "production",
-                description: "Optimized for production with caching and rate limiting",
-                middleware: ["analytics", "caching", "rateLimit", "retry"],
-            },
-            {
-                name: "security",
-                description: "Enhanced security with guardrails and monitoring",
-                middleware: ["guardrails", "logging", "rateLimit"],
-            },
-            {
-                name: "performance",
-                description: "Optimized for performance with caching and retries",
-                middleware: ["caching", "retry", "timeout"],
-            },
-            {
-                name: "enterprise",
-                description: "Full enterprise feature set with all middleware",
-                middleware: [
-                    "analytics",
-                    "guardrails",
-                    "logging",
-                    "caching",
-                    "rateLimit",
-                    "retry",
-                    "timeout",
-                ],
-            },
-            {
-                name: "minimal",
-                description: "Minimal overhead with only essential features",
-                middleware: ["analytics"],
-            },
-        ];
+    getAvailablePresets() {
+        return Array.from(this.presets.values()).map((preset) => ({
+            name: preset.name,
+            description: preset.description,
+            middleware: Object.keys(preset.config),
+        }));
     }
     /**
      * Get middleware chain statistics
      */
-    static getChainStats(context, config) {
-        const chain = middlewareRegistry.buildChain(context, config);
-        const stats = middlewareRegistry.getAggregatedStats();
+    getChainStats(context, config) {
+        const chain = this.registry.buildChain(context, config);
+        const stats = this.registry.getAggregatedStats();
         const results = {};
         let totalExecutionTime = 0;
         let appliedMiddleware = 0;
@@ -269,7 +295,7 @@ export class MiddlewareFactory {
     /**
      * Create a middleware-enabled model factory function
      */
-    static createModelFactory(baseModelFactory, defaultOptions = {}) {
+    createModelFactory(baseModelFactory, defaultOptions = {}) {
         return async (context, options = {}) => {
             // Get base model
             const baseModel = await baseModelFactory();

package/dist/middleware/index.d.ts

@@ -5,54 +5,8 @@
  * with the AI SDK's wrapLanguageModel functionality. It allows for modular enhancement
  * of language models with features like analytics, guardrails, caching, and more.
  */
-import type { NeuroLinkMiddleware, MiddlewareRegistrationOptions, MiddlewareConfig } from "./types.js";
+import { MiddlewareFactory } from "./factory.js";
 export type { NeuroLinkMiddleware, MiddlewareConfig, MiddlewareContext, MiddlewareConditions, MiddlewareRegistrationOptions, MiddlewareExecutionResult, MiddlewareChainStats, MiddlewarePreset, MiddlewareFactoryOptions, BuiltInMiddlewareType, } from "./types.js";
 export type { LanguageModelV1Middleware } from "ai";
-export { MiddlewareRegistry, middlewareRegistry } from "./registry.js";
-export { MiddlewareFactory } from "./factory.js";
-/**
- * Convenience function to register a middleware
- */
-export declare function registerMiddleware(middleware: NeuroLinkMiddleware, options?: MiddlewareRegistrationOptions): void;
-/**
- * Convenience function to unregister a middleware
- */
-export declare function unregisterMiddleware(middlewareId: string): boolean;
-/**
- * Convenience function to get all registered middleware
- */
-export declare function listMiddleware(): NeuroLinkMiddleware[];
-/**
- * Convenience function to check if a middleware is registered
- */
-export declare function hasMiddleware(middlewareId: string): boolean;
-/**
- * Convenience function to get middleware execution statistics
- */
-export declare function getMiddlewareStats(): Record<string, {
-    totalExecutions: number;
-    successfulExecutions: number;
-    failedExecutions: number;
-    averageExecutionTime: number;
-    lastExecutionTime: number;
-}>;
-/**
- * Convenience function to clear middleware execution statistics
- */
-export declare function clearMiddlewareStats(middlewareId?: string): void;
-/**
- * Convenience function to get available middleware presets
- */
-export declare function getAvailablePresets(): Array<{
-    name: string;
-    description: string;
-    middleware: string[];
-}>;
-/**
- * Convenience function to validate middleware configuration
- */
-export declare function validateMiddlewareConfig(config: Record<string, MiddlewareConfig>): {
-    isValid: boolean;
-    errors: string[];
-    warnings: string[];
-};
+export { MiddlewareFactory };
+export default MiddlewareFactory;

package/dist/middleware/index.js

@@ -5,63 +5,9 @@
  * with the AI SDK's wrapLanguageModel functionality. It allows for modular enhancement
  * of language models with features like analytics, guardrails, caching, and more.
  */
-import { middlewareRegistry } from "./registry.js";
+// Import types and classes
 import { MiddlewareFactory } from "./factory.js";
-// Registry for managing middleware
-export { MiddlewareRegistry, middlewareRegistry } from "./registry.js";
 // Factory for creating and applying middleware chains
-export { MiddlewareFactory } from "./factory.js";
-// Re-export built-in middleware when they're implemented
-// export { analyticsMiddleware } from './built-in/analytics.js';
-// export { guardrailsMiddleware } from './built-in/guardrails.js';
-// export { loggingMiddleware } from './built-in/logging.js';
-// export { cachingMiddleware } from './built-in/caching.js';
-// export { rateLimitMiddleware } from './built-in/rateLimit.js';
-/**
- * Convenience function to register a middleware
- */
-export function registerMiddleware(middleware, options) {
-    middlewareRegistry.register(middleware, options);
-}
-/**
- * Convenience function to unregister a middleware
- */
-export function unregisterMiddleware(middlewareId) {
-    return middlewareRegistry.unregister(middlewareId);
-}
-/**
- * Convenience function to get all registered middleware
- */
-export function listMiddleware() {
-    return middlewareRegistry.list();
-}
-/**
- * Convenience function to check if a middleware is registered
- */
-export function hasMiddleware(middlewareId) {
-    return middlewareRegistry.has(middlewareId);
-}
-/**
- * Convenience function to get middleware execution statistics
- */
-export function getMiddlewareStats() {
-    return middlewareRegistry.getAggregatedStats();
-}
-/**
- * Convenience function to clear middleware execution statistics
- */
-export function clearMiddlewareStats(middlewareId) {
-    middlewareRegistry.clearStats(middlewareId);
-}
-/**
- * Convenience function to get available middleware presets
- */
-export function getAvailablePresets() {
-    return MiddlewareFactory.getAvailablePresets();
-}
-/**
- * Convenience function to validate middleware configuration
- */
-export function validateMiddlewareConfig(config) {
-    return MiddlewareFactory.validateConfig(config);
-}
+export { MiddlewareFactory };
+// Export the factory as the default export for clean, direct usage
+export default MiddlewareFactory;

package/dist/middleware/registry.d.ts

@@ -1,8 +1,7 @@
 import type { LanguageModelV1Middleware } from "ai";
 import type { NeuroLinkMiddleware, MiddlewareConfig, MiddlewareContext, MiddlewareRegistrationOptions, MiddlewareExecutionResult } from "./types.js";
 /**
- * Global middleware registry for NeuroLink
- * Manages registration, configuration, and execution of middleware
+ * Manages the registration, configuration, and execution of middleware for a single factory instance.
  */
 export declare class MiddlewareRegistry {
     private middleware;
@@ -75,4 +74,3 @@ export declare class MiddlewareRegistry {
      */
     clear(): void;
 }
-export declare const middlewareRegistry: MiddlewareRegistry;

package/dist/middleware/registry.js

@@ -1,7 +1,6 @@
 import { logger } from "../utils/logger.js";
 /**
- * Global middleware registry for NeuroLink
- * Manages registration, configuration, and execution of middleware
+ * Manages the registration, configuration, and execution of middleware for a single factory instance.
  */
 export class MiddlewareRegistry {
     middleware = new Map();
@@ -143,7 +142,9 @@ export class MiddlewareRegistry {
             ...config?.config,
         };
         // Create wrapper that tracks execution
-        const wrappedMiddleware = {};
+        const wrappedMiddleware = {
+            metadata: middleware.metadata,
+        };
         if (middleware.transformParams) {
             wrappedMiddleware.transformParams = async (args) => {
                 const startTime = Date.now();
@@ -279,5 +280,3 @@ export class MiddlewareRegistry {
         logger.debug("All middleware cleared from registry");
     }
 }
-// Global middleware registry instance
-export const middlewareRegistry = new MiddlewareRegistry();

package/dist/middleware/types.d.ts

@@ -118,12 +118,14 @@ export interface MiddlewarePreset {
     /** Description of the preset */
     description: string;
     /** Middleware configurations in the preset */
-    middleware: Record<string, MiddlewareConfig>;
+    config: Record<string, MiddlewareConfig>;
 }
 /**
  * Factory options for middleware
  */
 export interface MiddlewareFactoryOptions {
+    /** Custom middleware to register on initialization */
+    middleware?: NeuroLinkMiddleware[];
     /** Enable specific middleware */
     enabledMiddleware?: string[];
     /** Disable specific middleware */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.28.0",
+  "version": "7.29.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",