@juspay/neurolink 9.42.0 → 9.43.0

package/dist/lib/core/factory.js

@@ -7,7 +7,7 @@ import { ProviderRegistry } from "../factories/providerRegistry.js";
 import { getBestProvider } from "../utils/providerUtils.js";
 import { logger } from "../utils/logger.js";
 import { dynamicModelProvider } from "./dynamicModels.js";
-import { withTimeout } from "../utils/errorHandling.js";
+import { withTimeout, ErrorFactory } from "../utils/errorHandling.js";
 import { AIProviderName } from "../constants/enums.js";
 const componentIdentifier = "aiProviderFactory";
 const factoryTracer = tracers.factory;
@@ -35,7 +35,7 @@ export class AIProviderFactory {
         const functionTag = "AIProviderFactory.initializeDynamicProviderWithTimeout";
         const INIT_TIMEOUT = 10000; // 10 seconds total timeout for initialization
         try {
-            await withTimeout(dynamicModelProvider.initialize(), INIT_TIMEOUT, new Error("Dynamic provider initialization timeout"));
+            await withTimeout(dynamicModelProvider.initialize(), INIT_TIMEOUT, ErrorFactory.toolTimeout("dynamic-provider-init", INIT_TIMEOUT));
             logger.debug(`[${functionTag}] Dynamic model provider initialized successfully`);
         }
         catch (error) {
@@ -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, ErrorFactory.toolTimeout("provider-registration", 30_000));
+        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, ErrorFactory.toolTimeout(`provider-creation:${normalizedName}`, 30_000));
+        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/ToolsManager.d.ts

