@juspay/neurolink 7.44.0 → 7.46.0

package/dist/lib/evaluation/ragasEvaluator.js

@@ -0,0 +1,90 @@
+import { AIProviderFactory } from "../core/factory.js";
+import { PromptBuilder } from "./prompts.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Implements a RAGAS-style evaluator that uses a "judge" LLM to score the
+ * quality of an AI response based on rich, contextual information.
+ */
+export class RAGASEvaluator {
+    evaluationModel;
+    providerName;
+    threshold;
+    promptBuilder;
+    promptGenerator;
+    constructor(evaluationModel, providerName, threshold, promptGenerator) {
+        this.evaluationModel =
+            evaluationModel ||
+                process.env.NEUROLINK_RAGAS_EVALUATION_MODEL ||
+                "gemini-1.5-flash";
+        this.providerName =
+            providerName ||
+                process.env.NEUROLINK_RAGAS_EVALUATION_PROVIDER ||
+                "vertex";
+        this.threshold =
+            threshold || Number(process.env.NEUROLINK_EVALUATION_THRESHOLD) || 7;
+        this.promptBuilder = new PromptBuilder();
+        this.promptGenerator = promptGenerator;
+    }
+    /**
+     * Evaluates an AI-generated response using a model-based approach.
+     *
+     * @param context The rich, contextual information for the evaluation.
+     * @returns A promise that resolves to a detailed `EvaluationResult`.
+     */
+    async evaluate(context) {
+        const startTime = Date.now();
+        const prompt = this.promptBuilder.buildEvaluationPrompt(context, this.promptGenerator);
+        const provider = await AIProviderFactory.createProvider(this.providerName, this.evaluationModel);
+        const result = await provider.generate({
+            input: { text: prompt },
+        });
+        if (!result) {
+            throw new Error("Evaluation generation failed to return a result.");
+        }
+        const rawEvaluationResponse = result.content;
+        const parsedResult = this.parseEvaluationResponse(rawEvaluationResponse);
+        const evaluationTime = Date.now() - startTime;
+        const finalResult = {
+            ...parsedResult,
+            isPassing: parsedResult.finalScore >= this.threshold, // This will be recalculated, but is needed for the type
+            evaluationModel: this.evaluationModel,
+            evaluationTime,
+            attemptNumber: context.attemptNumber,
+            rawEvaluationResponse,
+        };
+        return finalResult;
+    }
+    /**
+     * Parses the raw JSON string from the judge LLM into a structured `EvaluationResult` object.
+     * It includes error handling to gracefully manage malformed JSON.
+     *
+     * @param rawResponse The raw string response from the evaluation model.
+     * @returns A structured object containing the evaluation scores and feedback.
+     */
+    parseEvaluationResponse(rawResponse) {
+        try {
+            const cleanedResponse = rawResponse.replace(/```json\n|```/g, "").trim();
+            const parsed = JSON.parse(cleanedResponse);
+            logger.debug("Parsed evaluation response for RAGAS Evaluator:", parsed);
+            return {
+                relevanceScore: Number(parsed.relevanceScore) || 0,
+                accuracyScore: Number(parsed.accuracyScore) || 0,
+                completenessScore: Number(parsed.completenessScore) || 0,
+                finalScore: Number(parsed.finalScore) || 0,
+                suggestedImprovements: parsed.suggestedImprovements || "No suggestions provided.",
+                reasoning: parsed.reasoning || "No reasoning provided.",
+            };
+        }
+        catch (error) {
+            logger.error("Failed to parse evaluation response:", error);
+            return {
+                relevanceScore: 0,
+                accuracyScore: 0,
+                completenessScore: 0,
+                finalScore: 0,
+                reasoning: "Error parsing evaluation response.",
+                suggestedImprovements: "Error parsing evaluation response.",
+            };
+        }
+    }
+}

