@juspay/neurolink 7.28.1 → 7.29.1

package/dist/lib/providers/googleVertex.js

@@ -105,10 +105,10 @@ const createVertexSettings = async () => {
             // Silent error handling for runtime credentials file creation
         }
     }
-    // 🎯 OPTION 1: Check for principal account authentication (existing flow with debug logs)
+    // 🎯 OPTION 1: Check for principal account authentication (Accept any valid GOOGLE_APPLICATION_CREDENTIALS file (service account OR ADC))
     if (process.env.GOOGLE_APPLICATION_CREDENTIALS) {
         const credentialsPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
-        // 🚨 CRITICAL FIX: Check if the credentials file actually exists
+        // Check if the credentials file exists
         let fileExists = false;
         try {
             fileExists = fs.existsSync(credentialsPath);
@@ -1115,8 +1115,9 @@ export class GoogleVertexProvider extends BaseProvider {
                 method: authValidation.method,
                 issues: authValidation.issues,
                 solutions: [
-                    "Option 1: Set GOOGLE_APPLICATION_CREDENTIALS to valid service account file",
+                    "Option 1: Set GOOGLE_APPLICATION_CREDENTIALS to valid service account OR ADC file",
                     "Option 2: Set individual env vars: GOOGLE_AUTH_CLIENT_EMAIL, GOOGLE_AUTH_PRIVATE_KEY",
+                    "Option 3: Use gcloud auth application-default login for ADC",
                     "Documentation: https://cloud.google.com/docs/authentication/provide-credentials-adc",
                 ],
             });
@@ -1268,8 +1269,16 @@ export class GoogleVertexProvider extends BaseProvider {
                             result.method = "service_account_file";
                             return result;
                         }
+                        else if (credentials.client_id &&
+                            credentials.client_secret &&
+                            credentials.refresh_token &&
+                            credentials.type !== "service_account") {
+                            result.isValid = true;
+                            result.method = "application_default_credentials";
+                            return result;
+                        }
                         else {
-                            result.issues.push("Service account file missing required fields");
+                            result.issues.push("Credentials file missing required fields (not service account or ADC format)");
                         }
                     }
                     else {

package/dist/middleware/builtin/analytics.js

@@ -78,20 +78,19 @@ export function createAnalyticsMiddleware() {
                     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;
+                // Ensure the result includes all required properties
+                const updatedResult = {
+                    ...result,
+                    stream: result.stream || new ReadableStream(),
+                    rawCall: result.rawCall || { rawPrompt: null, rawSettings: {} },
+                    rawResponse: {
+                        ...(result.rawResponse || {}),
+                        neurolink: {
+                            ...(result.rawResponse?.neurolink ?? {}),
+                            analytics: streamAnalytics,
+                        },
+                    },
+                };
                 return updatedResult;
             }
             catch (error) {

package/dist/middleware/builtin/guardrails.d.ts

@@ -0,0 +1,20 @@
+import type { LanguageModelV1 } from "ai";
+import type { NeuroLinkMiddleware } from "../types.js";
+/**
+ * Configuration for the Guardrails middleware.
+ */
+export interface GuardrailsMiddlewareConfig {
+    badWords?: {
+        enabled?: boolean;
+        list?: string[];
+    };
+    modelFilter?: {
+        enabled?: boolean;
+        filterModel?: LanguageModelV1;
+    };
+}
+/**
+ * Create Guardrails AI middleware for content filtering and policy enforcement.
+ * @param config - Configuration for the guardrails middleware.
+ */
+export declare function createGuardrailsMiddleware(config?: GuardrailsMiddlewareConfig): NeuroLinkMiddleware;

package/dist/middleware/builtin/guardrails.js

@@ -0,0 +1,87 @@
+import { generateText } from "ai";
+import { logger } from "../../utils/logger.js";
+/**
+ * Create Guardrails AI middleware for content filtering and policy enforcement.
+ * @param config - Configuration for the guardrails middleware.
+ */
+export function createGuardrailsMiddleware(config = {}) {
+    const metadata = {
+        id: "guardrails",
+        name: "Guardrails AI",
+        description: "Provides content filtering and policy enforcement using custom rules and AI models.",
+        priority: 90,
+        defaultEnabled: true,
+    };
+    const middleware = {
+        wrapGenerate: async ({ doGenerate, params }) => {
+            logger.debug(`[GuardrailsMiddleware] Applying to generate call.`, {
+                badWordsEnabled: !!config.badWords?.enabled,
+                modelFilterEnabled: !!config.modelFilter?.enabled,
+            });
+            let result = await doGenerate();
+            // 1. Bad Word Filtering
+            if (config.badWords?.enabled && config.badWords.list) {
+                let filteredText = result.text;
+                for (const term of config.badWords.list) {
+                    const regex = new RegExp(term, "gi");
+                    filteredText = filteredText?.replace(regex, "*".repeat(term.length));
+                }
+                if (result.text !== filteredText) {
+                    logger.debug(`[GuardrailsMiddleware] Redacted bad words from text.`);
+                    result = { ...result, text: filteredText ?? "" };
+                }
+            }
+            // 2. Model-based Filtering
+            if (config.modelFilter?.enabled && config.modelFilter.filterModel) {
+                logger.debug(`[GuardrailsMiddleware] Invoking model-based filter.`);
+                try {
+                    const filterPrompt = `Is the following text safe? Respond with only "safe" or "unsafe".\n\nText: "${result.text}"`;
+                    const { text: filterResponse } = await generateText({
+                        model: config.modelFilter.filterModel, // Cast as any to satisfy type, will be resolved in integration
+                        prompt: filterPrompt,
+                    });
+                    if (filterResponse.toLowerCase().trim() === "unsafe") {
+                        logger.warn(`[GuardrailsMiddleware] Model-based filter flagged content as unsafe.`);
+                        result = { ...result, text: "<REDACTED BY AI GUARDRAIL>" };
+                    }
+                }
+                catch (error) {
+                    logger.error(`[GuardrailsMiddleware] Model-based filter failed.`, {
+                        error,
+                    });
+                }
+            }
+            return result;
+        },
+        wrapStream: async ({ doStream, params }) => {
+            logger.debug(`[GuardrailsMiddleware] Applying to stream call.`, {
+                badWordsEnabled: !!config.badWords?.enabled,
+            });
+            const { stream, ...rest } = await doStream();
+            // Note: Model-based filtering is not applied to streams in this version
+            // as it requires the full text for analysis.
+            const transformStream = new TransformStream({
+                transform(chunk, controller) {
+                    let filteredChunk = chunk;
+                    if (config.badWords?.enabled && config.badWords.list) {
+                        for (const term of config.badWords.list) {
+                            const regex = new RegExp(term, "gi");
+                            if (typeof filteredChunk === "string") {
+                                filteredChunk = filteredChunk.replace(regex, "*".repeat(term.length));
+                            }
+                        }
+                    }
+                    controller.enqueue(filteredChunk);
+                },
+            });
+            return {
+                stream: stream.pipeThrough(transformStream),
+                ...rest,
+            };
+        },
+    };
+    return {
+        ...middleware,
+        metadata,
+    };
+}

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;