@@ -35,6 +35,7 @@ export declare class ToolsManager {
      * Set session context for MCP tools
      */
     setSessionContext(sessionId?: string, userId?: string): void;
+    private emitToolEvent;
     /**
      * Set up tool executor for a provider to enable actual tool execution
      * @param sdk - The NeuroLinkSDK instance for tool execution

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

@@ -16,6 +16,7 @@
  */
 import { tool as createAISDKTool, jsonSchema } from "ai";
 import { z } from "zod";
+import { createToolEventPayload } from "../toolEvents.js";
 import { tracers, ATTR, withSpan } from "../../telemetry/index.js";
 import { SpanStatusCode } from "@opentelemetry/api";
 import { logger } from "../../utils/logger.js";
@@ -50,6 +51,13 @@ export class ToolsManager {
         this.sessionId = sessionId;
         this.userId = userId;
     }
+    emitToolEvent(eventName, toolName, payload) {
+        if (this.neurolink?.getEventEmitter) {
+            this.neurolink
+                .getEventEmitter()
+                .emit(eventName, createToolEventPayload(toolName, payload));
+        }
+    }
     /**
      * Set up tool executor for a provider to enable actual tool execution
      * @param sdk - The NeuroLinkSDK instance for tool execution
@@ -175,27 +183,24 @@ export class ToolsManager {
                 tools[toolName] = {
                     ...directTool,
                     execute: async (params) => {
-                        // 🔧 EMIT TOOL START EVENT - Bedrock-compatible format
-                        if (this.neurolink?.getEventEmitter) {
-                            const emitter = this.neurolink.getEventEmitter();
-                            emitter.emit("tool:start", { tool: toolName, input: params });
-                        }
+                        const startTime = Date.now();
+                        this.emitToolEvent("tool:start", toolName, { input: params });
                         try {
                             const result = await originalExecute(params);
-                            // 🔧 EMIT TOOL END EVENT - Bedrock-compatible format
-                            if (this.neurolink?.getEventEmitter) {
-                                const emitter = this.neurolink.getEventEmitter();
-                                emitter.emit("tool:end", { tool: toolName, result });
-                            }
+                            this.emitToolEvent("tool:end", toolName, {
+                                result,
+                                success: true,
+                                responseTime: Date.now() - startTime,
+                            });
                             return result;
                         }
                         catch (error) {
-                            // 🔧 EMIT TOOL END EVENT FOR ERROR - Bedrock-compatible format
-                            if (this.neurolink?.getEventEmitter) {
-                                const emitter = this.neurolink.getEventEmitter();
-                                const errorMsg = error instanceof Error ? error.message : String(error);
-                                emitter.emit("tool:end", { tool: toolName, error: errorMsg });
-                            }
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            this.emitToolEvent("tool:end", toolName, {
+                                error: errorMsg,
+                                success: false,
+                                responseTime: Date.now() - startTime,
+                            });
                             throw error;
                         }
                     },
@@ -443,48 +448,41 @@ export class ToolsManager {
                 description: tool.description || `External MCP tool ${tool.name}`,
                 inputSchema: finalSchema, // AI SDK v6 uses inputSchema (not parameters)
                 execute: async (params) => {
-                    // Emit tool start event
-                    if (this.neurolink?.getEventEmitter) {
-                        const emitter = this.neurolink.getEventEmitter();
-                        emitter.emit("tool:start", { tool: tool.name, input: params });
-                    }
+                    const startTime = Date.now();
+                    this.emitToolEvent("tool:start", tool.name, { input: params });
                     // Execute via NeuroLink's direct tool execution
                     if (this.neurolink &&
                         typeof this.neurolink.executeExternalMCPTool === "function") {
                         try {
                             const result = await this.neurolink.executeExternalMCPTool(tool.serverId || "unknown", tool.name, params);
-                            // Emit tool end event (success)
-                            if (this.neurolink?.getEventEmitter) {
-                                const emitter = this.neurolink.getEventEmitter();
-                                emitter.emit("tool:end", { tool: tool.name, result });
-                            }
+                            this.emitToolEvent("tool:end", tool.name, {
+                                result,
+                                success: true,
+                                responseTime: Date.now() - startTime,
+                            });
                             return result;
                         }
                         catch (mcpError) {
-                            // Emit tool end event (error)
-                            if (this.neurolink?.getEventEmitter) {
-                                const emitter = this.neurolink.getEventEmitter();
-                                const errorMsg = mcpError instanceof Error
-                                    ? mcpError.message
-                                    : String(mcpError);
-                                emitter.emit("tool:end", { tool: tool.name, error: errorMsg });
-                            }
+                            const errorMsg = mcpError instanceof Error ? mcpError.message : String(mcpError);
+                            this.emitToolEvent("tool:end", tool.name, {
+                                error: errorMsg,
+                                success: false,
+                                responseTime: Date.now() - startTime,
+                            });
                             logger.error(`External MCP tool failed: ${tool.name}`, {
                                 serverId: tool.serverId,
-                                error: mcpError instanceof Error
-                                    ? mcpError.message
-                                    : String(mcpError),
+                                error: errorMsg,
                             });
                             throw mcpError;
                         }
                     }
                     else {
                         const error = `Cannot execute external MCP tool: NeuroLink executeExternalMCPTool not available`;
-                        // Emit tool end event (error - no executor)
-                        if (this.neurolink?.getEventEmitter) {
-                            const emitter = this.neurolink.getEventEmitter();
-                            emitter.emit("tool:end", { tool: tool.name, error });
-                        }
+                        this.emitToolEvent("tool:end", tool.name, {
+                            error,
+                            success: false,
+                            responseTime: Date.now() - startTime,
+                        });
                         logger.error(error);
                         throw new Error(error);
                     }

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

@@ -0,0 +1,3 @@
+import type { ToolEventPayload } from "../types/index.js";
+export type { ToolEventPayload };
+export declare function createToolEventPayload(toolName: string, payload?: Omit<ToolEventPayload, "tool" | "toolName">): ToolEventPayload;

package/dist/lib/core/toolEvents.js

@@ -0,0 +1,8 @@
+export function createToolEventPayload(toolName, payload = {}) {
+    return {
+        ...payload,
+        tool: toolName,
+        toolName,
+    };
+}
+//# sourceMappingURL=toolEvents.js.map

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";
 /**
@@ -178,7 +178,10 @@ export class EvaluationPipeline {
         const hasOnlyScorers = !!options?.onlyScorers && options.onlyScorers.length > 0;
         const hasSkipScorers = !!options?.skipScorers && options.skipScorers.length > 0;
         if (hasOnlyScorers && hasSkipScorers) {
-            throw new Error("Cannot specify both 'onlyScorers' and 'skipScorers' options");
+            throw ErrorFactory.invalidConfiguration("evaluation pipeline execution options", "Cannot specify both 'onlyScorers' and 'skipScorers' options", {
+                onlyScorers: options?.onlyScorers,
+                skipScorers: options?.skipScorers,
+            });
         }
     }
     /**

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
      */