@juspay/neurolink 7.24.1 → 7.26.0

package/dist/lib/core/evaluationProviders.js

@@ -1,4 +1,11 @@
 import { modelConfig } from "./modelConfiguration.js";
+const PERFORMANCE_THRESHOLDS = {
+    EXCELLENT_SUCCESS_RATE: 0.95,
+    EXCELLENT_RESPONSE_TIME_MS: 2000,
+    GOOD_SUCCESS_RATE: 0.9,
+    FAIR_SUCCESS_RATE: 0.8,
+};
+const providerMetrics = new Map();
 /**
  * Convert new configuration format to legacy format for backwards compatibility
  */
@@ -101,3 +108,156 @@ export function getBestAvailableProvider(preferCheap = true) {
     const sortedProviders = sortProvidersByPreference(availableProviders, preferCheap);
     return sortedProviders[0];
 }
+/**
+ Record actual provider performance for optimization
+ */
+export function recordProviderPerformanceFromMetrics(providerName, metrics) {
+    const existing = providerMetrics.get(providerName) || {
+        responseTime: [],
+        successRate: 0,
+        tokenThroughput: 0,
+        costEfficiency: 0,
+        lastUpdated: new Date(),
+        sampleCount: 0,
+    };
+    // Keep rolling window of last 50 response times
+    existing.responseTime.push(metrics.responseTime);
+    if (existing.responseTime.length > 50) {
+        existing.responseTime.shift();
+    }
+    // Update success rate
+    const totalSamples = existing.sampleCount + 1;
+    existing.successRate =
+        (existing.successRate * existing.sampleCount + (metrics.success ? 1 : 0)) /
+            totalSamples;
+    // Update throughput (tokens per second)
+    if (metrics.responseTime > 0) {
+        const tokensPerSecond = metrics.tokensGenerated / (metrics.responseTime / 1000);
+        existing.tokenThroughput =
+            (existing.tokenThroughput * existing.sampleCount + tokensPerSecond) /
+                totalSamples;
+    }
+    // If responseTime is 0, skip updating tokenThroughput for this sample
+    // but still update other metrics
+    // Update cost efficiency (tokens per dollar)
+    if (metrics.cost > 0) {
+        const tokensPerDollar = metrics.tokensGenerated / metrics.cost;
+        existing.costEfficiency =
+            (existing.costEfficiency * existing.sampleCount + tokensPerDollar) /
+                totalSamples;
+    }
+    existing.sampleCount = totalSamples;
+    existing.lastUpdated = new Date();
+    providerMetrics.set(providerName, existing);
+}
+/**
+ * Get performance-optimized provider based on real metrics
+ */
+export function getPerformanceOptimizedProvider(priority = "speed") {
+    const availableProviders = getAvailableProviders();
+    if (availableProviders.length === 0) {
+        return null;
+    }
+    // Score providers based on real performance data
+    const scoredProviders = availableProviders.map((provider) => {
+        const metrics = providerMetrics.get(provider.provider);
+        if (!metrics || metrics.sampleCount < 3) {
+            // Fall back to static performance ratings for providers without data
+            return {
+                provider,
+                score: getStaticPerformanceScore(provider, priority),
+                metrics: null,
+            };
+        }
+        let score = 0;
+        switch (priority) {
+            case "speed": {
+                const avgResponseTime = metrics.responseTime.reduce((a, b) => a + b, 0) /
+                    metrics.responseTime.length;
+                score =
+                    metrics.tokenThroughput * 0.6 +
+                        (5000 / Math.max(avgResponseTime, 100)) * 0.4;
+                break;
+            }
+            case "cost": {
+                score = metrics.costEfficiency * 0.7 + metrics.successRate * 0.3;
+                break;
+            }
+            case "reliability": {
+                score = metrics.successRate * 0.8 + (metrics.sampleCount / 100) * 0.2;
+                break;
+            }
+        }
+        return { provider, score, metrics };
+    });
+    // Sort by score and return best
+    scoredProviders.sort((a, b) => b.score - a.score);
+    return scoredProviders[0].provider;
+}
+/**
+ * Helper function for providers without performance data
+ */
+function getStaticPerformanceScore(provider, priority) {
+    switch (priority) {
+        case "speed": {
+            const speedScore = provider.performance?.speed || 1;
+            return speedScore;
+        }
+        case "cost": {
+            const costScore = provider.performance?.cost || 1;
+            return costScore;
+        }
+        case "reliability": {
+            const qualityScore = provider.performance?.quality || 1;
+            return qualityScore;
+        }
+        default: {
+            throw new Error(`Invalid priority: "${priority}". Must be one of: speed, cost, reliability`);
+        }
+    }
+}
+export function getProviderPerformanceAnalytics() {
+    const analytics = {};
+    for (const [providerName, metrics] of providerMetrics.entries()) {
+        if (metrics.sampleCount === 0) {
+            continue;
+        }
+        const avgResponseTime = metrics.responseTime.reduce((a, b) => a + b, 0) /
+            metrics.responseTime.length;
+        let recommendation = "";
+        if (metrics.successRate > PERFORMANCE_THRESHOLDS.EXCELLENT_SUCCESS_RATE &&
+            avgResponseTime < PERFORMANCE_THRESHOLDS.EXCELLENT_RESPONSE_TIME_MS) {
+            recommendation = "Excellent - Recommended for production";
+        }
+        else if (metrics.successRate > PERFORMANCE_THRESHOLDS.GOOD_SUCCESS_RATE) {
+            recommendation = "Good - Suitable for most tasks";
+        }
+        else if (metrics.successRate > PERFORMANCE_THRESHOLDS.FAIR_SUCCESS_RATE) {
+            recommendation = "Fair - Monitor closely";
+        }
+        else {
+            recommendation = "Poor - Consider alternative providers";
+        }
+        analytics[providerName] = {
+            avgResponseTime,
+            successRate: metrics.successRate,
+            tokenThroughput: metrics.tokenThroughput,
+            costEfficiency: metrics.costEfficiency,
+            recommendation,
+            sampleCount: metrics.sampleCount,
+        };
+    }
+    return analytics;
+}
+/**
+ * Reset performance metrics for a provider or all providers.
+ * @param providerName - (Optional) The name of the provider to reset. If omitted, resets all providers.
+ */
+export function resetProviderMetrics(providerName) {
+    if (providerName) {
+        providerMetrics.delete(providerName);
+    }
+    else {
+        providerMetrics.clear();
+    }
+}

