@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/middleware/builtin/lifecycle.js

@@ -1,168 +0,0 @@
-/**
- * Lifecycle Middleware
- *
- * Provides onFinish, onError, and onChunk callbacks for observing
- * generation and streaming lifecycle events.
- *
- * This middleware is automatically enabled when lifecycle callbacks
- * (onFinish, onError, onChunk) are passed in GenerateOptions or StreamOptions.
- */
-import { logger } from "../../utils/logger.js";
-import { isRecoverableError } from "../../utils/errorHandling.js";
-export function createLifecycleMiddleware(config = {}) {
-    const metadata = {
-        id: "lifecycle",
-        name: "Lifecycle Callbacks",
-        description: "Provides onFinish, onError, and onChunk callbacks for generation and streaming lifecycle events",
-        priority: 110,
-        defaultEnabled: false,
-    };
-    const middleware = {
-        specificationVersion: "v3",
-        wrapGenerate: async ({ doGenerate, }) => {
-            const startTime = Date.now();
-            try {
-                const result = await doGenerate();
-                if (config.onFinish) {
-                    try {
-                        const content = result.content
-                            ?.map((c) => c.type === "text" ? c.text : "")
-                            .join("") ?? "";
-                        const callbackResult = config.onFinish({
-                            text: content,
-                            usage: result.usage
-                                ? {
-                                    promptTokens: result.usage.inputTokens?.total ?? 0,
-                                    completionTokens: result.usage.outputTokens?.total ?? 0,
-                                }
-                                : undefined,
-                            duration: Date.now() - startTime,
-                            finishReason: String(result.finishReason ?? ""),
-                        });
-                        Promise.resolve(callbackResult).catch((e) => {
-                            logger.warn("[LifecycleMiddleware] onFinish callback error:", e);
-                        });
-                    }
-                    catch (e) {
-                        logger.warn("[LifecycleMiddleware] onFinish callback error:", e);
-                    }
-                }
-                return result;
-            }
-            catch (error) {
-                if (config.onError) {
-                    const err = error instanceof Error ? error : new Error(String(error));
-                    try {
-                        const callbackResult = config.onError({
-                            error: err,
-                            duration: Date.now() - startTime,
-                            recoverable: isRecoverableError(err),
-                        });
-                        Promise.resolve(callbackResult).catch((e) => {
-                            logger.warn("[LifecycleMiddleware] onError callback error:", e);
-                        });
-                    }
-                    catch (e) {
-                        logger.warn("[LifecycleMiddleware] onError callback error:", e);
-                    }
-                }
-                throw error;
-            }
-        },
-        wrapStream: async ({ doStream, }) => {
-            const startTime = Date.now();
-            try {
-                const result = await doStream();
-                if (!config.onChunk && !config.onFinish && !config.onError) {
-                    return result;
-                }
-                let sequenceNumber = 0;
-                let accumulatedText = "";
-                const transformStream = new TransformStream({
-                    transform(chunk, controller) {
-                        try {
-                            if (chunk.type === "text-delta") {
-                                accumulatedText += chunk.textDelta;
-                            }
-                            if (config.onChunk && chunk.type) {
-                                try {
-                                    const callbackResult = config.onChunk({
-                                        type: chunk.type,
-                                        textDelta: chunk.type === "text-delta" ? chunk.textDelta : undefined,
-                                        sequenceNumber: sequenceNumber++,
-                                    });
-                                    Promise.resolve(callbackResult).catch((e) => {
-                                        logger.warn("[LifecycleMiddleware] onChunk callback error:", e);
-                                    });
-                                }
-                                catch (e) {
-                                    logger.warn("[LifecycleMiddleware] onChunk callback error:", e);
-                                }
-                            }
-                            controller.enqueue(chunk);
-                        }
-                        catch (error) {
-                            if (config.onError) {
-                                const err = error instanceof Error ? error : new Error(String(error));
-                                try {
-                                    const callbackResult = config.onError({
-                                        error: err,
-                                        duration: Date.now() - startTime,
-                                        recoverable: isRecoverableError(err),
-                                    });
-                                    Promise.resolve(callbackResult).catch((e) => {
-                                        logger.warn("[LifecycleMiddleware] onError callback error:", e);
-                                    });
-                                }
-                                catch (e) {
-                                    logger.warn("[LifecycleMiddleware] onError callback error:", e);
-                                }
-                            }
-                            throw error;
-                        }
-                    },
-                    flush() {
-                        if (config.onFinish) {
-                            try {
-                                const callbackResult = config.onFinish({
-                                    text: accumulatedText,
-                                    duration: Date.now() - startTime,
-                                });
-                                Promise.resolve(callbackResult).catch((e) => {
-                                    logger.warn("[LifecycleMiddleware] onFinish callback error:", e);
-                                });
-                            }
-                            catch (e) {
-                                logger.warn("[LifecycleMiddleware] onFinish callback error:", e);
-                            }
-                        }
-                    },
-                });
-                return {
-                    ...result,
-                    stream: result.stream.pipeThrough(transformStream),
-                };
-            }
-            catch (error) {
-                if (config.onError) {
-                    const err = error instanceof Error ? error : new Error(String(error));
-                    try {
-                        const callbackResult = config.onError({
-                            error: err,
-                            duration: Date.now() - startTime,
-                            recoverable: isRecoverableError(err),
-                        });
-                        Promise.resolve(callbackResult).catch((e) => {
-                            logger.warn("[LifecycleMiddleware] onError callback error:", e);
-                        });
-                    }
-                    catch (e) {
-                        logger.warn("[LifecycleMiddleware] onError callback error:", e);
-                    }
-                }
-                throw error;
-            }
-        },
-    };
-    return { ...middleware, metadata };
-}

