@juspay/neurolink 9.36.0 → 9.37.0

package/dist/evaluation/scorers/scorerRegistry.js

@@ -0,0 +1,467 @@
+/**
+ * @file Scorer registry for managing scorer registration and discovery
+ * Follows NeuroLink's factory + registry pattern with dynamic imports
+ */
+import { logger } from "../../utils/logger.js";
+/**
+ * Central registry for all scorers
+ * Manages registration, discovery, and instantiation
+ */
+export class ScorerRegistry {
+    static scorers = new Map();
+    static initialized = false;
+    static initPromise = null;
+    /**
+     * Register a scorer with the registry
+     */
+    static register(entry) {
+        const { metadata } = entry;
+        const normalizedId = metadata.id.toLowerCase();
+        if (ScorerRegistry.scorers.has(normalizedId)) {
+            logger.warn(`Scorer ${metadata.id} already registered, overwriting`);
+        }
+        ScorerRegistry.scorers.set(normalizedId, entry);
+        // Register aliases
+        if (entry.aliases) {
+            for (const alias of entry.aliases) {
+                ScorerRegistry.scorers.set(alias.toLowerCase(), entry);
+            }
+        }
+        logger.debug(`Scorer registered: ${metadata.id}`, {
+            name: metadata.name,
+            type: metadata.type,
+            category: metadata.category,
+        });
+    }
+    /**
+     * Register a scorer using a simple configuration
+     */
+    static registerScorer(metadata, factory, aliases = []) {
+        ScorerRegistry.register({
+            metadata,
+            factory,
+            defaultConfig: metadata.defaultConfig,
+            aliases,
+        });
+    }
+    /**
+     * Register built-in scorers using dynamic imports
+     */
+    static async registerBuiltInScorers() {
+        if (ScorerRegistry.initialized) {
+            return;
+        }
+        if (ScorerRegistry.initPromise) {
+            return ScorerRegistry.initPromise;
+        }
+        ScorerRegistry.initPromise = (async () => {
+            try {
+                // Register LLM-based scorers with dynamic imports
+                ScorerRegistry.registerScorer({
+                    id: "hallucination",
+                    name: "Hallucination Detection",
+                    description: "Detects factual errors, fabrications, and unsupported claims in responses",
+                    type: "llm",
+                    category: "accuracy",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.8,
+                        weight: 1.5,
+                        timeout: 30000,
+                        retries: 2,
+                    },
+                    requiredInputs: ["query", "response"],
+                    optionalInputs: ["context", "groundTruth"],
+                }, async (config) => {
+                    const { HallucinationScorer } = await import("./llm/hallucinationScorer.js");
+                    return new HallucinationScorer(config);
+                }, ["hallucination-detection", "hallucinations"]);
+                ScorerRegistry.registerScorer({
+                    id: "toxicity",
+                    name: "Toxicity Analysis",
+                    description: "Detects harmful, offensive, or inappropriate content in responses",
+                    type: "llm",
+                    category: "safety",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.9,
+                        weight: 2.0,
+                        timeout: 20000,
+                        retries: 1,
+                    },
+                    requiredInputs: ["response"],
+                    optionalInputs: ["query"],
+                }, async (config) => {
+                    const { ToxicityScorer } = await import("./llm/toxicityScorer.js");
+                    return new ToxicityScorer(config);
+                }, ["toxic", "safety"]);
+                ScorerRegistry.registerScorer({
+                    id: "faithfulness",
+                    name: "Faithfulness",
+                    description: "Evaluates if the response is faithfully grounded in provided context",
+                    type: "llm",
+                    category: "faithfulness",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.7,
+                        weight: 1.2,
+                        timeout: 30000,
+                        retries: 2,
+                    },
+                    requiredInputs: ["response", "context"],
+                    optionalInputs: ["query"],
+                }, async (config) => {
+                    const { FaithfulnessScorer } = await import("./llm/faithfulnessScorer.js");
+                    return new FaithfulnessScorer(config);
+                }, ["faithful", "grounding"]);
+                ScorerRegistry.registerScorer({
+                    id: "context-relevancy",
+                    name: "Context Relevancy",
+                    description: "Evaluates how relevant the retrieved context is to the user query",
+                    type: "llm",
+                    category: "relevancy",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.6,
+                        weight: 1.0,
+                        timeout: 25000,
+                        retries: 2,
+                    },
+                    requiredInputs: ["query", "context"],
+                    optionalInputs: ["response"],
+                }, async (config) => {
+                    const { ContextRelevancyScorer } = await import("./llm/contextRelevancyScorer.js");
+                    return new ContextRelevancyScorer(config);
+                }, ["context-relevance"]);
+                ScorerRegistry.registerScorer({
+                    id: "answer-relevancy",
+                    name: "Answer Relevancy",
+                    description: "Evaluates how relevant the AI response is to the user query",
+                    type: "llm",
+                    category: "relevancy",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.7,
+                        weight: 1.0,
+                        timeout: 25000,
+                        retries: 2,
+                    },
+                    requiredInputs: ["query", "response"],
+                    optionalInputs: ["context"],
+                }, async (config) => {
+                    const { AnswerRelevancyScorer } = await import("./llm/answerRelevancyScorer.js");
+                    return new AnswerRelevancyScorer(config);
+                }, ["response-relevancy", "relevancy"]);
+                ScorerRegistry.registerScorer({
+                    id: "context-precision",
+                    name: "Context Precision",
+                    description: "Measures the precision of retrieved context - whether relevant chunks are ranked higher",
+                    type: "llm",
+                    category: "relevancy",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.6,
+                        weight: 0.8,
+                        timeout: 25000,
+                        retries: 2,
+                    },
+                    requiredInputs: ["query", "context"],
+                    optionalInputs: ["groundTruth"],
+                }, async (config) => {
+                    const { ContextPrecisionScorer } = await import("./llm/contextPrecisionScorer.js");
+                    return new ContextPrecisionScorer(config);
+                }, ["precision"]);
+                ScorerRegistry.registerScorer({
+                    id: "bias-detection",
+                    name: "Bias Detection",
+                    description: "Identifies potential biases in AI responses",
+                    type: "llm",
+                    category: "safety",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.8,
+                        weight: 1.0,
+                        timeout: 25000,
+                        retries: 2,
+                    },
+                    requiredInputs: ["response"],
+                    optionalInputs: ["query", "context"],
+                }, async (config) => {
+                    const { BiasDetectionScorer } = await import("./llm/biasDetectionScorer.js");
+                    return new BiasDetectionScorer(config);
+                }, ["bias", "fairness"]);
+                ScorerRegistry.registerScorer({
+                    id: "tone-consistency",
+                    name: "Tone Consistency",
+                    description: "Checks for consistent tone throughout the response",
+                    type: "llm",
+                    category: "quality",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.7,
+                        weight: 0.8,
+                        timeout: 20000,
+                        retries: 1,
+                    },
+                    requiredInputs: ["response"],
+                    optionalInputs: ["query"],
+                }, async (config) => {
+                    const { ToneConsistencyScorer } = await import("./llm/toneConsistencyScorer.js");
+                    return new ToneConsistencyScorer(config);
+                }, ["tone"]);
+                ScorerRegistry.registerScorer({
+                    id: "prompt-alignment",
+                    name: "Prompt Alignment",
+                    description: "Measures how well the response aligns with prompt instructions",
+                    type: "llm",
+                    category: "quality",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.7,
+                        weight: 1.0,
+                        timeout: 25000,
+                        retries: 2,
+                    },
+                    requiredInputs: ["query", "response"],
+                    optionalInputs: [],
+                }, async (config) => {
+                    const { PromptAlignmentScorer } = await import("./llm/promptAlignmentScorer.js");
+                    return new PromptAlignmentScorer(config);
+                }, ["alignment", "instruction-following"]);
+                ScorerRegistry.registerScorer({
+                    id: "summarization",
+                    name: "Summarization Quality",
+                    description: "Evaluates the quality of AI-generated summaries",
+                    type: "llm",
+                    category: "quality",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.7,
+                        weight: 1.0,
+                        timeout: 25000,
+                        retries: 2,
+                    },
+                    requiredInputs: ["response", "context"],
+                    optionalInputs: ["query"],
+                }, async (config) => {
+                    const { SummarizationScorer } = await import("./llm/summarizationScorer.js");
+                    return new SummarizationScorer(config);
+                }, ["summary"]);
+                // Register rule-based scorers
+                ScorerRegistry.registerScorer({
+                    id: "keyword-coverage",
+                    name: "Keyword Coverage",
+                    description: "Checks if response covers expected keywords and concepts",
+                    type: "rule",
+                    category: "quality",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.6,
+                        weight: 0.8,
+                        timeout: 1000,
+                        retries: 0,
+                    },
+                    requiredInputs: ["response"],
+                    optionalInputs: ["query", "custom"],
+                }, async (config) => {
+                    const { KeywordCoverageScorer } = await import("./rule/keywordCoverageScorer.js");
+                    return new KeywordCoverageScorer(config);
+                }, ["keywords"]);
+                ScorerRegistry.registerScorer({
+                    id: "content-similarity",
+                    name: "Content Similarity",
+                    description: "Measures text similarity between response and reference",
+                    type: "rule",
+                    category: "accuracy",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.5,
+                        weight: 1.0,
+                        timeout: 2000,
+                        retries: 0,
+                    },
+                    requiredInputs: ["response", "groundTruth"],
+                    optionalInputs: [],
+                }, async (config) => {
+                    const { ContentSimilarityScorer } = await import("./rule/contentSimilarityScorer.js");
+                    return new ContentSimilarityScorer(config);
+                }, ["similarity", "text-similarity"]);
+                ScorerRegistry.registerScorer({
+                    id: "length",
+                    name: "Response Length",
+                    description: "Validates response length against configured bounds",
+                    type: "rule",
+                    category: "quality",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.8,
+                        weight: 0.5,
+                        timeout: 100,
+                        retries: 0,
+                    },
+                    requiredInputs: ["response"],
+                    optionalInputs: [],
+                }, async (config) => {
+                    const { LengthScorer } = await import("./rule/lengthScorer.js");
+                    return new LengthScorer(config);
+                }, ["response-length"]);
+                ScorerRegistry.registerScorer({
+                    id: "format",
+                    name: "Format Validation",
+                    description: "Checks if response follows expected formatting requirements",
+                    type: "rule",
+                    category: "quality",
+                    version: "1.0.0",
+                    defaultConfig: {
+                        enabled: true,
+                        threshold: 0.8,
+                        weight: 0.5,
+                        timeout: 100,
+                        retries: 0,
+                    },
+                    requiredInputs: ["response"],
+                    optionalInputs: ["custom"],
+                }, async (config) => {
+                    const { FormatScorer } = await import("./rule/formatScorer.js");
+                    return new FormatScorer(config);
+                }, ["formatting"]);
+                ScorerRegistry.initialized = true;
+                logger.debug(`Registered ${ScorerRegistry.scorers.size} built-in scorers (including aliases)`);
+            }
+            finally {
+                // Keep initPromise for future callers to await
+            }
+        })();
+        return ScorerRegistry.initPromise;
+    }
+    /**
+     * Get a scorer instance by ID
+     */
+    static async getScorer(scorerId, config) {
+        await ScorerRegistry.ensureInitialized();
+        const normalizedId = scorerId.toLowerCase();
+        const entry = ScorerRegistry.scorers.get(normalizedId);
+        if (!entry) {
+            logger.warn(`Scorer not found: ${scorerId}`);
+            return undefined;
+        }
+        // Merge configurations
+        const mergedConfig = {
+            ...entry.defaultConfig,
+            ...config,
+        };
+        return entry.factory(mergedConfig);
+    }
+    /**
+     * Get scorers by category
+     */
+    static getScorersByCategory(category) {
+        const results = [];
+        const seen = new Set();
+        for (const entry of ScorerRegistry.scorers.values()) {
+            if (entry.metadata.category === category &&
+                !seen.has(entry.metadata.id)) {
+                results.push(entry);
+                seen.add(entry.metadata.id);
+            }
+        }
+        return results;
+    }
+    /**
+     * Get scorers by type
+     */
+    static getScorersByType(type) {
+        const results = [];
+        const seen = new Set();
+        for (const entry of ScorerRegistry.scorers.values()) {
+            if (entry.metadata.type === type && !seen.has(entry.metadata.id)) {
+                results.push(entry);
+                seen.add(entry.metadata.id);
+            }
+        }
+        return results;
+    }
+    /**
+     * List all registered scorer metadata
+     */
+    static list() {
+        const results = [];
+        const seen = new Set();
+        for (const entry of ScorerRegistry.scorers.values()) {
+            if (!seen.has(entry.metadata.id)) {
+                results.push(entry.metadata);
+                seen.add(entry.metadata.id);
+            }
+        }
+        return results;
+    }
+    /**
+     * Check if a scorer is registered
+     */
+    static has(scorerId) {
+        return ScorerRegistry.scorers.has(scorerId.toLowerCase());
+    }
+    /**
+     * Unregister a scorer
+     */
+    static unregister(scorerId) {
+        const normalizedId = scorerId.toLowerCase();
+        const entry = ScorerRegistry.scorers.get(normalizedId);
+        if (!entry) {
+            return false;
+        }
+        // Remove main entry
+        ScorerRegistry.scorers.delete(normalizedId);
+        // Remove aliases
+        if (entry.aliases) {
+            for (const alias of entry.aliases) {
+                ScorerRegistry.scorers.delete(alias.toLowerCase());
+            }
+        }
+        logger.debug(`Scorer unregistered: ${scorerId}`);
+        return true;
+    }
+    /**
+     * Clear all registered scorers
+     */
+    static clear() {
+        ScorerRegistry.scorers.clear();
+        ScorerRegistry.initialized = false;
+        ScorerRegistry.initPromise = null;
+        logger.debug("Scorer registry cleared");
+    }
+    /**
+     * Ensure built-in scorers are initialized
+     */
+    static async ensureInitialized() {
+        if (!ScorerRegistry.initialized) {
+            await ScorerRegistry.registerBuiltInScorers();
+        }
+        if (ScorerRegistry.initPromise) {
+            await ScorerRegistry.initPromise;
+        }
+    }
+    /**
+     * Get the number of registered scorers (excluding aliases)
+     */
+    static get size() {
+        const seen = new Set();
+        for (const entry of ScorerRegistry.scorers.values()) {
+            seen.add(entry.metadata.id);
+        }
+        return seen.size;
+    }
+}

