@juspay/neurolink 7.24.1 → 7.25.0

package/dist/lib/middleware/factory.js

@@ -0,0 +1,289 @@
+import { wrapLanguageModel } from "ai";
+import { middlewareRegistry } from "./registry.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Middleware factory for creating and applying middleware chains
+ */
+export class MiddlewareFactory {
+    /**
+     * Apply middleware to a language model
+     */
+    static applyMiddleware(model, context, options = {}) {
+        const startTime = Date.now();
+        try {
+            // Build middleware configuration
+            const middlewareConfig = this.buildMiddlewareConfig(options);
+            // Build middleware chain
+            const middlewareChain = middlewareRegistry.buildChain(context, middlewareConfig);
+            if (middlewareChain.length === 0) {
+                logger.debug("No middleware to apply", { provider: context.provider });
+                return model;
+            }
+            logger.debug(`Applying ${middlewareChain.length} middleware to model`, {
+                provider: context.provider,
+                model: context.model,
+                middlewareCount: middlewareChain.length,
+            });
+            // Apply middleware using AI SDK's wrapLanguageModel
+            // Cast to the expected AI SDK middleware type
+            const wrappedModel = wrapLanguageModel({
+                model,
+                middleware: middlewareChain,
+            });
+            const processingTime = Date.now() - startTime;
+            logger.debug("Middleware applied successfully", {
+                provider: context.provider,
+                middlewareCount: middlewareChain.length,
+                processingTime,
+            });
+            return wrappedModel;
+        }
+        catch (error) {
+            logger.error("Failed to apply middleware", {
+                provider: context.provider,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Return original model on error to maintain functionality
+            return model;
+        }
+    }
+    /**
+     * Build middleware configuration from factory options
+     */
+    static buildMiddlewareConfig(options) {
+        const config = {};
+        // Start with all registered middleware
+        const allMiddleware = middlewareRegistry.list();
+        for (const middleware of allMiddleware) {
+            // Default configuration
+            config[middleware.metadata.id] = {
+                enabled: middleware.metadata.defaultEnabled || false,
+                config: {},
+            };
+        }
+        // Apply preset configuration if specified
+        if (options.preset) {
+            const presetConfig = this.getPresetConfig(options.preset);
+            if (presetConfig) {
+                Object.assign(config, presetConfig);
+            }
+        }
+        // Apply explicit middleware configurations
+        if (options.middlewareConfig) {
+            for (const [middlewareId, middlewareConfig] of Object.entries(options.middlewareConfig)) {
+                config[middlewareId] = {
+                    ...config[middlewareId],
+                    ...middlewareConfig,
+                };
+            }
+        }
+        // Apply enabled middleware list
+        if (options.enabledMiddleware) {
+            for (const middlewareId of options.enabledMiddleware) {
+                if (config[middlewareId]) {
+                    config[middlewareId].enabled = true;
+                }
+            }
+        }
+        // Apply disabled middleware list
+        if (options.disabledMiddleware) {
+            for (const middlewareId of options.disabledMiddleware) {
+                if (config[middlewareId]) {
+                    config[middlewareId].enabled = false;
+                }
+            }
+        }
+        return config;
+    }
+    /**
+     * 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 },
+            },
+        };
+    }
+    /**
+     * Create middleware context from provider and options
+     */
+    static createContext(provider, model, options = {}, session) {
+        return {
+            provider,
+            model,
+            options,
+            session,
+            metadata: {
+                timestamp: Date.now(),
+                requestId: `${provider}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            },
+        };
+    }
+    /**
+     * Validate middleware configuration
+     */
+    static validateConfig(config) {
+        const errors = [];
+        const warnings = [];
+        for (const [middlewareId, middlewareConfig] of Object.entries(config)) {
+            // Check if middleware is registered
+            if (!middlewareRegistry.has(middlewareId)) {
+                errors.push(`Middleware '${middlewareId}' is not registered`);
+                continue;
+            }
+            // Validate configuration structure
+            if (middlewareConfig.enabled !== undefined &&
+                typeof middlewareConfig.enabled !== "boolean") {
+                errors.push(`Middleware '${middlewareId}' enabled property must be boolean`);
+            }
+            if (middlewareConfig.config &&
+                typeof middlewareConfig.config !== "object") {
+                errors.push(`Middleware '${middlewareId}' config property must be an object`);
+            }
+            // Check for potential conflicts
+            if (middlewareConfig.conditions?.providers &&
+                middlewareConfig.conditions.providers.length === 0) {
+                warnings.push(`Middleware '${middlewareId}' has empty providers condition`);
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * 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"],
+            },
+        ];
+    }
+    /**
+     * Get middleware chain statistics
+     */
+    static getChainStats(context, config) {
+        const chain = middlewareRegistry.buildChain(context, config);
+        const stats = middlewareRegistry.getAggregatedStats();
+        const results = {};
+        let totalExecutionTime = 0;
+        let appliedMiddleware = 0;
+        for (const [middlewareId, middlewareStats] of Object.entries(stats)) {
+            if (config[middlewareId]?.enabled) {
+                results[middlewareId] = {
+                    applied: true,
+                    executionTime: middlewareStats.averageExecutionTime,
+                };
+                totalExecutionTime += middlewareStats.averageExecutionTime;
+                appliedMiddleware++;
+            }
+        }
+        return {
+            totalMiddleware: chain.length,
+            appliedMiddleware,
+            totalExecutionTime,
+            results,
+        };
+    }
+    /**
+     * Create a middleware-enabled model factory function
+     */
+    static createModelFactory(baseModelFactory, defaultOptions = {}) {
+        return async (context, options = {}) => {
+            // Get base model
+            const baseModel = await baseModelFactory();
+            // Merge options
+            const _mergedOptions = {
+                ...defaultOptions,
+                ...options,
+                middlewareConfig: {
+                    ...defaultOptions.middlewareConfig,
+                    ...options.middlewareConfig,
+                },
+            };
+            // Apply middleware
+            return this.applyMiddleware(baseModel, context, _mergedOptions);
+        };
+    }
+}

package/dist/lib/middleware/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * NeuroLink Middleware System
+ *
+ * This module provides a comprehensive middleware system for NeuroLink that integrates
+ * 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";
+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[];
+};

package/dist/lib/middleware/index.js

@@ -0,0 +1,67 @@
+/**
+ * NeuroLink Middleware System
+ *
+ * This module provides a comprehensive middleware system for NeuroLink that integrates
+ * 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 { 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);
+}

package/dist/lib/middleware/registry.d.ts

@@ -0,0 +1,78 @@
+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
+ */
+export declare class MiddlewareRegistry {
+    private middleware;
+    private globalConfigs;
+    private executionStats;
+    /**
+     * Register a middleware
+     */
+    register(middleware: NeuroLinkMiddleware, options?: MiddlewareRegistrationOptions): void;
+    /**
+     * Unregister a middleware
+     */
+    unregister(middlewareId: string): boolean;
+    /**
+     * Get a registered middleware
+     */
+    get(middlewareId: string): NeuroLinkMiddleware | undefined;
+    /**
+     * List all registered middleware
+     */
+    list(): NeuroLinkMiddleware[];
+    /**
+     * Get middleware IDs sorted by priority
+     */
+    getSortedIds(): string[];
+    /**
+     * Build middleware chain based on configuration
+     */
+    buildChain(context: MiddlewareContext, config?: Record<string, MiddlewareConfig>): LanguageModelV1Middleware[];
+    /**
+     * Determine if middleware should be applied based on conditions
+     */
+    private shouldApplyMiddleware;
+    /**
+     * Configure middleware with runtime configuration
+     */
+    private configureMiddleware;
+    /**
+     * Record middleware execution statistics
+     */
+    private recordExecution;
+    /**
+     * Get execution statistics for a middleware
+     */
+    getExecutionStats(middlewareId: string): MiddlewareExecutionResult[];
+    /**
+     * Get aggregated statistics for all middleware
+     */
+    getAggregatedStats(): Record<string, {
+        totalExecutions: number;
+        successfulExecutions: number;
+        failedExecutions: number;
+        averageExecutionTime: number;
+        lastExecutionTime: number;
+    }>;
+    /**
+     * Clear execution statistics
+     */
+    clearStats(middlewareId?: string): void;
+    /**
+     * Check if a middleware is registered
+     */
+    has(middlewareId: string): boolean;
+    /**
+     * Get the number of registered middleware
+     */
+    size(): number;
+    /**
+     * Clear all registered middleware
+     */
+    clear(): void;
+}
+export declare const middlewareRegistry: MiddlewareRegistry;