package/dist/lib/evaluation/retryManager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @file Implements the RetryManager class for handling evaluation retries.
+ */
+import type { EvaluationResult } from "../types/evaluationTypes.js";
+import type { TextGenerationOptions } from "../types/generateTypes.js";
+/**
+ * Manages the retry logic for the auto-evaluation middleware. It decides if a
+ * retry is warranted based on the evaluation score and prepares the options
+ * for the next generation attempt by incorporating feedback into the prompt.
+ */
+export declare class RetryManager {
+    private maxRetries;
+    constructor(maxRetries?: number);
+    /**
+     * Determines if a retry should be attempted based on the evaluation result.
+     *
+     * @param evaluation The `EvaluationResult` of the last attempt.
+     * @returns `true` if the response did not pass and the maximum number of retries has not been reached.
+     */
+    shouldRetry(evaluation: EvaluationResult): boolean;
+    /**
+     * Prepares the options for the next generation attempt by creating a new,
+     * improved prompt that includes feedback from the failed evaluation.
+     *
+     * @param originalOptions The original `TextGenerationOptions` from the user request.
+     * @param evaluation The `EvaluationResult` of the failed attempt.
+     * @returns A new `TextGenerationOptions` object with an improved prompt.
+     */
+    prepareRetryOptions(originalOptions: TextGenerationOptions, evaluation: EvaluationResult): TextGenerationOptions;
+    /**
+     * Builds a new prompt for a retry attempt by incorporating feedback from the
+     * evaluation. The instructions become progressively more direct with each attempt.
+     *
+     * @param originalPrompt The user's original prompt.
+     * @param feedback The constructive feedback from the evaluation.
+     * @param attemptNumber The upcoming attempt number (e.g., 2 for the first retry).
+     * @returns A new, enhanced prompt string.
+     */
+    private buildRetryPrompt;
+}

package/dist/lib/evaluation/retryManager.js

@@ -0,0 +1,78 @@
+/**
+ * @file Implements the RetryManager class for handling evaluation retries.
+ */
+/**
+ * Manages the retry logic for the auto-evaluation middleware. It decides if a
+ * retry is warranted based on the evaluation score and prepares the options
+ * for the next generation attempt by incorporating feedback into the prompt.
+ */
+export class RetryManager {
+    maxRetries;
+    constructor(maxRetries = 2) {
+        // Total 3 attempts: 1 initial + 2 retries
+        this.maxRetries = maxRetries;
+    }
+    /**
+     * Determines if a retry should be attempted based on the evaluation result.
+     *
+     * @param evaluation The `EvaluationResult` of the last attempt.
+     * @returns `true` if the response did not pass and the maximum number of retries has not been reached.
+     */
+    shouldRetry(evaluation) {
+        // Attempt number is 1-based. If attempt 1 fails, we can retry.
+        // If attempt 3 (maxRetries + 1) fails, we stop.
+        return !evaluation.isPassing && evaluation.attemptNumber <= this.maxRetries;
+    }
+    /**
+     * Prepares the options for the next generation attempt by creating a new,
+     * improved prompt that includes feedback from the failed evaluation.
+     *
+     * @param originalOptions The original `TextGenerationOptions` from the user request.
+     * @param evaluation The `EvaluationResult` of the failed attempt.
+     * @returns A new `TextGenerationOptions` object with an improved prompt.
+     */
+    prepareRetryOptions(originalOptions, evaluation) {
+        const originalPrompt = originalOptions.prompt || originalOptions.input?.text || "";
+        const newPrompt = this.buildRetryPrompt(originalPrompt, evaluation.suggestedImprovements, evaluation.attemptNumber + 1);
+        // Return a new options object with the updated prompt
+        return {
+            ...originalOptions,
+            prompt: newPrompt,
+            // Ensure input is not carried over if prompt is now the source of truth
+            input: undefined,
+            // Carry over the original prompt for context in subsequent retries if needed
+            originalPrompt: originalOptions.originalPrompt || originalPrompt,
+        };
+    }
+    /**
+     * Builds a new prompt for a retry attempt by incorporating feedback from the
+     * evaluation. The instructions become progressively more direct with each attempt.
+     *
+     * @param originalPrompt The user's original prompt.
+     * @param feedback The constructive feedback from the evaluation.
+     * @param attemptNumber The upcoming attempt number (e.g., 2 for the first retry).
+     * @returns A new, enhanced prompt string.
+     */
+    buildRetryPrompt(originalPrompt, feedback, attemptNumber) {
+        let instruction = "";
+        switch (attemptNumber) {
+            case 2: // First retry
+                instruction = `The previous response was not satisfactory. Please improve it based on the following feedback: "${feedback}".`;
+                break;
+            case 3: // Second retry
+                instruction = `The last response still requires improvement. Pay close attention to this feedback: "${feedback}". You MUST address these points.`;
+                break;
+            default: // Final retry or unexpected attempt number
+                instruction = `This is the final attempt. You MUST address the following feedback to generate a satisfactory response: "${feedback}".`;
+                break;
+        }
+        return `
+    Original Request: ${originalPrompt}
+
+    **Correction Instructions:**
+    ${instruction}
+
+    Generate a new, complete response that incorporates this feedback.
+  `;
+    }
+}

