@juspay/neurolink 7.48.0 → 7.49.0

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

@@ -1,22 +1,15 @@
 /**
  * MCP Registry - Industry Standard Interface with camelCase
  */
-import type { DiscoveredMcp, ExecutionContext, ToolInfo } from "./contracts/mcpContract.js";
+import type { DiscoveredMcp, McpRegistry } from "../types/mcpTypes.js";
+import type { ToolInfo, ExecutionContext } from "../types/tools.js";
 import type { UnknownRecord } from "../types/common.js";
-/**
- * MCP Registry interface with optional methods for maximum flexibility
- */
-export interface McpRegistry {
-    registerServer?(serverId: string, serverConfig?: unknown, context?: ExecutionContext): Promise<void>;
-    executeTool?<T = unknown>(toolName: string, args?: unknown, context?: ExecutionContext): Promise<T>;
-    listTools?(context?: ExecutionContext): Promise<ToolInfo[]>;
-}
 /**
  * Simple MCP registry for plugin management
  * Maintains backward compatibility with existing code
  */
 export declare class MCPRegistry implements McpRegistry {
-    plugins: Map<string, DiscoveredMcp<import("../types/typeAliases.js").StandardRecord>>;
+    plugins: Map<string, DiscoveredMcp>;
     /**
      * Register a plugin
      */

package/dist/lib/mcp/servers/agent/directToolsServer.d.ts

@@ -5,4 +5,4 @@
 /**
  * Direct Tools Server - Agent direct tools for immediate use
  */
-export declare const directToolsServer: import("../../factory.js").NeuroLinkMCPServer;
+export declare const directToolsServer: import("../../../types/mcpTypes.js").NeuroLinkMCPServer;

package/dist/lib/mcp/servers/aiProviders/aiCoreServer.d.ts

@@ -7,4 +7,4 @@
  * AI Core Server - Central hub for AI provider management
  * Provides provider selection and status checking functionality
  */
-export declare const aiCoreServer: import("../../factory.js").NeuroLinkMCPServer;
+export declare const aiCoreServer: import("../../../types/mcpTypes.js").NeuroLinkMCPServer;

package/dist/lib/mcp/servers/utilities/utilityServer.d.ts

@@ -5,4 +5,4 @@
 /**
  * Utility Server - General utility tools
  */
-export declare const utilityServer: import("../../factory.js").NeuroLinkMCPServer;
+export declare const utilityServer: import("../../../types/mcpTypes.js").NeuroLinkMCPServer;

package/dist/lib/mcp/toolDiscoveryService.d.ts

@@ -5,90 +5,9 @@
  */
 import { EventEmitter } from "events";
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { ExternalMCPToolInfo, ExternalMCPToolResult, ExternalMCPToolContext } from "../types/externalMcp.js";
+import type { ExternalMCPToolInfo, ExternalMCPToolResult } from "../types/externalMcp.js";
+import type { ToolDiscoveryResult, ExternalToolExecutionOptions } from "../types/mcpTypes.js";
 import type { JsonObject } from "../types/common.js";
-/**
- * Tool discovery result
- */
-export interface ToolDiscoveryResult {
-    /** Whether discovery was successful */
-    success: boolean;
-    /** Number of tools discovered */
-    toolCount: number;
-    /** Discovered tools */
-    tools: ExternalMCPToolInfo[];
-    /** Error message if failed */
-    error?: string;
-    /** Discovery duration in milliseconds */
-    duration: number;
-    /** Server ID */
-    serverId: string;
-}
-/**
- * Tool execution options
- */
-export interface ToolExecutionOptions {
-    /** Execution timeout in milliseconds */
-    timeout?: number;
-    /** Additional context for execution */
-    context?: Partial<ExternalMCPToolContext>;
-    /** Whether to validate input parameters */
-    validateInput?: boolean;
-    /** Whether to validate output */
-    validateOutput?: boolean;
-}
-/**
- * Tool validation result
- */
-export interface ToolValidationResult {
-    /** Whether the tool is valid */
-    isValid: boolean;
-    /** Validation errors */
-    errors: string[];
-    /** Validation warnings */
-    warnings: string[];
-    /** Tool metadata */
-    metadata?: {
-        category?: string;
-        complexity?: "simple" | "moderate" | "complex";
-        requiresAuth?: boolean;
-        isDeprecated?: boolean;
-    };
-}
-/**
- * Tool registry events
- */
-export interface ToolRegistryEvents {
-    toolRegistered: {
-        serverId: string;
-        toolName: string;
-        toolInfo: ExternalMCPToolInfo;
-        timestamp: Date;
-    };
-    toolUnregistered: {
-        serverId: string;
-        toolName: string;
-        timestamp: Date;
-    };
-    toolUpdated: {
-        serverId: string;
-        toolName: string;
-        oldInfo: ExternalMCPToolInfo;
-        newInfo: ExternalMCPToolInfo;
-        timestamp: Date;
-    };
-    discoveryCompleted: {
-        serverId: string;
-        toolCount: number;
-        duration: number;
-        timestamp: Date;
-    };
-    discoveryFailed: {
-        serverId: string;
-        error: string;
-        timestamp: Date;
-    };
-}
 /**
  * ToolDiscoveryService
  * Handles automatic tool discovery and registration from external MCP servers
@@ -134,7 +53,7 @@ export declare class ToolDiscoveryService extends EventEmitter {
     /**
      * Execute a tool
      */
-    executeTool(toolName: string, serverId: string, client: Client, parameters: JsonObject, options?: ToolExecutionOptions): Promise<ExternalMCPToolResult>;
+    executeTool(toolName: string, serverId: string, client: Client, parameters: JsonObject, options?: ExternalToolExecutionOptions): Promise<ExternalMCPToolResult>;
     /**
      * Validate tool parameters
      */

package/dist/lib/mcp/toolRegistry.d.ts

@@ -2,32 +2,10 @@
  * MCP Tool Registry - Extended Registry with Tool Management
  * Updated to match industry standard camelCase interfaces
  */
-import type { ExecutionContext, ToolInfo } from "./contracts/mcpContract.js";
-import type { ToolResult } from "./factory.js";
 import type { MCPServerInfo } from "../types/mcpTypes.js";
+import type { ToolImplementation, ToolInfo, ExecutionContext } from "../types/tools.js";
 import { MCPRegistry } from "./registry.js";
 import type { HITLManager } from "../hitl/hitlManager.js";
-interface ToolImplementation {
-    execute: (params: unknown, context?: ExecutionContext) => Promise<unknown> | unknown;
-    description?: string;
-    inputSchema?: unknown;
-    outputSchema?: unknown;
-    category?: string;
-    permissions?: string[];
-}
-export type ToolExecutionResult = ToolResult;
-/**
- * Tool execution options
- */
-export interface ToolExecutionOptions {
-    timeout?: number;
-    retries?: number;
-    context?: ExecutionContext;
-    preferredSource?: string;
-    fallbackEnabled?: boolean;
-    validateBeforeExecution?: boolean;
-    timeoutMs?: number;
-}
 export declare class MCPToolRegistry extends MCPRegistry {
     private tools;
     private toolImplementations;
@@ -163,4 +141,4 @@ export declare class MCPToolRegistry extends MCPRegistry {
 }
 export declare const toolRegistry: MCPToolRegistry;
 export declare const defaultToolRegistry: MCPToolRegistry;
-export type { ToolInfo } from "./contracts/mcpContract.js";
+export type { ToolInfo } from "../types/tools.js";

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

@@ -1,20 +1,9 @@
-import type { LanguageModelV1 } from "ai";
 import type { NeuroLinkMiddleware } from "../../types/middlewareTypes.js";
+import type { GuardrailsMiddlewareConfig } from "../../types/guardrails.js";
+export type { GuardrailsMiddlewareConfig } from "../../types/guardrails.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.
+ * Create Guardrails AI middleware for content filtering and policy enforcement
+ * @param config Configuration for the guardrails middleware
+ * @returns NeuroLink middleware instance
  */
 export declare function createGuardrailsMiddleware(config?: GuardrailsMiddlewareConfig): NeuroLinkMiddleware;

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

@@ -1,43 +1,48 @@
 import { generateText } from "ai";
+import { createBlockedResponse, createBlockedStream, applyContentFiltering, handlePrecallGuardrails, } from "../utils/guardrailsUtils.js";
 import { logger } from "../../utils/logger.js";
 /**
- * Create Guardrails AI middleware for content filtering and policy enforcement.
- * @param config - Configuration for the guardrails middleware.
+ * Create Guardrails AI middleware for content filtering and policy enforcement
+ * @param config Configuration for the guardrails middleware
+ * @returns NeuroLink middleware instance
  */
 export function createGuardrailsMiddleware(config = {}) {
     const metadata = {
         id: "guardrails",
         name: "Guardrails AI",
-        description: "Provides content filtering and policy enforcement using custom rules and AI models.",
+        description: "Provides comprehensive content filtering and policy enforcement using custom rules, AI models, and precall evaluation to filter inappropriate content before it reaches the LLM.",
         priority: 90,
         defaultEnabled: true,
     };
+    // WeakMap to store blocking state from transformParams to wrap methods
+    const blockingState = new WeakMap();
     const middleware = {
-        wrapGenerate: async ({ doGenerate, params: _params }) => {
-            logger.debug(`[GuardrailsMiddleware] Applying to generate call.`, {
-                badWordsEnabled: !!config.badWords?.enabled,
-                modelFilterEnabled: !!config.modelFilter?.enabled,
-            });
+        transformParams: async ({ params }) => {
+            if (config.precallEvaluation?.enabled) {
+                const { shouldBlock, transformedParams } = await handlePrecallGuardrails(params, config.precallEvaluation);
+                // Store the blocking state for use in wrap methods
+                blockingState.set(transformedParams, shouldBlock);
+                return transformedParams;
+            }
+            return params;
+        },
+        wrapGenerate: async ({ doGenerate, params }) => {
+            logger.debug(`[GuardrailsMiddleware] Applying to generate call.`);
+            // Check if this request should be blocked (set by transformParams)
+            if (config.precallEvaluation?.enabled && blockingState.get(params)) {
+                return createBlockedResponse();
+            }
             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 ?? "" };
-                }
+            const filterResult = applyContentFiltering(result.text || "", config.badWords, "generate");
+            if (filterResult.hasChanges) {
+                result = { ...result, text: filterResult.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
+                        model: config.modelFilter.filterModel,
                         prompt: filterPrompt,
                     });
                     if (filterResponse.toLowerCase().trim() === "unsafe") {
@@ -53,28 +58,28 @@ export function createGuardrailsMiddleware(config = {}) {
             }
             return result;
         },
-        wrapStream: async ({ doStream, params: _params }) => {
-            logger.debug(`[GuardrailsMiddleware] Applying to stream call.`, {
-                badWordsEnabled: !!config.badWords?.enabled,
-            });
-            const { stream, ...rest } = await doStream();
-            // Helper to escape regex special characters
-            function escapeRegExp(string) {
-                return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        wrapStream: async ({ doStream, params }) => {
+            logger.debug(`[GuardrailsMiddleware] Applying to stream call.`);
+            // Check if this request should be blocked (set by transformParams)
+            if (config.precallEvaluation?.enabled && blockingState.get(params)) {
+                return {
+                    stream: createBlockedStream(),
+                    rawCall: { rawPrompt: null, rawSettings: {} },
+                    warnings: [],
+                };
             }
+            const { stream, ...rest } = await doStream();
             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(escapeRegExp(term), "gi");
-                            if (typeof filteredChunk === "object" &&
-                                "textDelta" in filteredChunk) {
-                                filteredChunk = {
-                                    ...filteredChunk,
-                                    textDelta: filteredChunk.textDelta.replace(regex, "*".repeat(term.length)),
-                                };
-                            }
+                    if (typeof filteredChunk === "object" &&
+                        "textDelta" in filteredChunk) {
+                        const filterResult = applyContentFiltering(filteredChunk.textDelta, config.badWords, "stream");
+                        if (filterResult.hasChanges) {
+                            filteredChunk = {
+                                ...filteredChunk,
+                                textDelta: filterResult.filteredText,
+                            };
                         }
                     }
                     controller.enqueue(filteredChunk);

package/dist/lib/middleware/utils/guardrailsUtils.d.ts

@@ -0,0 +1,64 @@
+import type { PrecallEvaluationResult, PrecallEvaluationConfig, EvaluationActionResult, BadWordsConfig } from "../../types/guardrails.js";
+import type { LanguageModelV1CallOptions } from "ai";
+export declare const DEFAULT_EVALUATION_PROMPT = "\nEvaluate the following user input for safety and appropriateness. Respond ONLY with valid JSON:\n\n{\n  \"overall\": \"safe|unsafe|suspicious|inappropriate\",\n  \"safetyScore\": <1-10>,\n  \"appropriatenessScore\": <1-10>,\n  \"confidenceLevel\": <1-10>,\n  \"issues\": [\n    {\n      \"category\": \"explicit_content|hate_speech|violence|personal_info|spam|other\",\n      \"severity\": \"low|medium|high|critical\",\n      \"description\": \"Brief description\"\n    }\n  ],\n  \"suggestedAction\": \"allow|block|sanitize|warn\",\n  \"reasoning\": \"Brief explanation\"\n}\n\nUser Input: \"{USER_INPUT}\"\n";
+/**
+ * Extract user input from LanguageModelV1CallOptions
+ */
+export declare function extractUserInput(params: LanguageModelV1CallOptions): string;
+export declare function parseEvaluationResponse(rawResponse: string): PrecallEvaluationResult;
+/**
+ * Handles the precall guardrails logic, including evaluation and sanitization.
+ * @param params - The language model call options.
+ * @param config - The precall evaluation configuration.
+ * @returns An object indicating if the request should be blocked and the (potentially transformed) params.
+ */
+export declare function handlePrecallGuardrails(params: LanguageModelV1CallOptions, config: PrecallEvaluationConfig): Promise<{
+    shouldBlock: boolean;
+    transformedParams: LanguageModelV1CallOptions;
+}>;
+/**
+ * Perform precall evaluation of user input using AI models
+ */
+export declare function performPrecallEvaluation(config: PrecallEvaluationConfig, userInput: string): Promise<PrecallEvaluationResult>;
+export declare function applyEvaluationActions(evaluation: PrecallEvaluationResult, config: PrecallEvaluationConfig, userInput: string): EvaluationActionResult;
+/**
+ * Apply parameter sanitization to request parameters
+ */
+export declare function applySanitization(params: LanguageModelV1CallOptions, sanitizedInput: string): LanguageModelV1CallOptions;
+export declare function escapeRegExp(string: string): string;
+export declare function createBlockedResponse(): {
+    text: string;
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+    finishReason: "stop";
+    warnings: never[];
+    rawCall: {
+        rawPrompt: null;
+        rawSettings: {};
+    };
+};
+export declare function createBlockedStream(): ReadableStream<any>;
+/**
+ * Result from content filtering operation
+ */
+export interface ContentFilteringResult {
+    filteredText: string;
+    hasChanges: boolean;
+    appliedFilters: string[];
+    filteringStats: {
+        regexPatternsApplied: number;
+        stringFiltersApplied: number;
+        totalMatches: number;
+    };
+}
+/**
+ * Apply content filtering using bad words configuration
+ * Handles both regex patterns and string lists with proper priority
+ * @param text The text to filter
+ * @param badWordsConfig Bad words configuration
+ * @param context Optional context for logging (e.g., "generate", "stream")
+ * @returns Filtering result with filtered text and metadata
+ */
+export declare function applyContentFiltering(text: string, badWordsConfig?: BadWordsConfig, context?: string): ContentFilteringResult;