package/dist/lib/index.d.ts

@@ -18,6 +18,9 @@ export { getBestProvider, getAvailableProviders, isValidProvider, } from "./util
 export { NeuroLink } from "./neurolink.js";
 export type { ProviderStatus, MCPStatus } from "./neurolink.js";
 export type { MCPServerInfo } from "./types/mcpTypes.js";
+export type { NeuroLinkMiddleware, MiddlewareContext, MiddlewareFactoryOptions, } from "./middleware/types.js";
+export { MiddlewareRegistry, MiddlewareFactory } from "./middleware/index.js";
+export { createAnalyticsMiddleware } from "./middleware/builtin/analytics.js";
 export declare const VERSION = "1.0.0";
 /**
  * Quick start factory function

package/dist/lib/index.js

@@ -16,6 +16,8 @@ export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, }
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 // Main NeuroLink wrapper class and diagnostic types
 export { NeuroLink } from "./neurolink.js";
+export { MiddlewareRegistry, MiddlewareFactory } from "./middleware/index.js";
+export { createAnalyticsMiddleware } from "./middleware/builtin/analytics.js";
 // Version
 export const VERSION = "1.0.0";
 /**

package/dist/lib/middleware/builtin/analytics.d.ts

@@ -0,0 +1,16 @@
+import type { NeuroLinkMiddleware } from "../types.js";
+/**
+ * Create analytics middleware for tracking AI model usage
+ * Collects metrics on token usage, response times, and model performance
+ */
+export declare function createAnalyticsMiddleware(): NeuroLinkMiddleware;
+/**
+ * Get collected metrics from analytics middleware
+ * Note: This is a utility function for accessing metrics
+ */
+export declare function getAnalyticsMetrics(): Map<string, Record<string, unknown>>;
+/**
+ * Clear collected metrics from analytics middleware
+ * Note: This is a utility function for clearing metrics
+ */
+export declare function clearAnalyticsMetrics(): void;

package/dist/lib/middleware/builtin/analytics.js