package/dist/lib/evaluation/scoring.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @file Contains the logic for mapping raw evaluation results to the structured EvaluationData type.
+ */
+import type { EnhancedEvaluationContext, EvaluationResult } from "../types/evaluationTypes.js";
+import type { EvaluationData } from "../types/evaluation.js";
+/**
+ * Maps a raw `EvaluationResult` to the structured `EvaluationData` format.
+ * This includes calculating derived fields like `isOffTopic` and `alertSeverity`.
+ *
+ * @param result The raw `EvaluationResult` from the evaluator.
+ * @param threshold The score threshold to determine if the evaluation is passing.
+ * @param offTopicThreshold The score below which a response is considered off-topic.
+ * @param highSeverityThreshold The score below which a failing response is high severity.
+ * @returns A structured `EvaluationData` object.
+ */
+export declare function mapToEvaluationData(evalContext: EnhancedEvaluationContext, result: EvaluationResult, threshold: number, offTopicThreshold?: number, highSeverityThreshold?: number): EvaluationData;

package/dist/lib/evaluation/scoring.js

@@ -0,0 +1,35 @@
+/**
+ * @file Contains the logic for mapping raw evaluation results to the structured EvaluationData type.
+ */
+/**
+ * Maps a raw `EvaluationResult` to the structured `EvaluationData` format.
+ * This includes calculating derived fields like `isOffTopic` and `alertSeverity`.
+ *
+ * @param result The raw `EvaluationResult` from the evaluator.
+ * @param threshold The score threshold to determine if the evaluation is passing.
+ * @param offTopicThreshold The score below which a response is considered off-topic.
+ * @param highSeverityThreshold The score below which a failing response is high severity.
+ * @returns A structured `EvaluationData` object.
+ */
+export function mapToEvaluationData(evalContext, result, threshold, offTopicThreshold = 5, highSeverityThreshold = 4) {
+    const isPassing = result.finalScore >= threshold;
+    return {
+        relevance: result.relevanceScore,
+        accuracy: result.accuracyScore,
+        completeness: result.completenessScore,
+        overall: result.finalScore,
+        isOffTopic: result.finalScore < offTopicThreshold,
+        alertSeverity: isPassing
+            ? "none"
+            : result.finalScore < highSeverityThreshold
+                ? "high"
+                : "medium",
+        reasoning: result.reasoning,
+        suggestedImprovements: result.suggestedImprovements,
+        evaluationModel: result.evaluationModel,
+        evaluationTime: result.evaluationTime,
+        evaluationAttempt: result.attemptNumber,
+        responseContent: evalContext.aiResponse,
+        queryContent: evalContext.userQuery,
+    };
+}

