@juspay/neurolink 9.41.0 → 9.42.1

package/dist/lib/core/factory.js

@@ -48,6 +48,141 @@ export class AIProviderFactory {
             // This ensures the factory continues to work even if dynamic models fail
         }
     }
+    static resolveModelFromEnvironment(providerName, modelName, functionTag) {
+        if (modelName && modelName !== "default") {
+            logger.debug(`[${functionTag}] Skipping environment variable check - explicit model provided: ${modelName}`);
+            return modelName;
+        }
+        logger.debug(`[${functionTag}] Checking environment variables for provider: ${providerName}`);
+        const normalizedProvider = providerName.toLowerCase();
+        const envConfigs = [
+            {
+                match: ["bedrock"],
+                label: "Bedrock",
+                vars: ["BEDROCK_MODEL", "BEDROCK_MODEL_ID"],
+            },
+            {
+                match: ["vertex"],
+                label: "Vertex",
+                vars: ["VERTEX_MODEL"],
+            },
+            {
+                match: ["azure"],
+                label: "Azure",
+                vars: [
+                    "AZURE_OPENAI_MODEL",
+                    "AZURE_OPENAI_DEPLOYMENT",
+                    "AZURE_OPENAI_DEPLOYMENT_ID",
+                ],
+            },
+            {
+                match: ["openai", "gpt", "chatgpt", "openai-compat"],
+                label: "OpenAI",
+                vars: ["OPENAI_MODEL"],
+            },
+            {
+                match: ["anthropic", "claude", "anthropic-claude"],
+                label: "Anthropic",
+                vars: ["ANTHROPIC_MODEL"],
+            },
+            {
+                match: ["google", "gemini"],
+                label: "Google AI",
+                vars: ["GOOGLE_AI_MODEL"],
+            },
+            {
+                match: ["mistral"],
+                label: "Mistral",
+                vars: ["MISTRAL_MODEL"],
+            },
+            {
+                match: ["ollama"],
+                label: "Ollama",
+                vars: ["OLLAMA_MODEL"],
+            },
+            {
+                match: ["litellm"],
+                label: "LiteLLM",
+                vars: ["LITELLM_MODEL"],
+            },
+        ];
+        const envConfig = envConfigs.find((config) => config.match.some((match) => normalizedProvider.includes(match)));
+        if (!envConfig) {
+            logger.debug(`[${functionTag}] Provider ${providerName} - no environment variable check implemented`);
+            return modelName;
+        }
+        const matchedVar = envConfig.vars.find((name) => process.env[name]);
+        const envModel = matchedVar ? process.env[matchedVar] : undefined;
+        if (envModel) {
+            logger.debug(`[${functionTag}] Environment variable found for ${envConfig.label}`, {
+                envVariable: matchedVar,
+                resolvedModel: envModel,
+            });
+            return envModel;
+        }
+        logger.debug(`[${functionTag}] No ${envConfig.label} environment variables found (${envConfig.vars.join(", ")})`);
+        return modelName;
+    }
+    static async resolveDynamicModelName(providerName, modelName, resolvedModelName, functionTag) {
+        if ((resolvedModelName && resolvedModelName !== "default") ||
+            (modelName && modelName !== "default")) {
+            logger.debug(`[${functionTag}] Skipping dynamic model resolution`, {
+                resolvedModelName: resolvedModelName || "none",
+                reason: "Model already resolved from environment variables or explicit parameter",
+            });
+            return resolvedModelName;
+        }
+        logger.debug(`[${functionTag}] Attempting dynamic model resolution`, {
+            currentResolvedModel: resolvedModelName || "none",
+            reason: "No environment variable found and no explicit model provided",
+        });
+        try {
+            const normalizedProvider = this.normalizeProviderName(providerName);
+            if (dynamicModelProvider.needsRefresh()) {
+                logger.debug(`[${functionTag}] Dynamic model provider needs refresh - initializing`);
+                await this.initializeDynamicProviderWithTimeout();
+            }
+            const dynamicModel = dynamicModelProvider.resolveModel(normalizedProvider, modelName || undefined);
+            if (!dynamicModel) {
+                logger.debug(`[${functionTag}] Dynamic model resolution returned null`, {
+                    provider: normalizedProvider,
+                    requestedModel: modelName || "default",
+                });
+                return resolvedModelName;
+            }
+            logger.debug(`[${functionTag}] Resolved dynamic model`, {
+                provider: normalizedProvider,
+                requestedModel: modelName || "default",
+                resolvedModel: dynamicModel.id,
+                displayName: dynamicModel.displayName,
+                pricing: dynamicModel.pricing.input,
+            });
+            return dynamicModel.id;
+        }
+        catch (resolveError) {
+            logger.debug(`[${functionTag}] Dynamic model resolution failed, using static fallback`, {
+                error: resolveError instanceof Error
+                    ? resolveError.message
+                    : String(resolveError),
+            });
+            return resolvedModelName;
+        }
+    }
+    static async createResolvedProvider(providerName, resolvedModelName, sdk, region, functionTag) {
+        await withTimeout(ProviderRegistry.registerAllProviders(), 30_000, new Error("Provider registration timed out"));
+        const normalizedName = this.normalizeProviderName(providerName);
+        const finalModelName = resolvedModelName === "default" || resolvedModelName === null
+            ? undefined
+            : resolvedModelName;
+        logger.debug(`[${functionTag}] Final provider configuration`, {
+            originalProviderName: providerName,
+            normalizedProviderName: normalizedName,
+            resolvedModelName: resolvedModelName || "not resolved",
+            finalModelName: finalModelName || "using provider default",
+        });
+        const provider = await withTimeout(ProviderFactory.createProvider(normalizedName, finalModelName, sdk, region), 30_000, new Error(`Provider creation timed out for ${normalizedName}`));
+        return { normalizedName, finalModelName, provider };
+    }
     /**
      * Create a provider instance for the specified provider type
      * @param providerName - Name of the provider ('vertex', 'bedrock', 'openai')
@@ -89,194 +224,9 @@ export class AIProviderFactory {
                 // - Enhanced error handling and logging for debugging
                 //
                 // The dynamic model provider now provides reliable functionality without hanging
-                let resolvedModelName = modelName;
-                // PRIORITY 1: Check environment variables BEFORE dynamic resolution
-                if (!modelName || modelName === "default") {
-                    logger.debug(`[${functionTag}] Checking environment variables for provider: ${providerName}`);
-                    // Check for provider-specific environment variables first
-                    if (providerName.toLowerCase().includes("bedrock")) {
-                        const envModel = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
-                        if (envModel) {
-                            resolvedModelName = envModel;
-                            logger.debug(`[${functionTag}] Environment variable found for Bedrock`, {
-                                envVariable: process.env.BEDROCK_MODEL
-                                    ? "BEDROCK_MODEL"
-                                    : "BEDROCK_MODEL_ID",
-                                resolvedModel: envModel,
-                            });
-                        }
-                        else {
-                            logger.debug(`[${functionTag}] No Bedrock environment variables found (BEDROCK_MODEL, BEDROCK_MODEL_ID)`);
-                        }
-                    }
-                    else if (providerName.toLowerCase().includes("vertex")) {
-                        const envModel = process.env.VERTEX_MODEL;
-                        if (envModel) {
-                            resolvedModelName = envModel;
-                            logger.debug(`[${functionTag}] Environment variable found for Vertex`, {
-                                envVariable: "VERTEX_MODEL",
-                                resolvedModel: envModel,
-                            });
-                        }
-                        else {
-                            logger.debug(`[${functionTag}] No Vertex environment variables found (VERTEX_MODEL)`);
-                        }
-                    }
-                    else if (providerName.toLowerCase().includes("azure")) {
-                        const envModel = process.env.AZURE_OPENAI_MODEL ||
-                            process.env.AZURE_OPENAI_DEPLOYMENT ||
-                            process.env.AZURE_OPENAI_DEPLOYMENT_ID;
-                        if (envModel) {
-                            resolvedModelName = envModel;
-                            logger.debug(`[${functionTag}] Environment variable found for Azure`, {
-                                envVariable: process.env.AZURE_OPENAI_MODEL
-                                    ? "AZURE_OPENAI_MODEL"
-                                    : process.env.AZURE_OPENAI_DEPLOYMENT
-                                        ? "AZURE_OPENAI_DEPLOYMENT"
-                                        : "AZURE_OPENAI_DEPLOYMENT_ID",
-                                resolvedModel: envModel,
-                            });
-                        }
-                        else {
-                            logger.debug(`[${functionTag}] No Azure environment variables found (AZURE_OPENAI_MODEL, AZURE_OPENAI_DEPLOYMENT, AZURE_OPENAI_DEPLOYMENT_ID)`);
-                        }
-                    }
-                    else if (providerName.toLowerCase().includes("openai")) {
-                        const envModel = process.env.OPENAI_MODEL;
-                        if (envModel) {
-                            resolvedModelName = envModel;
-                            logger.debug(`[${functionTag}] Environment variable found for OpenAI`, {
-                                envVariable: "OPENAI_MODEL",
-                                resolvedModel: envModel,
-                            });
-                        }
-                        else {
-                            logger.debug(`[${functionTag}] No OpenAI environment variables found (OPENAI_MODEL)`);
-                        }
-                    }
-                    else if (providerName.toLowerCase().includes("anthropic")) {
-                        const envModel = process.env.ANTHROPIC_MODEL;
-                        if (envModel) {
-                            resolvedModelName = envModel;
-                            logger.debug(`[${functionTag}] Environment variable found for Anthropic`, {
-                                envVariable: "ANTHROPIC_MODEL",
-                                resolvedModel: envModel,
-                            });
-                        }
-                        else {
-                            logger.debug(`[${functionTag}] No Anthropic environment variables found (ANTHROPIC_MODEL)`);
-                        }
-                    }
-                    else if (providerName.toLowerCase().includes("google") ||
-                        providerName.toLowerCase().includes("gemini")) {
-                        const envModel = process.env.GOOGLE_AI_MODEL;
-                        if (envModel) {
-                            resolvedModelName = envModel;
-                            logger.debug(`[${functionTag}] Environment variable found for Google AI`, {
-                                envVariable: "GOOGLE_AI_MODEL",
-                                resolvedModel: envModel,
-                            });
-                        }
-                        else {
-                            logger.debug(`[${functionTag}] No Google AI environment variables found (GOOGLE_AI_MODEL)`);
-                        }
-                    }
-                    else if (providerName.toLowerCase().includes("mistral")) {
-                        const envModel = process.env.MISTRAL_MODEL;
-                        if (envModel) {
-                            resolvedModelName = envModel;
-                            logger.debug(`[${functionTag}] Environment variable found for Mistral`, {
-                                envVariable: "MISTRAL_MODEL",
-                                resolvedModel: envModel,
-                            });
-                        }
-                        else {
-                            logger.debug(`[${functionTag}] No Mistral environment variables found (MISTRAL_MODEL)`);
-                        }
-                    }
-                    else if (providerName.toLowerCase().includes("ollama")) {
-                        const envModel = process.env.OLLAMA_MODEL;
-                        if (envModel) {
-                            resolvedModelName = envModel;
-                            logger.debug(`[${functionTag}] Environment variable found for Ollama`, {
-                                envVariable: "OLLAMA_MODEL",
-                                resolvedModel: envModel,
-                            });
-                        }
-                        else {
-                            logger.debug(`[${functionTag}] No Ollama environment variables found (OLLAMA_MODEL)`);
-                        }
-                    }
-                    else {
-                        logger.debug(`[${functionTag}] Provider ${providerName} - no environment variable check implemented`);
-                    }
-                }
-                else {
-                    logger.debug(`[${functionTag}] Skipping environment variable check - explicit model provided: ${modelName}`);
-                }
-                // PRIORITY 2: Enable dynamic model resolution only if no env var found
-                if ((!resolvedModelName || resolvedModelName === "default") &&
-                    (!modelName || modelName === "default")) {
-                    logger.debug(`[${functionTag}] Attempting dynamic model resolution`, {
-                        currentResolvedModel: resolvedModelName || "none",
-                        reason: "No environment variable found and no explicit model provided",
-                    });
-                    try {
-                        const normalizedProvider = this.normalizeProviderName(providerName);
-                        // Initialize with timeout protection - won't hang anymore
-                        if (dynamicModelProvider.needsRefresh()) {
-                            logger.debug(`[${functionTag}] Dynamic model provider needs refresh - initializing`);
-                            await this.initializeDynamicProviderWithTimeout();
-                        }
-                        const dynamicModel = dynamicModelProvider.resolveModel(normalizedProvider, modelName || undefined);
-                        if (dynamicModel) {
-                            resolvedModelName = dynamicModel.id;
-                            logger.debug(`[${functionTag}] Resolved dynamic model`, {
-                                provider: normalizedProvider,
-                                requestedModel: modelName || "default",
-                                resolvedModel: resolvedModelName,
-                                displayName: dynamicModel.displayName,
-                                pricing: dynamicModel.pricing.input,
-                            });
-                        }
-                        else {
-                            logger.debug(`[${functionTag}] Dynamic model resolution returned null`, {
-                                provider: normalizedProvider,
-                                requestedModel: modelName || "default",
-                            });
-                        }
-                    }
-                    catch (resolveError) {
-                        logger.debug(`[${functionTag}] Dynamic model resolution failed, using static fallback`, {
-                            error: resolveError instanceof Error
-                                ? resolveError.message
-                                : String(resolveError),
-                        });
-                        // Continue with static model name - no functionality loss
-                    }
-                }
-                else {
-                    logger.debug(`[${functionTag}] Skipping dynamic model resolution`, {
-                        resolvedModelName: resolvedModelName || "none",
-                        reason: "Model already resolved from environment variables or explicit parameter",
-                    });
-                }
-                // CRITICAL FIX: Initialize providers before using them
-                await withTimeout(ProviderRegistry.registerAllProviders(), 30_000, new Error("Provider registration timed out"));
-                // PURE FACTORY PATTERN: No switch statements - use ProviderFactory exclusively
-                const normalizedName = this.normalizeProviderName(providerName);
-                const finalModelName = resolvedModelName === "default" || resolvedModelName === null
-                    ? undefined
-                    : resolvedModelName;
-                logger.debug(`[${functionTag}] Final provider configuration`, {
-                    originalProviderName: providerName,
-                    normalizedProviderName: normalizedName,
-                    originalModelName: modelName || "not provided",
-                    resolvedModelName: resolvedModelName || "not resolved",
-                    finalModelName: finalModelName || "using provider default",
-                });
-                // Create provider with enhanced SDK and region support
-                const provider = await withTimeout(ProviderFactory.createProvider(normalizedName, finalModelName, sdk, region), 30_000, new Error(`Provider creation timed out for ${normalizedName}`));
+                let resolvedModelName = this.resolveModelFromEnvironment(providerName, modelName, functionTag);
+                resolvedModelName = await this.resolveDynamicModelName(providerName, modelName, resolvedModelName, functionTag);
+                const { normalizedName, finalModelName, provider } = await this.createResolvedProvider(providerName, resolvedModelName, sdk, region, functionTag);
                 // Summary logging in format expected by debugging tools
                 logger.debug(`[AIProviderFactory] Provider creation completed { providerName: '${normalizedName}', modelName: '${finalModelName}' }`);
                 logger.debug(`[AIProviderFactory] Resolved model: ${finalModelName}`);

package/dist/lib/core/modules/GenerationHandler.js

@@ -95,6 +95,7 @@ export class GenerationHandler {
                 };
             }
         }
+        const prepareStep = options.prepareStep;
         return await generateText({
             model,
             messages,
@@ -103,8 +104,8 @@ export class GenerationHandler {
             stopWhen: stepCountIs(options.maxSteps ?? DEFAULT_MAX_STEPS),
             ...(shouldUseTools &&
                 options.toolChoice && { toolChoice: options.toolChoice }),
-            ...(options.prepareStep && {
-                experimental_prepareStep: ((stepOptions) => options.prepareStep({
+            ...(prepareStep && {
+                experimental_prepareStep: ((stepOptions) => prepareStep({
                     ...stepOptions,
                     maxSteps: options.maxSteps ?? DEFAULT_MAX_STEPS,
                 })),

package/dist/lib/core/redisConversationMemoryManager.js

@@ -16,6 +16,7 @@ import { runWithCurrentLangfuseContext } from "../services/server/ai/observabili
 import { logger } from "../utils/logger.js";
 import { createRedisClient, deserializeConversation, getNormalizedConfig, getPooledRedisClient, getSessionKey, getUserSessionsKey, releasePooledRedisClient, scanKeys, serializeConversation, } from "../utils/redis.js";
 const redisTracer = tracers.redis;
+const REDIS_TIMEOUT_MS = 5000;
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
@@ -130,13 +131,14 @@ export class RedisConversationMemoryManager {
         if (!this.redisClient) {
             return undefined;
         }
+        const redisClient = this.redisClient;
         return redisTracer.startActiveSpan("neurolink.memory.getSession", { kind: SpanKind.CLIENT, attributes: { "session.id": sessionId } }, async (span) => {
             if (userId) {
                 span.setAttribute("user.id", userId);
             }
             try {
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
-                const conversationData = await this.redisClient.get(redisKey);
+                const conversationData = await withTimeout(redisClient.get(redisKey), REDIS_TIMEOUT_MS);
                 const conversation = deserializeConversation(conversationData || null);
                 if (!conversation) {
                     span.setAttribute("session.found", false);
@@ -630,6 +632,7 @@ export class RedisConversationMemoryManager {
             logger.warn("[RedisConversationMemoryManager] Redis client not available in buildContextMessages");
             return [];
         }
+        const redisClient = this.redisClient;
         // NLK-GAP-012: Add span for buildContext CRUD operation
         return redisTracer.startActiveSpan("neurolink.memory.buildContext", {
             kind: SpanKind.CLIENT,
@@ -645,7 +648,7 @@ export class RedisConversationMemoryManager {
                     method: "buildContextMessages",
                 });
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
-                const conversationData = await this.redisClient.get(redisKey);
+                const conversationData = await withTimeout(redisClient.get(redisKey), REDIS_TIMEOUT_MS);
                 const conversation = deserializeConversation(conversationData || null);
                 if (!conversation) {
                     span.setAttribute("session.found", false);
@@ -1080,6 +1083,7 @@ User message: "${userMessage}"`;
         if (!this.redisClient) {
             return false;
         }
+        const redisClient = this.redisClient;
         // NLK-GAP-012: Add span for clearSession CRUD operation
         return redisTracer.startActiveSpan("neurolink.memory.clear", {
             kind: SpanKind.CLIENT,
@@ -1090,7 +1094,7 @@ User message: "${userMessage}"`;
         }, async (span) => {
             try {
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
-                const result = await this.redisClient.del(redisKey);
+                const result = await withTimeout(redisClient.del(redisKey), REDIS_TIMEOUT_MS);
                 if (Number(result) > 0) {
                     // Remove session from user's session set
                     if (userId) {

package/dist/lib/evaluation/BatchEvaluator.js

@@ -6,6 +6,9 @@ import { Evaluator } from "./index.js";
 import { createBatchEvaluationError, isRetryableEvaluationError, } from "./errors/EvaluationError.js";
 import { logger } from "../utils/logger.js";
 import { NeuroLinkFeatureError } from "../core/infrastructure/index.js";
+function hasEvaluationData(result) {
+    return result.success && result.data !== undefined;
+}
 /**
  * BatchEvaluator - Performs evaluation on multiple items in parallel.
  * Supports configurable concurrency, retry logic, and progress tracking.
@@ -201,7 +204,7 @@ export class BatchEvaluator {
             }
         }
         // Calculate summary statistics
-        const successfulResults = results.filter((r) => r.success && r.data);
+        const successfulResults = results.filter(hasEvaluationData);
         const scores = successfulResults.map((r) => r.data.overall);
         const passingScores = successfulResults.filter((r) => r.data.overall >=
             (autoEvalConfig.threshold || this.config.threshold || 7));

package/dist/lib/evaluation/hooks/observabilityHooks.js

@@ -41,10 +41,12 @@ export class ObservabilityHooks {
      * Register an event handler
      */
     on(event, handler) {
-        if (!this._handlers.has(event)) {
-            this._handlers.set(event, new Set());
+        let handlers = this._handlers.get(event);
+        if (!handlers) {
+            handlers = new Set();
+            this._handlers.set(event, handlers);
         }
-        this._handlers.get(event).add(handler);
+        handlers.add(handler);
         // Return unsubscribe function
         return () => {
             this._handlers.get(event)?.delete(handler);

package/dist/lib/evaluation/pipeline/evaluationPipeline.d.ts

@@ -12,9 +12,9 @@ export type PipelineExecutionOptions = {
     correlationId?: string;
     /** Custom timeout override */
     timeout?: number;
-    /** Skip specific scorers */
+    /** Skip specific scorers. Mutually exclusive with onlyScorers. */
     skipScorers?: string[];
-    /** Only run specific scorers */
+    /** Only run specific scorers. Mutually exclusive with skipScorers. */
     onlyScorers?: string[];
     /** Additional metadata to attach */
     metadata?: JsonObject;
@@ -59,6 +59,7 @@ export declare class EvaluationPipeline {
      * Execute the pipeline on input
      */
     execute(input: ScorerInput, options?: PipelineExecutionOptions): Promise<PipelineResult>;
+    private _validateExecutionOptions;
     /**
      * Get scorers to run based on options
      */

package/dist/lib/evaluation/pipeline/evaluationPipeline.js

@@ -3,7 +3,7 @@
  * Multi-scorer orchestration with configurable execution
  */
 import { logger } from "../../utils/logger.js";
-import { withTimeout } from "../../utils/errorHandling.js";
+import { ErrorFactory, withTimeout } from "../../utils/errorHandling.js";
 import { DEFAULT_SCORE_SCALE } from "../scorers/baseScorer.js";
 import { ScorerRegistry } from "../scorers/scorerRegistry.js";
 /**
@@ -91,6 +91,7 @@ export class EvaluationPipeline {
         if (!this._initialized) {
             await this.initialize();
         }
+        this._validateExecutionOptions(options);
         const startTime = Date.now();
         const correlationId = options?.correlationId ?? `pipeline-${Date.now()}`;
         logger.debug(`Executing pipeline: ${this._config.name ?? "unnamed"}`, {
@@ -173,16 +174,28 @@ export class EvaluationPipeline {
             skippedScorers,
         };
     }
+    _validateExecutionOptions(options) {
+        const hasOnlyScorers = !!options?.onlyScorers && options.onlyScorers.length > 0;
+        const hasSkipScorers = !!options?.skipScorers && options.skipScorers.length > 0;
+        if (hasOnlyScorers && hasSkipScorers) {
+            throw ErrorFactory.invalidConfiguration("evaluation pipeline execution options", "Cannot specify both 'onlyScorers' and 'skipScorers' options", {
+                onlyScorers: options?.onlyScorers,
+                skipScorers: options?.skipScorers,
+            });
+        }
+    }
     /**
      * Get scorers to run based on options
      */
     _getScorersToRun(options) {
         const allScorers = Array.from(this._scorers.entries());
-        if (options?.onlyScorers && options.onlyScorers.length > 0) {
-            return allScorers.filter(([id]) => options.onlyScorers.includes(id));
+        const onlyScorers = options?.onlyScorers;
+        const skipScorers = options?.skipScorers;
+        if (onlyScorers && onlyScorers.length > 0) {
+            return allScorers.filter(([id]) => onlyScorers.includes(id));
         }
-        if (options?.skipScorers && options.skipScorers.length > 0) {
-            return allScorers.filter(([id]) => !options.skipScorers.includes(id));
+        if (skipScorers && skipScorers.length > 0) {
+            return allScorers.filter(([id]) => !skipScorers.includes(id));
         }
         return allScorers;
     }
@@ -191,11 +204,13 @@ export class EvaluationPipeline {
      */
     _getSkippedScorers(options) {
         const allIds = Array.from(this._scorers.keys());
-        if (options?.onlyScorers && options.onlyScorers.length > 0) {
-            return allIds.filter((id) => !options.onlyScorers.includes(id));
+        const onlyScorers = options?.onlyScorers;
+        const skipScorers = options?.skipScorers;
+        if (onlyScorers && onlyScorers.length > 0) {
+            return allIds.filter((id) => !onlyScorers.includes(id));
         }
-        if (options?.skipScorers && options.skipScorers.length > 0) {
-            return options.skipScorers.filter((id) => allIds.includes(id));
+        if (skipScorers && skipScorers.length > 0) {
+            return skipScorers.filter((id) => allIds.includes(id));
         }
         return [];
     }

package/dist/lib/evaluation/pipeline/strategies/batchStrategy.js

@@ -2,6 +2,9 @@
  * @file Batch Strategy
  * Batch processing for evaluation pipelines
  */
+function hasPipelineResult(result) {
+    return !result.error && result.result !== undefined;
+}
 /**
  * Default batch configuration
  */
@@ -66,7 +69,7 @@ export class BatchStrategy {
         }
         // Calculate summary
         const totalDuration = Date.now() - startTime;
-        const successfulResults = results.filter((r) => !r.error && r.result);
+        const successfulResults = results.filter(hasPipelineResult);
         const scores = successfulResults.map((r) => r.result.overallScore);
         const passed = successfulResults.filter((r) => r.result.passed);
         return {
@@ -192,7 +195,7 @@ export async function* streamBatchEvaluation(pipeline, inputs, config) {
             durations.push(result.duration);
             // If continueOnError is false and this result has an error, abort and return summary
             if (result.error && batchConfig.continueOnError === false) {
-                const successfulResults = results.filter((r) => !r.error && r.result);
+                const successfulResults = results.filter(hasPipelineResult);
                 const earlyScores = successfulResults.map((r) => r.result.overallScore);
                 const earlyPassed = successfulResults.filter((r) => r.result.passed);
                 return {
@@ -219,7 +222,7 @@ export async function* streamBatchEvaluation(pipeline, inputs, config) {
         }
     }
     // Return summary
-    const successfulResults = results.filter((r) => !r.error && r.result);
+    const successfulResults = results.filter(hasPipelineResult);
     const scores = successfulResults.map((r) => r.result.overallScore);
     const passed = successfulResults.filter((r) => r.result.passed);
     return {

package/dist/lib/evaluation/pipeline/strategies/samplingStrategy.js

@@ -17,6 +17,12 @@ export const DEFAULT_SAMPLING_CONFIG = {
         maxRate: 1.0,
     },
 };
+const DEFAULT_ADAPTIVE_CONFIG = {
+    enabled: false,
+    qualityThreshold: 0.7,
+    minRate: 0.1,
+    maxRate: 1.0,
+};
 /**
  * Sampling strategy for evaluation
  */
@@ -27,9 +33,10 @@ export class SamplingStrategy {
     _maxRecentScores = 100;
     constructor(config = {}) {
         const clamp01 = (v) => Math.max(0, Math.min(1, v));
+        const defaultAdaptive = DEFAULT_SAMPLING_CONFIG.adaptive ?? DEFAULT_ADAPTIVE_CONFIG;
         const rawRate = config.rate ?? DEFAULT_SAMPLING_CONFIG.rate;
-        const rawMinRate = config.adaptive?.minRate ?? DEFAULT_SAMPLING_CONFIG.adaptive.minRate;
-        const rawMaxRate = config.adaptive?.maxRate ?? DEFAULT_SAMPLING_CONFIG.adaptive.maxRate;
+        const rawMinRate = config.adaptive?.minRate ?? defaultAdaptive.minRate;
+        const rawMaxRate = config.adaptive?.maxRate ?? defaultAdaptive.maxRate;
         const minRate = clamp01(Math.min(rawMinRate, rawMaxRate));
         const maxRate = clamp01(Math.max(rawMinRate, rawMaxRate));
         this._config = {
@@ -41,9 +48,8 @@ export class SamplingStrategy {
                 ...(config.alwaysEvaluate ?? {}),
             },
             adaptive: {
-                enabled: config.adaptive?.enabled ?? DEFAULT_SAMPLING_CONFIG.adaptive.enabled,
-                qualityThreshold: clamp01(config.adaptive?.qualityThreshold ??
-                    DEFAULT_SAMPLING_CONFIG.adaptive.qualityThreshold),
+                enabled: config.adaptive?.enabled ?? defaultAdaptive.enabled,
+                qualityThreshold: clamp01(config.adaptive?.qualityThreshold ?? defaultAdaptive.qualityThreshold),
                 minRate,
                 maxRate,
             },
@@ -156,9 +162,12 @@ export class SamplingStrategy {
      */
     configure(config) {
         const clamp01 = (v) => Math.max(0, Math.min(1, v));
+        const currentAdaptive = this._config.adaptive ??
+            DEFAULT_SAMPLING_CONFIG.adaptive ??
+            DEFAULT_ADAPTIVE_CONFIG;
         const rawRate = config.rate ?? this._config.rate;
-        const rawMinRate = config.adaptive?.minRate ?? this._config.adaptive.minRate;
-        const rawMaxRate = config.adaptive?.maxRate ?? this._config.adaptive.maxRate;
+        const rawMinRate = config.adaptive?.minRate ?? currentAdaptive.minRate;
+        const rawMaxRate = config.adaptive?.maxRate ?? currentAdaptive.maxRate;
         const minRate = clamp01(Math.min(rawMinRate, rawMaxRate));
         const maxRate = clamp01(Math.max(rawMinRate, rawMaxRate));
         this._config = {
@@ -170,9 +179,8 @@ export class SamplingStrategy {
                 ...(config.alwaysEvaluate ?? {}),
             },
             adaptive: {
-                enabled: config.adaptive?.enabled ?? this._config.adaptive.enabled,
-                qualityThreshold: clamp01(config.adaptive?.qualityThreshold ??
-                    this._config.adaptive.qualityThreshold),
+                enabled: config.adaptive?.enabled ?? currentAdaptive.enabled,
+                qualityThreshold: clamp01(config.adaptive?.qualityThreshold ?? currentAdaptive.qualityThreshold),
                 minRate,
                 maxRate,
             },

package/dist/lib/evaluation/scorers/scorerRegistry.d.ts

@@ -19,6 +19,9 @@ export declare class ScorerRegistry {
      * Register a scorer using a simple configuration
      */
     static registerScorer(metadata: ScorerMetadata, factory: ScorerFactory, aliases?: string[]): void;
+    private static registerScorerDefinitions;
+    private static registerBuiltInLLMScorers;
+    private static registerBuiltInRuleScorers;
     /**
      * Register built-in scorers using dynamic imports
      */