package/dist/index.d.ts

@@ -35,6 +35,8 @@ import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
 export { GoogleTTSHandler } from "./adapters/tts/googleTTSHandler.js";
 export { NeuroLinkConfigManager as ConfigManager } from "./config/configManager.js";
+export { BaseFactory, BaseRegistry, NeuroLinkFeatureError, createErrorFactory, withRetry, TypedEventEmitter, } from "./core/infrastructure/index.js";
+export type { ErrorCode, FactoryFunction, FactoryRegistration, RegistryEntry as CoreRegistryEntry, RetryOptions, } from "./core/infrastructure/index.js";
 export { NeuroLinkClient, createClient, NeuroLinkApiError, NeuroLinkLanguageModel, NeuroLinkAIProvider, createNeuroLinkProvider, createNeuroLinkModel, createStreamingResponse, neurolink as neuroLinkAIInstance, createApiKeyAuthInterceptor, createBearerAuthInterceptor, createDynamicAuthInterceptor, createLoggingInterceptor, createRetryInterceptor, createRateLimitInterceptor, createRequestTransformInterceptor, createResponseTransformInterceptor, createCacheInterceptor, createTimeoutInterceptor, createErrorHandlerInterceptor, composeMiddleware, conditionalMiddleware, SSEClient, WebSocketStreamingClient, createStreamingClient, createAsyncStream, collectStream, OAuth2TokenManager, JWTTokenManager, createApiKeyMiddleware, createBearerTokenMiddleware, createTokenManagerMiddleware, createAuthWithRetryMiddleware, createMultiAuthMiddleware, OAuth2Error, OAuth2AuthError, TokenRefreshError, decodeJWTPayload, isJWTExpired, getJWTExpiry, getApiKeyFromEnv, ErrorCode as ClientErrorCode, NeuroLinkError as ClientNeuroLinkError, HttpError, ClientRateLimitError, ClientValidationError, ClientAuthenticationError, ClientAuthorizationError, NotFoundError, ClientNetworkError, ClientTimeoutError, ClientConnectionError, AbortError, ClientConfigurationError, StreamError, ClientProviderError, ContextLengthError, ContentFilterError, createErrorFromResponse, createErrorFromNative, mapStatusToErrorCode, isRetryableStatus, isRetryableError, isNeuroLinkError, isApiError, } from "./client/index.js";
 export type { ClientConfig, RequestOptions, ApiResponse, ApiError, RetryConfig, Middleware as ClientMiddleware, MiddlewareRequest, MiddlewareResponse, MiddlewareContext as ClientMiddlewareContext, StreamCallbacks, StreamEvent, StreamResult, GenerateRequestOptions, GenerateResponse, StreamRequestOptions, AgentExecuteOptions, AgentExecuteResult, AgentInfo, WorkflowExecuteOptions, WorkflowExecuteResult, WorkflowInfo, ToolInfo as ClientToolInfo, ProviderStatus, WebSocketOptions, WebSocketState, WebSocketMessageHandler, NeuroLinkProviderOptions, ModelOptions, LanguageModel, LanguageModelCallOptions, LanguageModelResponse, LanguageModelStreamResponse, LoggingInterceptorOptions, RetryInterceptorOptions, RateLimiterOptions, CacheInterceptorOptions, TimeoutInterceptorOptions, ErrorHandlerOptions, SSEConnectionOptions, SSEConnectionState, StreamingRequestOptions, StreamingEventEmitter, StreamingClientConfig, SpeechRecognitionResult, SpeechSynthesisOptions, AuthConfig as ClientAuthConfig, OAuth2Config, TokenRefreshResult, ErrorCodeType, } from "./client/index.js";
 export { AIProviderName, BedrockModels, OpenAIModels, VertexModels, } from "./constants/enums.js";