package/dist/lib/factories/providerFactory.d.ts

@@ -4,8 +4,8 @@ import type { UnknownRecord } from "../types/common.js";
  * Provider constructor interface - supports both sync constructors and async factory functions
  */
 type ProviderConstructor = {
-    new (modelName?: string, providerName?: string, sdk?: UnknownRecord): AIProvider;
-} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord) => Promise<AIProvider>);
+    new (modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string): AIProvider;
+} | ((modelName?: string, providerName?: string, sdk?: UnknownRecord, region?: string) => Promise<AIProvider>);
 /**
  * Provider registration entry
  */
@@ -30,7 +30,7 @@ export declare class ProviderFactory {
     /**
      * Create a provider instance
      */
-    static createProvider(providerName: AIProviderName | string, modelName?: string, sdk?: UnknownRecord): Promise<AIProvider>;
+    static createProvider(providerName: AIProviderName | string, modelName?: string, sdk?: UnknownRecord, region?: string): Promise<AIProvider>;
     /**
      * Check if a provider is registered
      */

package/dist/lib/factories/providerFactory.js

@@ -28,7 +28,7 @@ export class ProviderFactory {
     /**
      * Create a provider instance
      */
-    static async createProvider(providerName, modelName, sdk) {
+    static async createProvider(providerName, modelName, sdk, region) {
         // Note: Providers are registered explicitly by ProviderRegistry to avoid circular dependencies
         const normalizedName = providerName.toLowerCase();
         const registration = this.providers.get(normalizedName);
@@ -54,7 +54,7 @@ export class ProviderFactory {
             }
             let result;
             try {
-                const factoryResult = registration.constructor(model, providerName, sdk);
+                const factoryResult = registration.constructor(model, providerName, sdk, region);
                 // Handle both sync and async results
                 result =
                     factoryResult instanceof Promise
@@ -66,7 +66,7 @@ export class ProviderFactory {
                     registration.constructor.prototype.constructor ===
                         registration.constructor) {
                     try {
-                        result = new registration.constructor(model, providerName, sdk);
+                        result = new registration.constructor(model, providerName, sdk, region);
                     }
                     catch (constructorError) {
                         throw new Error(`Both factory function and constructor failed. Factory error: ${factoryError}. Constructor error: ${constructorError}`);

package/dist/lib/factories/providerRegistry.js

@@ -39,9 +39,9 @@ export class ProviderRegistry {
                 return new AnthropicProvider(modelName, sdk);
             }, "claude-3-5-sonnet-20241022", ["claude", "anthropic"]);
             // Register Amazon Bedrock provider
-            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName, _providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName, _providerName, sdk, region) => {
                 const { AmazonBedrockProvider } = await import("../providers/amazonBedrock.js");
-                return new AmazonBedrockProvider(modelName, sdk);
+                return new AmazonBedrockProvider(modelName, sdk, region);
             }, undefined, // Let provider read BEDROCK_MODEL from .env
             ["bedrock", "aws"]);
             // Register Azure OpenAI provider
@@ -54,9 +54,9 @@ export class ProviderRegistry {
                 process.env.AZURE_OPENAI_DEPLOYMENT_ID ||
                 "gpt-4o-mini", ["azure", "azureOpenai"]);
             // Register Google Vertex AI provider
-            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName, providerName, sdk, region) => {
                 const { GoogleVertexProvider } = await import("../providers/googleVertex.js");
-                return new GoogleVertexProvider(modelName, providerName, sdk);
+                return new GoogleVertexProvider(modelName, providerName, sdk, region);
             }, "claude-sonnet-4@20250514", ["vertex", "googleVertex"]);
             // Register Hugging Face provider (Unified Router implementation)
             ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName) => {
@@ -85,9 +85,9 @@ export class ProviderRegistry {
             }, process.env.OPENAI_COMPATIBLE_MODEL || undefined, // Enable auto-discovery when no model specified
             ["openai-compatible", "openrouter", "vllm", "compatible"]);
             // Register Amazon SageMaker provider
-            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, _providerName, _sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, _providerName, _sdk, region) => {
                 const { AmazonSageMakerProvider } = await import("../providers/amazonSagemaker.js");
-                return new AmazonSageMakerProvider(modelName);
+                return new AmazonSageMakerProvider(modelName, region);
             }, process.env.SAGEMAKER_MODEL || "sagemaker-model", ["sagemaker", "aws-sagemaker"]);
             logger.debug("All providers registered successfully");
             this.registered = true;

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

