@juspay/neurolink 7.28.0 → 7.29.0

package/dist/cli/utils/ollamaUtils.js

@@ -0,0 +1,161 @@
+import { spawnSync, spawn, } from "child_process";
+import chalk from "chalk";
+import ora from "ora";
+import { logger } from "../../lib/utils/logger.js";
+/**
+ * Shared Ollama utilities for CLI commands
+ */
+export class OllamaUtils {
+    /**
+     * Secure wrapper around spawnSync to prevent command injection.
+     */
+    static safeSpawn(command, args, options = {}) {
+        const defaultOptions = {
+            ...options,
+            encoding: "utf8", // Always enforce utf8 encoding
+        };
+        return spawnSync(command, args, defaultOptions);
+    }
+    /**
+     * Wait for Ollama service to become ready with exponential backoff
+     */
+    static async waitForOllamaReady(maxAttempts = 30, initialDelay = 500) {
+        let delay = initialDelay;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                // Try both command line and HTTP API checks
+                const cmdCheck = this.safeSpawn("ollama", ["list"]);
+                if (!cmdCheck.error && cmdCheck.status === 0) {
+                    // Stronger HTTP API probe with response validation
+                    try {
+                        const apiCheck = this.safeSpawn("curl", [
+                            "-s",
+                            "--max-time",
+                            "3",
+                            "--fail", // Fail on HTTP error codes
+                            "-w",
+                            "%{http_code}",
+                            "http://localhost:11434/api/tags",
+                        ]);
+                        if (!apiCheck.error &&
+                            apiCheck.status === 0 &&
+                            apiCheck.stdout.trim()) {
+                            // Validate that we get a proper HTTP 200 response and JSON structure
+                            const output = apiCheck.stdout.trim();
+                            const httpCodeMatch = output.match(/(\d{3})$/);
+                            if (httpCodeMatch && httpCodeMatch[1] === "200") {
+                                // Try to parse the JSON response (excluding HTTP code)
+                                const jsonResponse = output.replace(/\d{3}$/, "");
+                                try {
+                                    const parsedResponse = JSON.parse(jsonResponse);
+                                    // Verify it has the expected structure
+                                    if (parsedResponse && typeof parsedResponse === "object") {
+                                        return true; // Strong verification passed
+                                    }
+                                }
+                                catch {
+                                    // JSON parsing failed, but HTTP 200 is good enough
+                                    return true;
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // If curl fails, fall back to command check only
+                        return true;
+                    }
+                    return true; // Command check passed
+                }
+            }
+            catch {
+                // Service not ready yet
+            }
+            // Wait before next attempt with exponential backoff (max 4 seconds)
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            delay = Math.min(delay * 1.5, 4000);
+        }
+        return false; // Timeout reached
+    }
+    /**
+     * Check if Ollama service is already running
+     */
+    static isOllamaRunning() {
+        try {
+            const check = this.safeSpawn("ollama", ["list"]);
+            return !check.error && check.status === 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Unified Ollama start logic that works across platforms
+     */
+    static async startOllamaService() {
+        logger.always(chalk.blue("Starting Ollama service..."));
+        // Check if already running
+        if (this.isOllamaRunning()) {
+            logger.always(chalk.yellow("Ollama service is already running!"));
+            return;
+        }
+        try {
+            if (process.platform === "darwin") {
+                logger.always(chalk.gray("Starting Ollama on macOS..."));
+                try {
+                    this.safeSpawn("open", ["-a", "Ollama"]);
+                    logger.always(chalk.green("✅ Ollama app started"));
+                }
+                catch {
+                    const child = spawn("ollama", ["serve"], {
+                        stdio: "ignore",
+                        detached: true,
+                    });
+                    child.unref();
+                    logger.always(chalk.green("✅ Ollama service started"));
+                }
+            }
+            else if (process.platform === "linux") {
+                logger.always(chalk.gray("Starting Ollama service on Linux..."));
+                try {
+                    this.safeSpawn("systemctl", ["start", "ollama"]);
+                    logger.always(chalk.green("✅ Ollama service started"));
+                }
+                catch {
+                    const child = spawn("ollama", ["serve"], {
+                        stdio: "ignore",
+                        detached: true,
+                    });
+                    child.unref();
+                    logger.always(chalk.green("✅ Ollama service started"));
+                }
+            }
+            else {
+                logger.always(chalk.gray("Starting Ollama on Windows..."));
+                // Security Note: Windows shell=true usage is intentional here for 'start' command.
+                // Arguments are controlled internally (no user input) and safeSpawn validates command names.
+                // This is safer than alternative Windows process creation methods for this specific use case.
+                this.safeSpawn("start", ["ollama", "serve"], {
+                    stdio: "ignore",
+                    shell: true,
+                });
+                logger.always(chalk.green("✅ Ollama service started"));
+            }
+            // Wait for service to become ready with readiness probe
+            const readinessSpinner = ora("Waiting for Ollama service to be ready...").start();
+            const isReady = await this.waitForOllamaReady();
+            if (isReady) {
+                readinessSpinner.succeed("Ollama service is ready!");
+            }
+            else {
+                readinessSpinner.warn("Ollama service may still be starting. Try 'ollama list' to check status.");
+            }
+        }
+        catch (error) {
+            logger.error(chalk.red("Failed to start Ollama service"));
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(chalk.red("Error:", errorMessage));
+            logger.always(chalk.blue("\nTry starting Ollama manually or check installation"));
+            process.exit(1);
+        }
+    }
+}

package/dist/core/baseProvider.js

@@ -413,13 +413,15 @@ export class BaseProvider {
             return baseModel;
         }
         try {
+            // Create a new factory instance with the specified options
+            const factory = new MiddlewareFactory(middlewareOptions);
             // Create middleware context
-            const context = MiddlewareFactory.createContext(this.providerName, this.modelName, options, {
+            const context = factory.createContext(this.providerName, this.modelName, options, {
                 sessionId: this.sessionId,
                 userId: this.userId,
             });
             // Apply middleware to the model
-            const wrappedModel = MiddlewareFactory.applyMiddleware(baseModel, context, middlewareOptions);
+            const wrappedModel = factory.applyMiddleware(baseModel, context, middlewareOptions);
             logger.debug(`Applied middleware to ${this.providerName} model`, {
                 provider: this.providerName,
                 model: this.modelName,

package/dist/index.d.ts

@@ -18,9 +18,8 @@ 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 type { NeuroLinkMiddleware, MiddlewareContext, MiddlewareFactoryOptions, MiddlewarePreset, MiddlewareConfig, } from "./middleware/types.js";
+export { MiddlewareFactory } from "./middleware/factory.js";
 export declare const VERSION = "1.0.0";
 /**
  * Quick start factory function

package/dist/index.js

@@ -16,8 +16,7 @@ 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";
+export { MiddlewareFactory } from "./middleware/factory.js";
 // Version
 export const VERSION = "1.0.0";
 /**

package/dist/lib/core/baseProvider.js

@@ -413,13 +413,15 @@ export class BaseProvider {
             return baseModel;
         }
         try {
+            // Create a new factory instance with the specified options
+            const factory = new MiddlewareFactory(middlewareOptions);
             // Create middleware context
-            const context = MiddlewareFactory.createContext(this.providerName, this.modelName, options, {
+            const context = factory.createContext(this.providerName, this.modelName, options, {
                 sessionId: this.sessionId,
                 userId: this.userId,
             });
             // Apply middleware to the model
-            const wrappedModel = MiddlewareFactory.applyMiddleware(baseModel, context, middlewareOptions);
+            const wrappedModel = factory.applyMiddleware(baseModel, context, middlewareOptions);
             logger.debug(`Applied middleware to ${this.providerName} model`, {
                 provider: this.providerName,
                 model: this.modelName,

package/dist/lib/core/dynamicModels.d.ts

@@ -20,8 +20,8 @@ declare const ModelConfigSchema: z.ZodObject<{
     contextWindow: z.ZodNumber;
     releaseDate: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    capabilities: string[];
     id: string;
+    capabilities: string[];
     displayName: string;
     deprecated: boolean;
     pricing: {
@@ -31,8 +31,8 @@ declare const ModelConfigSchema: z.ZodObject<{
     contextWindow: number;
     releaseDate: string;
 }, {
-    capabilities: string[];
     id: string;
+    capabilities: string[];
     displayName: string;
     deprecated: boolean;
     pricing: {
@@ -63,8 +63,8 @@ declare const ModelRegistrySchema: z.ZodObject<{
         contextWindow: z.ZodNumber;
         releaseDate: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        capabilities: string[];
         id: string;
+        capabilities: string[];
         displayName: string;
         deprecated: boolean;
         pricing: {
@@ -74,8 +74,8 @@ declare const ModelRegistrySchema: z.ZodObject<{
         contextWindow: number;
         releaseDate: string;
     }, {
-        capabilities: string[];
         id: string;
+        capabilities: string[];
         displayName: string;
         deprecated: boolean;
         pricing: {
@@ -89,8 +89,8 @@ declare const ModelRegistrySchema: z.ZodObject<{
     defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     models: Record<string, Record<string, {
-        capabilities: string[];
         id: string;
+        capabilities: string[];
         displayName: string;
         deprecated: boolean;
         pricing: {
@@ -106,8 +106,8 @@ declare const ModelRegistrySchema: z.ZodObject<{
     aliases?: Record<string, string> | undefined;
 }, {
     models: Record<string, Record<string, {
-        capabilities: string[];
         id: string;
+        capabilities: string[];
         displayName: string;
         deprecated: boolean;
         pricing: {

package/dist/lib/index.d.ts

@@ -18,9 +18,8 @@ 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 type { NeuroLinkMiddleware, MiddlewareContext, MiddlewareFactoryOptions, MiddlewarePreset, MiddlewareConfig, } from "./middleware/types.js";
+export { MiddlewareFactory } from "./middleware/factory.js";
 export declare const VERSION = "1.0.0";
 /**
  * Quick start factory function

package/dist/lib/index.js

@@ -16,8 +16,7 @@ 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";
+export { MiddlewareFactory } from "./middleware/factory.js";
 // Version
 export const VERSION = "1.0.0";
 /**

package/dist/lib/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/lib/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/lib/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/lib/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>;
 }