package/dist/client/middleware/factory.js

@@ -1,327 +0,0 @@
-import { wrapLanguageModel } from "ai";
-import { MiddlewareRegistry } from "./registry.js";
-import { createAnalyticsMiddleware } from "./builtin/analytics.js";
-import { createGuardrailsMiddleware } from "./builtin/guardrails.js";
-import { createAutoEvaluationMiddleware } from "./builtin/autoEvaluation.js";
-import { createLifecycleMiddleware } from "./builtin/lifecycle.js";
-import { logger } from "../utils/logger.js";
-/**
- * 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,
-            autoEvaluation: createAutoEvaluationMiddleware,
-            lifecycle: createLifecycleMiddleware,
-        };
-        // 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
-        logger.debug("Initializing MiddlewareFactory", { options });
-        if (options.middleware) {
-            logger.debug(`Registering custom 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;
-                logger.debug(`Registering built-in middleware '${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
-     */
-    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(mergedOptions);
-            // Re-register middleware with the correct configuration for this call
-            for (const [id, config] of Object.entries(middlewareConfig)) {
-                logger.debug(`Configuring middleware '${id}'`, { config });
-                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 = this.registry.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
-            // wrapLanguageModel expects LanguageModelV3, narrow from LanguageModel union
-            const modelV3 = model;
-            const wrappedModel = wrapLanguageModel({
-                model: modelV3,
-                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;
-        }
-    }
-    getCreator(id) {
-        const builtInMiddlewareCreators = {
-            analytics: createAnalyticsMiddleware,
-            guardrails: createGuardrailsMiddleware,
-            autoEvaluation: createAutoEvaluationMiddleware,
-            lifecycle: createLifecycleMiddleware,
-        };
-        logger.debug("Getting creator for middleware ID:", id);
-        return builtInMiddlewareCreators[id];
-    }
-    /**
-     * Build middleware configuration from factory options
-     */
-    buildMiddlewareConfig(options) {
-        const config = {};
-        const allMiddleware = this.registry.list();
-        // Initialize all middleware as disabled. Configuration will enable them.
-        for (const middleware of allMiddleware) {
-            config[middleware.metadata.id] = {
-                enabled: false,
-                config: {},
-            };
-        }
-        // 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) {
-                for (const [middlewareId, middlewareConfig] of Object.entries(presetConfig)) {
-                    if (config[middlewareId]) {
-                        config[middlewareId] = {
-                            ...config[middlewareId],
-                            ...middlewareConfig,
-                        };
-                    }
-                }
-            }
-        }
-        // 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
-     */
-    getPresetConfig(presetName) {
-        const preset = this.presets.get(presetName);
-        return preset ? preset.config : null;
-    }
-    /**
-     * Create middleware context from provider and options
-     */
-    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
-     */
-    validateConfig(config) {
-        const errors = [];
-        const warnings = [];
-        for (const [middlewareId, middlewareConfig] of Object.entries(config)) {
-            // Check if middleware is registered
-            if (!this.registry.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
-     */
-    getAvailablePresets() {
-        return Array.from(this.presets.values()).map((preset) => ({
-            name: preset.name,
-            description: preset.description,
-            middleware: Object.keys(preset.config),
-        }));
-    }
-    /**
-     * Get middleware chain statistics
-     */
-    getChainStats(context, config) {
-        const chain = this.registry.buildChain(context, config);
-        const stats = this.registry.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
-     */
-    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);
-        };
-    }
-}