@@ -0,0 +1,14 @@
+/**
+ * @file Implements the Auto-Evaluation Middleware for ensuring response quality.
+ */
+import type { NeuroLinkMiddleware, AutoEvaluationConfig } from "../../types/middlewareTypes.js";
+/**
+ * Creates the Auto-Evaluation middleware, which intercepts generation requests
+ * to evaluate the quality of the response. If the response quality is below a
+ * configured threshold, it can trigger retries with feedback.
+ *
+ * @param config - Configuration for the auto-evaluation middleware.
+ * @returns A `NeuroLinkMiddleware` object.
+ */
+export declare function createAutoEvaluationMiddleware(config?: AutoEvaluationConfig): NeuroLinkMiddleware;
+export default createAutoEvaluationMiddleware;

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

@@ -0,0 +1,181 @@
+/**
+ * @file Implements the Auto-Evaluation Middleware for ensuring response quality.
+ */
+import { Evaluator } from "../../evaluation/index.js";
+import { logger } from "../../utils/logger.js";
+/**
+ * Creates the Auto-Evaluation middleware, which intercepts generation requests
+ * to evaluate the quality of the response. If the response quality is below a
+ * configured threshold, it can trigger retries with feedback.
+ *
+ * @param config - Configuration for the auto-evaluation middleware.
+ * @returns A `NeuroLinkMiddleware` object.
+ */
+export function createAutoEvaluationMiddleware(config = {}) {
+    const metadata = {
+        id: "autoEvaluation",
+        name: "Auto Evaluation",
+        description: "Automatically evaluates response quality and retries if needed.",
+        priority: 90,
+        defaultEnabled: false, // Should be explicitly enabled
+    };
+    logger.debug("Auto-Evaluation Middleware Config:", config);
+    const middleware = {
+        wrapGenerate: async ({ doGenerate, params }) => {
+            const options = params;
+            const rawResult = await doGenerate();
+            const result = {
+                ...rawResult,
+                content: rawResult.text ?? "",
+                usage: {
+                    input: rawResult.usage.promptTokens,
+                    output: rawResult.usage.completionTokens,
+                    total: rawResult.usage.promptTokens + rawResult.usage.completionTokens,
+                },
+                toolCalls: rawResult.toolCalls?.map((tc) => {
+                    let parsedArgs = tc.args;
+                    if (typeof tc.args === "string") {
+                        try {
+                            parsedArgs = JSON.parse(tc.args);
+                        }
+                        catch (e) {
+                            logger.warn(`Failed to parse tool call args for tool ${tc.toolName}:`, e);
+                            parsedArgs = tc.args; // Fallback to original string if parsing fails
+                        }
+                    }
+                    return {
+                        ...tc,
+                        args: parsedArgs,
+                    };
+                }),
+            };
+            const isBlocking = config.blocking !== false;
+            if (isBlocking) {
+                const evaluationResult = await performEvaluation(config, options, result);
+                return {
+                    ...rawResult,
+                    evaluationResult,
+                };
+            }
+            else {
+                performEvaluation(config, options, result).catch((err) => {
+                    logger.error("Non-blocking auto-evaluation error:", err);
+                });
+                return rawResult;
+            }
+        },
+        wrapStream: async ({ doStream, params }) => {
+            const options = params;
+            const rawResult = await doStream();
+            const [streamForUser, streamForEvaluation] = rawResult.stream.tee();
+            // Non-blocking evaluation for streams
+            consumeAndEvaluateStream(config, options, streamForEvaluation).catch((err) => {
+                logger.error("Non-blocking stream auto-evaluation error:", err);
+            });
+            return {
+                ...rawResult,
+                stream: streamForUser,
+            };
+        },
+    };
+    return {
+        ...middleware,
+        metadata,
+    };
+}
+/**
+ * A common function to perform the evaluation logic.
+ * @param config The middleware configuration.
+ * @param options The text generation options.
+ * @param result The generation result.
+ */
+async function performEvaluation(config, options, result) {
+    const isBlocking = config.blocking !== false;
+    const threshold = config.threshold ??
+        (Number(process.env.NEUROLINK_EVALUATION_THRESHOLD) || 7);
+    try {
+        const evaluator = new Evaluator({
+            threshold,
+            provider: config.provider,
+            promptGenerator: config.promptGenerator,
+            evaluationModel: config.evaluationModel,
+        });
+        const evaluationResult = await evaluator.evaluate(options, result, threshold, config);
+        if (config.onEvaluationComplete) {
+            await config.onEvaluationComplete(evaluationResult);
+        }
+    }
+    catch (error) {
+        logger.error("Error during auto-evaluation:", error);
+        if (isBlocking) {
+            throw error;
+        }
+    }
+}
+/**
+ * Consumes a stream to build the full response and then evaluates it.
+ * @param config The middleware configuration.
+ * @param options The generation options.
+ * @param stream The stream to consume.
+ */
+async function consumeAndEvaluateStream(config, options, stream) {
+    let fullText = "";
+    let usage;
+    const toolCalls = [];
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            switch (value.type) {
+                case "text-delta":
+                    fullText += value.textDelta;
+                    break;
+                case "tool-call":
+                    {
+                        let parsedArgs;
+                        try {
+                            parsedArgs = JSON.parse(value.args);
+                        }
+                        catch (e) {
+                            logger.warn(`Failed to parse tool call args for tool ${value.toolName}:`, e);
+                            // In case of parsing failure, we can't assign a string.
+                            // Let's use an object with the raw string to maintain type safety.
+                            parsedArgs = { raw: value.args };
+                        }
+                        toolCalls.push({
+                            toolCallId: value.toolCallId,
+                            toolName: value.toolName,
+                            args: parsedArgs,
+                        });
+                    }
+                    break;
+                case "finish":
+                    usage = {
+                        input: value.usage.promptTokens,
+                        output: value.usage.completionTokens,
+                        total: value.usage.promptTokens + value.usage.completionTokens,
+                    };
+                    break;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const result = {
+        content: fullText,
+        usage,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+    };
+    // For streams, evaluation is always non-blocking from the user's perspective.
+    if (config.blocking) {
+        logger.warn("Auto-evaluation 'blocking' mode is not supported for streaming responses. Evaluation will proceed non-blockingly.");
+    }
+    // Create a new config object to force non-blocking behavior for the evaluation function
+    const nonBlockingConfig = { ...config, blocking: false };
+    await performEvaluation(nonBlockingConfig, options, result);
+}
+export default createAutoEvaluationMiddleware;

package/dist/lib/middleware/factory.js

@@ -2,6 +2,7 @@ import { wrapLanguageModel } from "ai";
 import { MiddlewareRegistry } from "./registry.js";
 import { createAnalyticsMiddleware } from "./builtin/analytics.js";
 import { createGuardrailsMiddleware } from "./builtin/guardrails.js";
+import { createAutoEvaluationMiddleware } from "./builtin/autoEvaluation.js";
 import { logger } from "../utils/logger.js";
 /**
  * Middleware factory for creating and applying middleware chains.
@@ -24,6 +25,7 @@ export class MiddlewareFactory {
         const builtInMiddlewareCreators = {
             analytics: createAnalyticsMiddleware,
             guardrails: createGuardrailsMiddleware,
+            autoEvaluation: createAutoEvaluationMiddleware,
         };
         // Register built-in presets
         this.registerPreset({
@@ -54,6 +56,7 @@ export class MiddlewareFactory {
             if (!this.registry.has(middlewareId)) {
                 const creator = builtInMiddlewareCreators[middlewareId];
                 const config = options.middlewareConfig?.[middlewareId]?.config;
+                logger.debug(`Registering built-in middleware '${middlewareId}'`, config);
                 this.registry.register(creator(config));
             }
         }
@@ -92,6 +95,7 @@ export class MiddlewareFactory {
             const middlewareConfig = this.buildMiddlewareConfig(mergedOptions);
             // Re-register middleware with the correct configuration for this call
             for (const [id, config] of Object.entries(middlewareConfig)) {
+                logger.debug(`Configuring middleware '${id}'`, { config });
                 if (config.enabled && this.registry.has(id)) {
                     const creator = this.getCreator(id);
                     if (creator) {
@@ -137,7 +141,9 @@ export class MiddlewareFactory {
         const builtInMiddlewareCreators = {
             analytics: createAnalyticsMiddleware,
             guardrails: createGuardrailsMiddleware,
+            autoEvaluation: createAutoEvaluationMiddleware,
         };
+        logger.debug("Getting creator for middleware ID:", id);
         return builtInMiddlewareCreators[id];
     }
     /**

package/dist/lib/neurolink.js

@@ -1082,6 +1082,7 @@ export class NeuroLink {
             evaluationDomain: options.evaluationDomain,
             toolUsageContext: options.toolUsageContext,
             input: options.input, // This includes text, images, and content arrays
+            region: options.region,
         };
         // Apply factory enhancement using centralized utilities
         const textOptions = enhanceTextGenerationOptions(baseOptions, factoryResult);
@@ -1410,7 +1411,8 @@ export class NeuroLink {
             const conversationMessages = await getConversationMessages(this.conversationMemory, options);
             // Create provider and generate
             const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
-            this);
+            this, // Pass SDK instance
+            options.region);
             // ADD: Emit connection events for all providers (Bedrock-compatible)
             this.emitter.emit("connected");
             this.emitter.emit("message", `${providerName} provider initialized successfully`);
@@ -1520,7 +1522,8 @@ export class NeuroLink {
                 // Get conversation messages for context
                 const conversationMessages = await getConversationMessages(this.conversationMemory, options);
                 const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
-                this);
+                this, // Pass SDK instance
+                options.region);
                 // ADD: Emit connection events for successful provider creation (Bedrock-compatible)
                 this.emitter.emit("connected");
                 this.emitter.emit("message", `${providerName} provider initialized successfully`);
@@ -1897,7 +1900,8 @@ export class NeuroLink {
         // Simplified placeholder - in the actual implementation this would contain the complex MCP stream logic
         const providerName = await getBestProvider(options.provider);
         const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
-        this);
+        this, // Pass SDK instance
+        options.region);
         // Enable tool execution for the provider using BaseProvider method
         provider.setupToolExecutor({
             customTools: this.getCustomTools(),

package/dist/lib/providers/amazonBedrock.d.ts

@@ -6,7 +6,8 @@ import type { NeuroLink } from "../neurolink.js";
 export declare class AmazonBedrockProvider extends BaseProvider {
     private bedrockClient;
     private conversationHistory;
-    constructor(modelName?: string, neurolink?: NeuroLink);
+    private region;
+    constructor(modelName?: string, neurolink?: NeuroLink, region?: string);
     /**
      * Perform initial health check to catch credential/connectivity issues early
      * This prevents the health check failure we saw in production logs