@juspay/neurolink 7.29.1 → 7.29.3

package/dist/lib/core/baseProvider.js

@@ -1,4 +1,3 @@
-import { z } from "zod";
 import { MiddlewareFactory } from "../middleware/factory.js";
 import { logger } from "../utils/logger.js";
 import { DEFAULT_MAX_STEPS, STEP_LIMITS } from "../core/constants.js";
@@ -320,9 +319,9 @@ export class BaseProvider {
             const enhancedResult = {
                 content: result.text,
                 usage: {
-                    inputTokens: result.usage?.promptTokens || 0,
-                    outputTokens: result.usage?.completionTokens || 0,
-                    totalTokens: result.usage?.totalTokens || 0,
+                    input: result.usage?.promptTokens || 0,
+                    output: result.usage?.completionTokens || 0,
+                    total: result.usage?.totalTokens || 0,
                 },
                 provider: this.providerName,
                 model: this.modelName,
@@ -389,9 +388,9 @@ export class BaseProvider {
             provider: result.provider || this.providerName,
             model: result.model || this.modelName,
             usage: result.usage || {
-                promptTokens: 0,
-                completionTokens: 0,
-                totalTokens: 0,
+                input: 0,
+                output: 0,
+                total: 0,
             },
             responseTime: 0, // BaseProvider doesn't track response time directly
             toolsUsed: result.toolsUsed || [],
@@ -483,211 +482,152 @@ export class BaseProvider {
     // TOOL MANAGEMENT
     // ===================
     /**
-     * Get all available tools - direct tools are ALWAYS available
-     * MCP tools are added when available (without blocking)
+     * Check if a schema is a Zod schema
      */
-    async getAllTools() {
-        const tools = {
-            ...this.directTools, // Always include direct tools
-        };
-        logger.debug(`[BaseProvider] getAllTools called for ${this.providerName}`, {
-            neurolinkAvailable: !!this.neurolink,
-            neurolinkType: typeof this.neurolink,
-            directToolsCount: getKeyCount(this.directTools),
-        });
-        logger.debug(`[BaseProvider] Direct tools: ${getKeysAsString(this.directTools)}`);
-        // Add custom tools from setupToolExecutor if available
-        if (this.customTools && this.customTools.size > 0) {
-            logger.debug(`[BaseProvider] Loading ${this.customTools.size} custom tools from setupToolExecutor`);
-            for (const [toolName, toolDef] of this.customTools.entries()) {
-                logger.debug(`[BaseProvider] Processing custom tool: ${toolName}`, {
-                    toolDef: typeof toolDef,
-                    hasExecute: toolDef && typeof toolDef === "object" && "execute" in toolDef,
-                    hasName: toolDef && typeof toolDef === "object" && "name" in toolDef,
-                });
-                if (toolDef &&
-                    typeof toolDef === "object" &&
-                    "execute" in toolDef &&
-                    typeof toolDef.execute === "function") {
-                    try {
-                        const { tool: createAISDKTool } = await import("ai");
-                        const typedToolDef = toolDef;
-                        tools[toolName] = createAISDKTool({
-                            description: typedToolDef.description || `Custom tool ${toolName}`,
-                            parameters: z.object({}), // Use empty schema for custom tools
-                            execute: async (params) => {
-                                logger.debug(`[BaseProvider] Executing custom tool: ${toolName}`, { params });
-                                try {
-                                    // Use the tool executor if available (from setupToolExecutor)
-                                    let result;
-                                    if (this.toolExecutor) {
-                                        result = await this.toolExecutor(toolName, params);
-                                    }
-                                    else {
-                                        result = await typedToolDef.execute(params);
-                                    }
-                                    // Log successful execution
-                                    logger.debug(`[BaseProvider] Tool execution successful: ${toolName}`, {
-                                        resultType: typeof result,
-                                        hasResult: result !== null && result !== undefined,
-                                        toolName,
-                                    });
-                                    return result;
-                                }
-                                catch (error) {
-                                    logger.warn(`[BaseProvider] Tool execution failed: ${toolName}`, {
-                                        error: error instanceof Error ? error.message : String(error),
-                                        params,
-                                        toolName,
-                                    });
-                                    // GENERIC ERROR HANDLING FOR ALL MCP TOOLS:
-                                    // Return a generic error object that works with any MCP server
-                                    // The AI can interpret this and try different approaches
-                                    return {
-                                        _neurolinkToolError: true,
-                                        toolName: toolName,
-                                        error: error instanceof Error ? error.message : String(error),
-                                        timestamp: new Date().toISOString(),
-                                        params: params,
-                                        // Keep it simple - just indicate an error occurred
-                                        message: `Error calling ${toolName}: ${error instanceof Error ? error.message : String(error)}`,
-                                    };
-                                }
-                            },
-                        });
-                        logger.debug(`[BaseProvider] Successfully added custom tool: ${toolName}`);
-                    }
-                    catch (error) {
-                        logger.error(`[BaseProvider] Failed to add custom tool: ${toolName}`, error);
-                    }
-                }
-                else {
-                    logger.warn(`[BaseProvider] Invalid custom tool format: ${toolName}`, {
-                        toolDef: typeof toolDef,
-                        hasExecute: toolDef && typeof toolDef === "object" && "execute" in toolDef,
-                        executeType: toolDef && typeof toolDef === "object" && "execute" in toolDef
-                            ? typeof toolDef.execute
-                            : "N/A",
-                    });
-                }
+    isZodSchema(schema) {
+        return (typeof schema === "object" &&
+            schema !== null &&
+            // Most Zod schemas have an internal _def and a parse method
+            typeof schema.parse === "function");
+    }
+    /**
+     * Convert tool execution result from MCP format to standard format
+     */
+    async convertToolResult(result) {
+        // Handle MCP-style results
+        if (result && typeof result === "object" && "success" in result) {
+            const mcpResult = result;
+            if (mcpResult.success) {
+                return mcpResult.data;
+            }
+            else {
+                const errorMsg = typeof mcpResult.error === "string"
+                    ? mcpResult.error
+                    : "Tool execution failed";
+                throw new Error(errorMsg);
             }
         }
-        // Add custom tools from NeuroLink if available
-        logger.debug(`[BaseProvider] Checking NeuroLink: ${!!this.neurolink}, has getInMemoryServers: ${this.neurolink && typeof this.neurolink.getInMemoryServers}`);
-        if (this.neurolink &&
-            typeof this.neurolink.getInMemoryServers === "function") {
-            logger.debug(`[BaseProvider] NeuroLink check passed, loading custom tools`);
-            try {
-                const inMemoryServers = this.neurolink.getInMemoryServers();
-                logger.debug(`[BaseProvider] Got servers:`, inMemoryServers.size);
-                logger.debug(`[BaseProvider] Loading custom tools from SDK, found ${inMemoryServers.size} servers`);
-                if (inMemoryServers && inMemoryServers.size > 0) {
-                    // Convert in-memory server tools to AI SDK format
-                    for (const [_serverId, serverConfig] of inMemoryServers) {
-                        if (serverConfig && serverConfig.tools) {
-                            // Handle tools array from MCPServerInfo
-                            const toolEntries = serverConfig.tools.map((tool) => [
-                                tool.name,
-                                tool,
-                            ]);
-                            for (const [toolName, toolInfo] of toolEntries) {
-                                if (toolInfo && typeof toolInfo.execute === "function") {
-                                    logger.debug(`[BaseProvider] Converting custom tool: ${toolName}`);
-                                    try {
-                                        // Convert to AI SDK tool format
-                                        const { tool: createAISDKTool } = await import("ai");
-                                        // Validate optional schemas if present (accept Zod or plain JSON schema objects)
-                                        const isZodSchema = (s) => typeof s === "object" &&
-                                            s !== null &&
-                                            // Most Zod schemas have an internal _def and a parse method
-                                            typeof s.parse === "function";
-                                        tools[toolName] = createAISDKTool({
-                                            description: toolInfo.description || `Tool ${toolName}`,
-                                            parameters: isZodSchema(toolInfo.parameters)
-                                                ? toolInfo.parameters
-                                                : z.object({}),
-                                            execute: async (params) => {
-                                                const result = await toolInfo.execute(params);
-                                                // Handle MCP-style results
-                                                if (result &&
-                                                    typeof result === "object" &&
-                                                    "success" in result) {
-                                                    if (result.success) {
-                                                        return result.data;
-                                                    }
-                                                    else {
-                                                        const errorMsg = typeof result.error === "string"
-                                                            ? result.error
-                                                            : "Tool execution failed";
-                                                        throw new Error(errorMsg);
-                                                    }
-                                                }
-                                                return result;
-                                            },
-                                        });
-                                    }
-                                    catch (toolCreationError) {
-                                        logger.error(`Failed to create tool: ${toolName}`, toolCreationError);
-                                    }
-                                }
-                            }
-                        }
-                    }
+        return result;
+    }
+    /**
+     * Create a custom tool from tool definition
+     */
+    async createCustomToolFromDefinition(toolName, toolInfo) {
+        try {
+            logger.debug(`[BaseProvider] Converting custom tool: ${toolName}`);
+            // Convert to AI SDK tool format
+            const { tool: createAISDKTool } = await import("ai");
+            const { z } = await import("zod");
+            return createAISDKTool({
+                description: toolInfo.description || `Tool ${toolName}`,
+                parameters: this.isZodSchema(toolInfo.parameters)
+                    ? toolInfo.parameters
+                    : z.object({}),
+                execute: async (params) => {
+                    const result = await toolInfo.execute(params);
+                    return await this.convertToolResult(result);
+                },
+            });
+        }
+        catch (toolCreationError) {
+            logger.error(`Failed to create tool: ${toolName}`, toolCreationError);
+            return null;
+        }
+    }
+    /**
+     * Process custom tools from setupToolExecutor
+     */
+    async processCustomTools(tools) {
+        if (!this.customTools || this.customTools.size === 0) {
+            return;
+        }
+        logger.debug(`[BaseProvider] Loading ${this.customTools.size} custom tools from setupToolExecutor`);
+        for (const [toolName, toolDef] of this.customTools.entries()) {
+            logger.debug(`[BaseProvider] Processing custom tool: ${toolName}`, {
+                toolDef: typeof toolDef,
+                hasExecute: toolDef && typeof toolDef === "object" && "execute" in toolDef,
+                hasName: toolDef && typeof toolDef === "object" && "name" in toolDef,
+            });
+            // Validate tool definition has required execute function
+            const toolInfo = toolDef ||
+                {};
+            if (toolInfo && typeof toolInfo.execute === "function") {
+                const tool = await this.createCustomToolFromDefinition(toolName, toolInfo);
+                if (tool) {
+                    tools[toolName] = tool;
                 }
             }
-            catch (error) {
-                logger.debug(`Failed to load custom tools for ${this.providerName}:`, error);
-                // Not an error - custom tools are optional
-            }
         }
-        if (this.neurolink &&
-            typeof this.neurolink.getExternalMCPTools === "function") {
-            try {
-                logger.debug(`[BaseProvider] Loading external MCP tools from NeuroLink via direct tool access`);
-                const externalTools = this.neurolink.getExternalMCPTools() || [];
-                logger.debug(`[BaseProvider] Found ${externalTools.length} external MCP tools`);
-                for (const tool of externalTools) {
-                    logger.debug(`[BaseProvider] Converting external MCP tool: ${tool.name}`);
-                    try {
-                        // Convert to AI SDK tool format
-                        const { tool: createAISDKTool } = await import("ai");
-                        tools[tool.name] = createAISDKTool({
-                            description: tool.description || `External MCP tool ${tool.name}`,
-                            parameters: await this.convertMCPSchemaToZod(tool.inputSchema),
-                            execute: async (params) => {
-                                logger.debug(`[BaseProvider] Executing external MCP tool: ${tool.name}`, { params });
-                                // Execute via NeuroLink's direct tool execution
-                                if (this.neurolink &&
-                                    typeof this.neurolink.executeExternalMCPTool === "function") {
-                                    return await this.neurolink.executeExternalMCPTool(tool.serverId || "unknown", tool.name, params);
-                                }
-                                else {
-                                    throw new Error(`Cannot execute external MCP tool: NeuroLink executeExternalMCPTool not available`);
-                                }
-                            },
-                        });
-                        logger.debug(`[BaseProvider] Successfully added external MCP tool: ${tool.name}`);
+        logger.debug(`[BaseProvider] Custom tools processing complete`, {
+            customToolsProcessed: this.customTools.size,
+        });
+    }
+    /**
+     * Create an external MCP tool
+     */
+    async createExternalMCPTool(tool) {
+        try {
+            logger.debug(`[BaseProvider] Converting external MCP tool: ${tool.name}`);
+            // Convert to AI SDK tool format
+            const { tool: createAISDKTool } = await import("ai");
+            return createAISDKTool({
+                description: tool.description || `External MCP tool ${tool.name}`,
+                parameters: await this.convertMCPSchemaToZod(tool.inputSchema),
+                execute: async (params) => {
+                    logger.debug(`[BaseProvider] Executing external MCP tool: ${tool.name}`, { params });
+                    // Execute via NeuroLink's direct tool execution
+                    if (this.neurolink &&
+                        typeof this.neurolink.executeExternalMCPTool === "function") {
+                        return await this.neurolink.executeExternalMCPTool(tool.serverId || "unknown", tool.name, params);
                     }
-                    catch (toolCreationError) {
-                        logger.error(`Failed to create external MCP tool: ${tool.name}`, toolCreationError);
+                    else {
+                        throw new Error(`Cannot execute external MCP tool: NeuroLink executeExternalMCPTool not available`);
                     }
-                }
-                logger.debug(`[BaseProvider] External MCP tools loading complete`, {
-                    totalToolsAdded: externalTools.length,
-                });
-            }
-            catch (error) {
-                logger.error(`[BaseProvider] Failed to load external MCP tools for ${this.providerName}:`, error);
-                // Not an error - external tools are optional
-            }
+                },
+            });
         }
-        else {
+        catch (toolCreationError) {
+            logger.error(`Failed to create external MCP tool: ${tool.name}`, toolCreationError);
+            return null;
+        }
+    }
+    /**
+     * Process external MCP tools
+     */
+    async processExternalMCPTools(tools) {
+        if (!this.neurolink ||
+            typeof this.neurolink.getExternalMCPTools !== "function") {
             logger.debug(`[BaseProvider] No external MCP tool interface available`, {
                 hasNeuroLink: !!this.neurolink,
                 hasGetExternalMCPTools: this.neurolink &&
                     typeof this.neurolink.getExternalMCPTools === "function",
             });
+            return;
+        }
+        try {
+            logger.debug(`[BaseProvider] Loading external MCP tools for ${this.providerName}`);
+            const externalTools = await this.neurolink.getExternalMCPTools();
+            logger.debug(`[BaseProvider] Found ${externalTools.length} external MCP tools`);
+            for (const tool of externalTools) {
+                const mcpTool = await this.createExternalMCPTool(tool);
+                if (mcpTool) {
+                    tools[tool.name] = mcpTool;
+                    logger.debug(`[BaseProvider] Successfully added external MCP tool: ${tool.name}`);
+                }
+            }
+            logger.debug(`[BaseProvider] External MCP tools loading complete`, {
+                totalToolsAdded: externalTools.length,
+            });
         }
+        catch (error) {
+            logger.error(`[BaseProvider] Failed to load external MCP tools for ${this.providerName}:`, error);
+            // Not an error - external tools are optional
+        }
+    }
+    /**
+     * Process MCP tools integration
+     */
+    async processMCPTools(tools) {
         // MCP tools loading simplified - removed functionCalling dependency
         if (!this.mcpTools) {
             // Set empty tools object - MCP tools are handled at a higher level
@@ -697,6 +637,25 @@ export class BaseProvider {
         if (this.mcpTools) {
             Object.assign(tools, this.mcpTools);
         }
+    }
+    /**
+     * Get all available tools - direct tools are ALWAYS available
+     * MCP tools are added when available (without blocking)
+     */
+    async getAllTools() {
+        const tools = {
+            ...this.directTools, // Always include direct tools
+        };
+        logger.debug(`[BaseProvider] getAllTools called for ${this.providerName}`, {
+            neurolinkAvailable: !!this.neurolink,
+            neurolinkType: typeof this.neurolink,
+            directToolsCount: getKeyCount(this.directTools),
+        });
+        logger.debug(`[BaseProvider] Direct tools: ${getKeysAsString(this.directTools)}`);
+        // Process all tool types using dedicated helper methods
+        await this.processCustomTools(tools);
+        await this.processExternalMCPTools(tools);
+        await this.processMCPTools(tools);
         logger.debug(`[BaseProvider] getAllTools returning tools: ${getKeysAsString(tools)}`);
         return tools;
     }
@@ -992,7 +951,30 @@ export class BaseProvider {
     }
     async createEvaluation(result, options) {
         const { evaluateResponse } = await import("../core/evaluation.js");
-        const evaluation = await evaluateResponse(result.content, options.prompt);
+        const context = {
+            userQuery: options.prompt || options.input?.text || "Generated response",
+            aiResponse: result.content,
+            context: options.context,
+            primaryDomain: options.evaluationDomain,
+            assistantRole: "AI assistant",
+            conversationHistory: options.conversationHistory?.map((msg) => ({
+                role: msg.role,
+                content: msg.content,
+            })),
+            toolUsage: options.toolUsageContext
+                ? [
+                    {
+                        toolName: options.toolUsageContext,
+                        input: {},
+                        output: {},
+                        executionTime: 0,
+                    },
+                ]
+                : undefined,
+            expectedOutcome: options.expectedOutcome,
+            evaluationCriteria: options.evaluationCriteria,
+        };
+        const evaluation = await evaluateResponse(context);
         return evaluation;
     }
     validateOptions(options) {

package/dist/lib/core/dynamicModels.js

@@ -100,12 +100,6 @@ export class DynamicModelProvider {
             // Setup timeout and abort controller
             const controller = new AbortController();
             const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-            // Load from URL
-            const response = await fetch(source, {
-                headers: {
-                    "User-Agent": "NeuroLink/1.0 (+https://github.com/juspay/neurolink)",
-                },
-            });
             try {
                 // Add health check for localhost before attempting full request
                 if (source.includes("localhost") || source.includes("127.0.0.1")) {
@@ -113,7 +107,7 @@ export class DynamicModelProvider {
                 }
                 const response = await fetch(source, {
                     headers: {
-                        "User-Agent": "NeuroLink/1.0 (+https://github.com/sachinsharma92/neurolink)",
+                        "User-Agent": "NeuroLink/1.0 (+https://github.com/juspay/neurolink)",
                         Accept: "application/json",
                         "Cache-Control": "no-cache",
                     },
@@ -242,6 +236,9 @@ export class DynamicModelProvider {
     searchByCapability(capability, options = {}) {
         this.ensureInitialized();
         const results = [];
+        if (!this.modelRegistry) {
+            return results;
+        }
         for (const [providerName, models] of Object.entries(this.modelRegistry.models)) {
             if (options.provider && providerName !== options.provider) {
                 continue;
@@ -301,6 +298,9 @@ export class DynamicModelProvider {
     getAllModels() {
         this.ensureInitialized();
         const results = [];
+        if (!this.modelRegistry) {
+            return results;
+        }
         for (const [providerName, models] of Object.entries(this.modelRegistry.models)) {
             for (const [modelName, modelConfig] of Object.entries(models)) {
                 results.push({

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

@@ -1,8 +1,8 @@
 /**
- * NeuroLink Unified Evaluation System
+ * NeuroLink Evaluation System
  */
-import type { EvaluationData } from "./types.js";
-export interface UnifiedEvaluationResult extends EvaluationData {
+import type { EvaluationData } from "../index.js";
+export interface EvaluationResult extends EvaluationData {
     domainAlignment?: number;
     terminologyAccuracy?: number;
     toolEffectiveness?: number;
@@ -20,7 +20,7 @@ export interface UnifiedEvaluationResult extends EvaluationData {
     alertSeverity: "low" | "medium" | "high" | "none";
     reasoning: string;
 }
-export interface UnifiedEvaluationContext {
+export interface EvaluationContext {
     userQuery: string;
     aiResponse: string;
     context?: Record<string, unknown>;
@@ -43,14 +43,14 @@ export interface UnifiedEvaluationContext {
 /**
  * Get default evaluation when evaluation fails
  */
-declare function getDefaultUnifiedEvaluation(reason: string, evaluationTime: number, context: UnifiedEvaluationContext): UnifiedEvaluationResult;
+declare function getDefaultEvaluation(reason: string, evaluationTime: number, context: EvaluationContext): EvaluationResult;
 /**
  * Parse unified evaluation result from text response
  */
-declare function parseUnifiedEvaluationResult(response: string, context: UnifiedEvaluationContext): Partial<UnifiedEvaluationResult>;
+declare function parseEvaluationResult(response: string, context: EvaluationContext): Partial<EvaluationResult>;
 /**
  * Main unified evaluation function
  */
-export declare function generateUnifiedEvaluation(context: UnifiedEvaluationContext): Promise<UnifiedEvaluationResult>;
-export declare function evaluateResponse(responseOrContext: unknown, contextOrUserQuery?: unknown, userQuery?: unknown, providedContexts?: unknown, options?: unknown, additionalArgs?: unknown): Promise<unknown>;
-export { getDefaultUnifiedEvaluation, parseUnifiedEvaluationResult };
+export declare function generateEvaluation(context: EvaluationContext): Promise<EvaluationResult>;
+export declare function evaluateResponse(context: EvaluationContext): Promise<EvaluationResult>;
+export { getDefaultEvaluation, parseEvaluationResult };