@@ -204,7 +206,7 @@ export declare function createBestAIProvider(requestedProvider?: string, modelNa
  * ```
  */
 export { CircuitBreakerManager, calculateExpiresAt, createMCPServer, createOAuthProviderFromConfig, DEFAULT_HTTP_RETRY_CONFIG, DEFAULT_RATE_LIMIT_CONFIG, executeMCP, FileTokenStorage, getMCPStats, getServerInfo, globalCircuitBreakerManager, globalRateLimiterManager, HTTPRateLimiter, InMemoryTokenStorage, initializeMCPEcosystem, isRetryableHTTPError, isRetryableStatusCode, isTokenExpired, listMCPs, CircuitBreakerOpenError, MCPCircuitBreaker, mcpLogger, NeuroLinkOAuthProvider, RateLimiterManager, validateServerTools, validateTool as validateMCPTool, withHTTPRetry, MCPToolRegistry, ExternalServerManager, MCPClientFactory, ToolRouter, createToolRouter, DEFAULT_ROUTER_CONFIG, ToolCache, createToolCache, DEFAULT_CACHE_CONFIG, ToolResultCache, createToolResultCache, RequestBatcher, ToolCallBatcher, createRequestBatcher, createToolCallBatcher, DEFAULT_BATCH_CONFIG, inferAnnotations, createAnnotatedTool, validateAnnotations, filterToolsByAnnotations, mergeAnnotations, getAnnotationSummary, requiresConfirmation, isSafeToRetry, getToolSafetyLevel, ElicitationManager, globalElicitationManager, EnhancedToolDiscovery, MCPRegistryClient, globalMCPRegistryClient, getWellKnownServer, getAllWellKnownServers, MCPServerBase, MultiServerManager, globalMultiServerManager, AgentExposureManager, exposeAgentAsTool, exposeAgentsAsTools, exposeWorkflowAsTool, exposeWorkflowsAsTools, globalAgentExposureManager, ServerCapabilitiesManager, createTextResource, createJsonResource, createPrompt, neuroLinkToolToMCP, mcpToolToNeuroLink, batchConvertToMCP, batchConvertToNeuroLink, sanitizeToolName, validateToolName, createToolFromFunction, mcpProtocolToolToServerTool, serverToolToMCPProtocol, TOOL_COMPATIBILITY, ToolIntegrationManager, globalToolIntegrationManager, wrapToolWithElicitation, wrapToolsWithElicitation, createElicitationContext, confirmationMiddleware, validationMiddleware, loggingMiddleware, createRetryMiddleware, createTimeoutMiddleware, createToolMiddlewareChain, ElicitationProtocolAdapter, globalElicitationProtocol, isElicitationProtocolMessage, protocolMessageToElicitation, elicitationResponseToProtocol, createElicitationRequest, createElicitationResponse, createElicitationCancel, createTextInputRequest, createSelectRequest, createConfirmationRequest, createFormRequest, } from "./mcp/index.js";
-export type { RoutingStrategy, ToolRouterConfig, RoutingDecision, MCPTool, ToolRouterEvents, AffinityRule, CategoryMapping, RouterServerWeight, CacheStrategy, CacheConfig as MCPCacheConfig, CacheStats, CacheEvents, BatchConfig, BatchResult, BatchExecutor, BatcherEvents, MCPToolAnnotations, MCPServerTool, ToolConverterOptions, MCPProtocolTool, NeuroLinkTool, ToolMiddleware, EnhancedExecutionContext, ToolWrapperOptions, ExposableAgent, ExposableWorkflow, ExposureOptions, ExposureResult, MCPResource, MCPPrompt, ServerCapabilitiesConfig, PromptGenerator, PromptMessage, PromptResult, RegisteredPrompt, RegisteredResource, ResourceContent, ResourceReader, ResourceSubscriptionCallback, RegistryEntry, RegistrySearchOptions, RegistrySearchResult, RegistrySourceType, RegistryConfig, MCPRegistryClientConfig, LoadBalancingStrategy, ServerGroup, UnifiedTool, MultiServerManagerConfig, ServerWeight, MCPServerBaseConfig, MCPServerEvents, EnhancedToolInfo, ToolSearchCriteria, ToolSearchResult, CompatibilityCheckResult, ElicitationType, Elicitation, ElicitationResponse, ElicitationHandler, ElicitationManagerConfig, ElicitationRequest, ElicitationContext, TextElicitation, SelectElicitation, SelectOption, MultiSelectElicitation, ConfirmationElicitation, FileElicitation, SecretElicitation, FormElicitation, FormField, ElicitationProtocolMessage, ElicitationProtocolMessageType, ElicitationProtocolPayload, ElicitationProtocolHandler, ElicitationProtocolAdapterConfig, ElicitationRequestMessage, ElicitationRequestParams, ElicitationResponseMessage, ElicitationResponseParams, ElicitationCancelMessage, ElicitationCancelParams, } from "./mcp/index.js";
+export type { RoutingStrategy, ToolRouterConfig, RoutingDecision, MCPTool, ToolRouterEvents, AffinityRule, CategoryMapping, RouterServerWeight, CacheStrategy, CacheConfig as MCPCacheConfig, CacheStats, CacheEvents, BatchConfig, BatchResult, BatchExecutor, BatcherEvents, MCPToolAnnotations, MCPServerTool, ToolConverterOptions, MCPProtocolTool, NeuroLinkTool, ToolMiddleware, EnhancedExecutionContext, ToolWrapperOptions, ExposableAgent, ExposableWorkflow, ExposureOptions, ExposureResult, MCPResource, MCPPrompt, ServerCapabilitiesConfig, PromptGenerator, PromptMessage, PromptResult, RegisteredPrompt, RegisteredResource, ResourceContent, ResourceReader, ResourceSubscriptionCallback, RegistryEntry, RegistryEntry as MCPRegistryEntry, RegistrySearchOptions, RegistrySearchResult, RegistrySourceType, RegistryConfig, MCPRegistryClientConfig, LoadBalancingStrategy, ServerGroup, UnifiedTool, MultiServerManagerConfig, ServerWeight, MCPServerBaseConfig, MCPServerEvents, EnhancedToolInfo, ToolSearchCriteria, ToolSearchResult, CompatibilityCheckResult, ElicitationType, Elicitation, ElicitationResponse, ElicitationHandler, ElicitationManagerConfig, ElicitationRequest, ElicitationContext, TextElicitation, SelectElicitation, SelectOption, MultiSelectElicitation, ConfirmationElicitation, FileElicitation, SecretElicitation, FormElicitation, FormField, ElicitationProtocolMessage, ElicitationProtocolMessageType, ElicitationProtocolPayload, ElicitationProtocolHandler, ElicitationProtocolAdapterConfig, ElicitationRequestMessage, ElicitationRequestParams, ElicitationResponseMessage, ElicitationResponseParams, ElicitationCancelMessage, ElicitationCancelParams, } from "./mcp/index.js";
 export type { AuthorizationUrlResult, DiscoveredMcp, HTTPRetryConfig, MCPOAuthConfig, McpMetadata, OAuthClientInformation, OAuthTokens as McpOAuthTokens, RateLimitConfig, TokenExchangeRequest, TokenStorage, } from "./types/mcpTypes.js";
 export type { ExecutionContext, ToolExecutionResult, ToolInfo, } from "./types/tools.js";
 export type { LogLevel } from "./types/utilities.js";
@@ -218,6 +220,40 @@ export declare function getTelemetryStatus(): Promise<{
     service?: string;
     version?: string;
 }>;
+/**
+ * Evaluation System Exports
+ *
+ * A comprehensive evaluation framework for assessing AI response quality,
+ * with support for RAGAS-style metrics, custom scorers, and pipeline-based evaluation.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   Evaluator,
+ *   ScorerRegistry,
+ *   EvaluationPipeline,
+ *   createFaithfulnessScorer,
+ *   createAnswerRelevancyScorer,
+ * } from '@juspay/neurolink';
+ *
+ * // Create a pipeline with multiple scorers
+ * const pipeline = new EvaluationPipeline({
+ *   scorers: [
+ *     createFaithfulnessScorer({ model: 'gpt-4' }),
+ *     createAnswerRelevancyScorer({ model: 'gpt-4' }),
+ *   ],
+ * });
+ *
+ * // Run evaluation
+ * const result = await pipeline.evaluate({
+ *   question: 'What is quantum computing?',
+ *   answer: 'Quantum computing uses quantum mechanics...',
+ *   context: ['Quantum computing is a type of computation...'],
+ * });
+ * ```
+ */
+export { Evaluator, BatchEvaluator, EvaluationAggregator, EvaluatorFactory, getEvaluatorFactory, EvaluatorRegistry, getEvaluatorRegistry, EvaluationErrorCodes, evaluationErrors, isRetryableEvaluationError, isEvaluationError, createEvaluationFailedError, createParseError, createStrategyNotFoundError, createProviderError, createMaxRetriesExceededError, createBatchEvaluationError, createConfigurationError, contextToErrorContext, createLangfuseAdapter, createMockLangfuseClient, LangfuseAdapter, startLangfuseAdapter, createConsoleLoggerHook, createMetricsCollectorHook, ObservabilityHooks, observabilityHooks, pipelineToSpanAttributes, scorerToSpanAttributes, createAndInitializePipeline, createPipeline, EvaluationPipeline, PipelineBuilder, Pipelines, CODE_GENERATION_PIPELINE, COMPREHENSIVE_PIPELINE, CUSTOMER_SUPPORT_PIPELINE, getPreset, getPresetNames, MINIMAL_PIPELINE, PipelinePresets, QUALITY_PIPELINE, RAG_PIPELINE, SAFETY_PIPELINE, SUMMARIZATION_PIPELINE, BatchStrategy, createBatchStrategy, evaluateBatch, streamBatchEvaluation, createSamplingStrategy, DEFAULT_SAMPLING_CONFIG, SamplingStrategies, SamplingStrategy, createMetricsCollector, globalMetricsCollector, MetricsCollector, createReportGenerator, ReportGenerator, Reports, BaseScorer, DEFAULT_SCORE_SCALE as EVAL_DEFAULT_SCORE_SCALE, composeScorers, createConditionalScorer, createFunctionScorer, createInvertedScorer, createKeywordScorer, createRegexScorer, createScorerMetadata, createSimpleLengthScorer, AnswerRelevancyScorer, createAnswerRelevancyScorer, BaseLLMScorer, DEFAULT_LLM_SCORER_CONFIG, BiasDetectionScorer, createBiasDetectionScorer, ContextPrecisionScorer, createContextPrecisionScorer, ContextRelevancyScorer, createContextRelevancyScorer, createFaithfulnessScorer, FaithfulnessScorer, createHallucinationScorer, HallucinationScorer, createPromptAlignmentScorer, PromptAlignmentScorer, createSummarizationScorer, SummarizationScorer, createToneConsistencyScorer, ToneConsistencyScorer, createToxicityScorer, ToxicityScorer, BaseRuleScorer, DEFAULT_RULE_SCORER_CONFIG, ContentSimilarityScorer, createContentSimilarityScorer, createFormatScorer, FormatScorer, FormatScorerPresets, createKeywordCoverageScorer, KeywordCoverageScorer, createLengthScorer, LengthScorer, LengthScorerPresets, ScorerBuilder, Scorers, ScorerRegistry, } from "./evaluation/index.js";
+export type { LangfuseAdapterConfig, LangfuseClient, EvaluationEvents, EventHandler, SpanAttributes as EvalSpanAttributes, PipelineExecutionOptions, PipelineResult, AggregatedMetrics, PipelineMetrics, ScorerMetrics, GeneratedReport, ReportData, BatchConfig as EvalBatchConfig, BatchItemResult, BatchProgress as PipelineBatchProgress, BatchResult as EvalBatchResult, ScorerFunction, ContentSimilarityConfig, SimilarityMetric, CodeLanguage, FormatScorerConfig, FormatType, KeywordCoverageConfig, LengthConstraintType, LengthScorerConfig, LengthUnit, BatchEvaluationConfig, BatchProgress, BatchEvaluationItem, BatchEvaluationItemResult, BatchEvaluationResult, ScoreStatistics, ScoreDistribution, TrendAnalysis, DimensionAnalysis, AlertSummary, AggregationResult, EvaluatorPreset, EvaluationStrategyFunction, EvaluationStrategyConfig, EvaluationStrategyMetadata, EvaluationErrorCode, EvaluationErrorContext, } from "./evaluation/index.js";
 export type { AnalyticsData, EvaluationData, TextGenerationOptions, TextGenerationResult, } from "./types/index.js";
 /**
  * Legacy generateText function for backward compatibility.
@@ -350,28 +386,4 @@ export type { BaseChunkerConfig, BM25Result, CharacterChunkerConfig, Chunk, Chun
  */
 export { assembleContext, batchRerank, CharacterChunker, ChunkerRegistry, CohereRelevanceScorer, CrossEncoderReranker, CSVLoader, chunkText, createChunker, createContextWindow, createHybridSearch, createRAGPipeline, createVectorQueryTool, executeWithCircuitBreaker, extractMetadata, formatContextWithCitations, GraphRAG, getAvailableStrategies, getCircuitBreaker, getDefaultChunkerConfig, getRecommendedStrategy, HTMLChunker, HTMLLoader, InMemoryBM25Index, InMemoryVectorStore, JSONChunker as RAGJSONChunker, JSONLoader, LaTeXChunker, LLMMetadataExtractor, linearCombination, loadDocument, loadDocuments, MarkdownChunker, MarkdownLoader, MDocument, PDFLoader, prepareRAGTool, processDocument, RAGCircuitBreaker, type RAGCircuitBreakerConfig, type RAGCircuitBreakerEvents, RAGCircuitBreakerManager, type RAGCircuitBreakerStats, RAGPipeline, RAGRetryHandler, RecursiveChunker, ragCircuitBreakerManager, reciprocalRankFusion, rerank, SemanticChunker, SentenceChunker, simpleRerank, summarizeContext, TextLoader, TokenChunker, WebLoader, } from "./rag/index.js";
 export { ContextBuilder } from "./evaluation/contextBuilder.js";
-/**
- * Evaluation system for AI response quality assessment.
- *
- * Uses RAGAS-style model-based evaluation with a "judge" LLM to score
- * responses on relevance, accuracy, completeness, and overall quality.
- * Supports retry logic with progressive prompt improvement.
- *
- * @example
- * ```typescript
- * import { Evaluator, RAGASEvaluator, ContextBuilder, RetryManager } from '@juspay/neurolink';
- *
- * const evaluator = new Evaluator({
- *   evaluationModel: 'gemini-1.5-flash',
- *   provider: 'vertex',
- *   threshold: 7,
- * });
- * ```
- */
-export { Evaluator } from "./evaluation/index.js";
-export { PromptBuilder } from "./evaluation/prompts.js";
-export { RAGASEvaluator } from "./evaluation/ragasEvaluator.js";
-export { RetryManager } from "./evaluation/retryManager.js";
-export { mapToEvaluationData } from "./evaluation/scoring.js";
-export type { EnhancedConversationTurn, EnhancedEvaluationContext, EvaluationConfig, EvaluationResult, GetPromptFunction, QualityErrorDetails, QueryIntentAnalysis, } from "./types/evaluationTypes.js";
 export { AuthProviderFactory, createAuthProvider, AuthProviderRegistry, AuthError as AuthErrorFactory, AuthErrorCodes, BaseAuthProvider, InMemorySessionStorage, AuthProviderError, createAuthMiddleware as createAuthProviderMiddleware, createRBACMiddleware, createProtectedMiddleware, createExpressAuthMiddleware, createRequestContext, extractToken, AuthMiddlewareError, AuthMiddlewareErrorCodes, type MiddlewareHandler as AuthMiddlewareHandler, type MiddlewareResult, type NextFunction, type ExpressMiddleware, UserRateLimiter, MemoryRateLimitStorage, RedisRateLimitStorage, createRateLimitByUserMiddleware, createAuthenticatedRateLimitMiddleware, createRateLimitStorage, type RateLimitConfig as AuthRateLimitConfig, type RateLimitResult, type RateLimitMiddlewareResult, type RateLimitStorage, SessionManager, MemorySessionStorage, RedisSessionStorage, createSessionStorage, type SessionStorageInterface, AuthContextHolder, globalAuthContext, getAuthContext, getCurrentUser, getCurrentSession, isAuthenticated, hasRole, hasAnyRole, hasPermission, hasAllPermissions, requireAuth, requireRole, requirePermission, requireUser, runWithAuthContext, createAuthenticatedContext, RequestContext, NEUROLINK_RESOURCE_ID_KEY, NEUROLINK_THREAD_ID_KEY, createAuthValidatorFromProvider, } from "./auth/index.js";