@@ -0,0 +1,130 @@
+import { logger } from "../../utils/logger.js";
+/**
+ * Create analytics middleware for tracking AI model usage
+ * Collects metrics on token usage, response times, and model performance
+ */
+export function createAnalyticsMiddleware() {
+    const requestMetrics = new Map();
+    const metadata = {
+        id: "analytics",
+        name: "Analytics Tracking",
+        description: "Tracks token usage, response times, and model performance metrics",
+        priority: 100, // High priority to ensure analytics are captured
+        defaultEnabled: true,
+    };
+    const middleware = {
+        wrapGenerate: async ({ doGenerate, params }) => {
+            const requestId = `analytics-${Date.now()}`;
+            const startTime = Date.now();
+            logger.debug(`[AnalyticsMiddleware] Starting request tracking`, {
+                requestId,
+                hasPrompt: !!params.prompt,
+            });
+            try {
+                // Execute the generation
+                const result = await doGenerate();
+                // Calculate metrics
+                const responseTime = Date.now() - startTime;
+                const analytics = {
+                    requestId,
+                    responseTime,
+                    timestamp: new Date().toISOString(),
+                    usage: {
+                        inputTokens: result.usage?.promptTokens || 0,
+                        outputTokens: result.usage?.completionTokens || 0,
+                        totalTokens: (result.usage?.promptTokens || 0) +
+                            (result.usage?.completionTokens || 0),
+                    },
+                };
+                // Store metrics for potential retrieval
+                requestMetrics.set(requestId, analytics);
+                logger.debug(`[AnalyticsMiddleware] Request completed`, analytics);
+                // Add analytics to the result
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const updatedResult = { ...result };
+                if (!updatedResult.experimental_providerMetadata) {
+                    updatedResult.experimental_providerMetadata = {};
+                }
+                if (!updatedResult.experimental_providerMetadata.neurolink) {
+                    updatedResult.experimental_providerMetadata.neurolink = {};
+                }
+                updatedResult.experimental_providerMetadata.neurolink.analytics =
+                    analytics;
+                return updatedResult;
+            }
+            catch (error) {
+                const responseTime = Date.now() - startTime;
+                logger.error(`[AnalyticsMiddleware] Request failed`, {
+                    requestId,
+                    responseTime,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw error;
+            }
+        },
+        wrapStream: async ({ doStream, params }) => {
+            const requestId = `analytics-stream-${Date.now()}`;
+            const startTime = Date.now();
+            logger.debug(`[AnalyticsMiddleware] Starting stream tracking`, {
+                requestId,
+                hasPrompt: !!params.prompt,
+            });
+            try {
+                const result = await doStream();
+                const streamAnalytics = {
+                    requestId,
+                    startTime,
+                    timestamp: new Date().toISOString(),
+                    streamingMode: true,
+                };
+                requestMetrics.set(requestId, streamAnalytics);
+                // The 'result' is a stream, so we can't directly modify it.
+                // Analytics for streams are typically handled after the stream is consumed.
+                // For this middleware, we'll log the start and rely on other mechanisms
+                // to capture the end-to-end stream metrics if needed.
+                // We will pass a new property in the `rawResponse`
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const updatedResult = { ...result };
+                if (!updatedResult.rawResponse) {
+                    updatedResult.rawResponse = {};
+                }
+                if (!updatedResult.rawResponse.neurolink) {
+                    updatedResult.rawResponse.neurolink = {};
+                }
+                updatedResult.rawResponse.neurolink.analytics = streamAnalytics;
+                return updatedResult;
+            }
+            catch (error) {
+                const responseTime = Date.now() - startTime;
+                logger.error(`[AnalyticsMiddleware] Stream failed`, {
+                    requestId,
+                    responseTime,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw error;
+            }
+        },
+    };
+    // Return the NeuroLinkMiddleware with metadata
+    return {
+        ...middleware,
+        metadata,
+    };
+}
+/**
+ * Get collected metrics from analytics middleware
+ * Note: This is a utility function for accessing metrics
+ */
+export function getAnalyticsMetrics() {
+    // This would need to be implemented with a global registry
+    // For now, return empty map
+    return new Map();
+}
+/**
+ * Clear collected metrics from analytics middleware
+ * Note: This is a utility function for clearing metrics
+ */
+export function clearAnalyticsMetrics() {
+    // This would need to be implemented with a global registry
+    // For now, do nothing
+}

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

@@ -0,0 +1,54 @@
+import type { LanguageModelV1 } from "ai";
+import type { MiddlewareContext, MiddlewareConfig, MiddlewareFactoryOptions, MiddlewareChainStats } from "./types.js";
+/**
+ * Middleware factory for creating and applying middleware chains
+ */
+export declare class MiddlewareFactory {
+    /**
+     * Apply middleware to a language model
+     */
+    static applyMiddleware(model: LanguageModelV1, context: MiddlewareContext, options?: MiddlewareFactoryOptions): LanguageModelV1;
+    /**
+     * Build middleware configuration from factory options
+     */
+    private static buildMiddlewareConfig;
+    /**
+     * Get preset configuration
+     */
+    private static getPresetConfig;
+    /**
+     * Get built-in preset configurations
+     */
+    private static getBuiltInPresets;
+    /**
+     * Create middleware context from provider and options
+     */
+    static createContext(provider: string, model: string, options?: Record<string, unknown>, session?: {
+        sessionId?: string;
+        userId?: string;
+    }): MiddlewareContext;
+    /**
+     * Validate middleware configuration
+     */
+    static validateConfig(config: Record<string, MiddlewareConfig>): {
+        isValid: boolean;
+        errors: string[];
+        warnings: string[];
+    };
+    /**
+     * Get available presets
+     */
+    static getAvailablePresets(): Array<{
+        name: string;
+        description: string;
+        middleware: string[];
+    }>;
+    /**
+     * Get middleware chain statistics
+     */
+    static 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>;
+}

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