@juspay/neurolink 7.13.0 → 7.14.1

package/dist/lib/core/baseProvider.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { logger } from "../utils/logger.js";
 import { SYSTEM_LIMITS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { directAgentTools } from "../agent/directTools.js";
@@ -5,19 +6,6 @@ import { getSafeMaxTokens } from "../utils/tokenLimits.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 import { buildMessagesArray } from "../utils/messageBuilder.js";
-/**
- * Validates if a result contains a valid toolsObject structure
- * @param result - The result object to validate
- * @returns true if the result contains a valid toolsObject, false otherwise
- */
-function isValidToolsObject(result) {
-    return (result !== null &&
-        typeof result === "object" &&
-        "toolsObject" in result &&
-        result.toolsObject !== null &&
-        typeof result.toolsObject === "object" &&
-        Object.keys(result.toolsObject).length > 0);
-}
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -31,13 +19,15 @@ export class BaseProvider {
         ? {}
         : directAgentTools;
     mcpTools; // MCP tools loaded dynamically when available
+    customTools; // Custom tools from registerTool()
+    toolExecutor; // Tool executor from setupToolExecutor
     sessionId;
     userId;
-    sdk; // Reference to NeuroLink SDK instance for custom tools
-    constructor(modelName, providerName, sdk) {
+    neurolink; // Reference to actual NeuroLink instance for MCP tools
+    constructor(modelName, providerName, neurolink) {
         this.modelName = modelName || this.getDefaultModel();
         this.providerName = providerName || this.getProviderName();
-        this.sdk = sdk;
+        this.neurolink = neurolink;
     }
     /**
      * Check if this provider supports tool/function calling
@@ -106,7 +96,7 @@ export class BaseProvider {
                                         await new Promise((resolve) => setTimeout(resolve, Math.random() * 9 + 1));
                                     }
                                 }
-                                // Yield any remaining content
+                                // Yield all remaining content
                                 if (buffer.trim()) {
                                     yield { content: buffer };
                                 }
@@ -157,10 +147,20 @@ export class BaseProvider {
         try {
             // Import generateText dynamically to avoid circular dependencies
             const { generateText } = await import("ai");
-            // Get ALL available tools (direct + MCP when available)
+            // Get ALL available tools (direct + MCP + external from options)
             const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools ? await this.getAllTools() : {};
-            logger.debug(`[BaseProvider.generate] Tools for ${this.providerName}: ${Object.keys(tools).join(", ")}`);
+            const baseTools = shouldUseTools ? await this.getAllTools() : {};
+            const tools = shouldUseTools
+                ? {
+                    ...baseTools,
+                    ...(options.tools || {}), // Include external tools passed from NeuroLink
+                }
+                : {};
+            logger.debug(`[BaseProvider.generate] Tools for ${this.providerName}:`, {
+                directTools: Object.keys(baseTools),
+                externalTools: Object.keys(options.tools || {}),
+                totalTools: Object.keys(tools),
+            });
             // EVERY provider uses Vercel AI SDK - no exceptions
             const model = await this.getAISDKModel(); // This method is now REQUIRED
             // Build proper message array with conversation history
@@ -201,22 +201,66 @@ export class BaseProvider {
             const uniqueToolsUsed = [...new Set(toolsUsed)];
             // ✅ Extract tool executions from AI SDK result
             const toolExecutions = [];
+            // Create a map of tool calls to their arguments for matching with results
+            const toolCallArgsMap = new Map();
             // Extract tool executions from AI SDK result steps
-            // Extract tool executions from steps (where tool results are stored)
             if (result.steps &&
                 Array.isArray(result.steps)) {
                 for (const step of result.steps ||
                     []) {
-                    // Focus only on tool results (which have complete execution data)
-                    // Tool calls are just the requests, tool results contain the actual execution data
+                    // First, collect tool calls and their arguments
+                    if (step?.toolCalls && Array.isArray(step.toolCalls)) {
+                        for (const toolCall of step.toolCalls) {
+                            const tcRecord = toolCall;
+                            const toolName = tcRecord.toolName ||
+                                tcRecord.name ||
+                                "unknown";
+                            const toolId = tcRecord.toolCallId ||
+                                tcRecord.id ||
+                                toolName;
+                            // Extract arguments from tool call
+                            let callArgs = {};
+                            if (tcRecord.args) {
+                                callArgs = tcRecord.args;
+                            }
+                            else if (tcRecord.arguments) {
+                                callArgs = tcRecord.arguments;
+                            }
+                            else if (tcRecord.parameters) {
+                                callArgs = tcRecord.parameters;
+                            }
+                            toolCallArgsMap.set(toolId, callArgs);
+                            toolCallArgsMap.set(toolName, callArgs); // Also map by name as fallback
+                        }
+                    }
+                    // Then, process tool results and match with call arguments
                     if (step?.toolResults && Array.isArray(step.toolResults)) {
                         for (const toolResult of step.toolResults) {
                             const trRecord = toolResult;
+                            const toolName = trRecord.toolName || "unknown";
+                            const toolId = trRecord.toolCallId || trRecord.id;
+                            // Try to get arguments from the tool result first
+                            let toolArgs = {};
+                            if (trRecord.args) {
+                                toolArgs = trRecord.args;
+                            }
+                            else if (trRecord.arguments) {
+                                toolArgs = trRecord.arguments;
+                            }
+                            else if (trRecord.parameters) {
+                                toolArgs = trRecord.parameters;
+                            }
+                            else if (trRecord.input) {
+                                toolArgs = trRecord.input;
+                            }
+                            else {
+                                // Fallback: get arguments from the corresponding tool call
+                                toolArgs = toolCallArgsMap.get(toolId || toolName) || {};
+                            }
                             toolExecutions.push({
-                                name: trRecord.toolName || "unknown",
-                                input: trRecord.args || {},
+                                name: toolName,
+                                input: toolArgs,
                                 output: trRecord.result || "success",
-                                duration: 0, // AI SDK doesn't track duration
                             });
                         }
                     }
@@ -248,6 +292,12 @@ export class BaseProvider {
                 toolResults: result.toolResults,
                 toolsUsed: uniqueToolsUsed,
                 toolExecutions, // ✅ Add extracted tool executions
+                availableTools: Object.keys(tools).map((name) => ({
+                    name,
+                    description: tools[name].description || "No description available",
+                    parameters: tools[name].parameters || {},
+                    server: tools[name].serverId || "direct",
+                })),
             };
             // Enhanced result with analytics and evaluation
             return await this.enhanceResult(enhancedResult, options, startTime);
@@ -274,37 +324,88 @@ export class BaseProvider {
         const tools = {
             ...this.directTools, // Always include direct tools
         };
-        logger.debug(`[BaseProvider] getAllTools called, SDK available: ${!!this.sdk}, type: ${typeof this.sdk}`);
+        logger.debug(`[BaseProvider] getAllTools called for ${this.providerName}`, {
+            neurolinkAvailable: !!this.neurolink,
+            neurolinkType: typeof this.neurolink,
+            directToolsCount: Object.keys(this.directTools).length,
+        });
         logger.debug(`[BaseProvider] Direct tools: ${Object.keys(this.directTools).join(", ")}`);
-        // Add custom tools from SDK if available
-        logger.debug(`[BaseProvider] Checking SDK: ${!!this.sdk}, has getInMemoryServers: ${this.sdk && typeof this.sdk.getInMemoryServers}`);
-        if (this.sdk && typeof this.sdk.getInMemoryServers === "function") {
-            logger.debug(`[BaseProvider] SDK check passed, loading custom tools`);
+        // 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 (args) => {
+                                logger.debug(`[BaseProvider] Executing custom tool: ${toolName}`, { args });
+                                // Use the tool executor if available (from setupToolExecutor)
+                                if (this.toolExecutor) {
+                                    return await this.toolExecutor(toolName, args);
+                                }
+                                else {
+                                    return await typedToolDef.execute(args);
+                                }
+                            },
+                        });
+                        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",
+                    });
+                }
+            }
+        }
+        // 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.sdk.getInMemoryServers();
+                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) {
-                        const server = serverConfig.server;
-                        if (server && server.tools) {
-                            // Handle both Map and object formats
-                            const toolEntries = server.tools instanceof Map
-                                ? Array.from(server.tools.entries())
-                                : Object.entries(server.tools || {});
+                        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");
-                                        const { z } = await import("zod");
                                         tools[toolName] = createAISDKTool({
                                             description: toolInfo.description || `Tool ${toolName}`,
-                                            parameters: toolInfo.inputSchema ||
-                                                toolInfo.parameters ||
-                                                z.object({}),
+                                            parameters: toolInfo.parameters instanceof z.ZodType
+                                                ? toolInfo.parameters
+                                                : z.object({}),
                                             execute: async (args) => {
                                                 const result = await toolInfo.execute(args);
                                                 // Handle MCP-style results
@@ -339,6 +440,54 @@ export class BaseProvider {
                 // 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 (args) => {
+                                logger.debug(`[BaseProvider] Executing external MCP tool: ${tool.name}`, { args });
+                                // 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, args);
+                                }
+                                else {
+                                    throw new Error(`Cannot execute external MCP tool: NeuroLink executeExternalMCPTool not available`);
+                                }
+                            },
+                        });
+                        logger.debug(`[BaseProvider] Successfully added external MCP tool: ${tool.name}`);
+                    }
+                    catch (toolCreationError) {
+                        logger.error(`Failed to create external MCP tool: ${tool.name}`, toolCreationError);
+                    }
+                }
+                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 {
+            logger.debug(`[BaseProvider] No external MCP tool interface available`, {
+                hasNeuroLink: !!this.neurolink,
+                hasGetExternalMCPTools: this.neurolink &&
+                    typeof this.neurolink.getExternalMCPTools === "function",
+            });
+        }
         // MCP tools loading simplified - removed functionCalling dependency
         if (!this.mcpTools) {
             // Set empty tools object - MCP tools are handled at a higher level
@@ -351,6 +500,80 @@ export class BaseProvider {
         logger.debug(`[BaseProvider] getAllTools returning tools: ${Object.keys(tools).join(", ")}`);
         return tools;
     }
+    /**
+     * Convert MCP JSON Schema to Zod schema for AI SDK tools
+     * Handles common MCP schema patterns safely
+     */
+    async convertMCPSchemaToZod(inputSchema) {
+        const { z } = await import("zod");
+        if (!inputSchema || typeof inputSchema !== "object") {
+            return z.object({});
+        }
+        try {
+            const schema = inputSchema;
+            const zodFields = {};
+            // Handle JSON Schema properties
+            if (schema.properties && typeof schema.properties === "object") {
+                const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+                for (const [propName, propDef] of Object.entries(schema.properties)) {
+                    const prop = propDef;
+                    let zodType;
+                    // Convert based on JSON Schema type
+                    switch (prop.type) {
+                        case "string":
+                            zodType = z.string();
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        case "number":
+                        case "integer":
+                            zodType = z.number();
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        case "boolean":
+                            zodType = z.boolean();
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        case "array":
+                            zodType = z.array(z.unknown());
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        case "object":
+                            zodType = z.object({});
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                            break;
+                        default:
+                            // Unknown type, use string as fallback
+                            zodType = z.string();
+                            if (prop.description) {
+                                zodType = zodType.describe(prop.description);
+                            }
+                    }
+                    // Make optional if not required
+                    if (!required.has(propName)) {
+                        zodType = zodType.optional();
+                    }
+                    zodFields[propName] = zodType;
+                }
+            }
+            return Object.keys(zodFields).length > 0
+                ? z.object(zodFields)
+                : z.object({});
+        }
+        catch (error) {
+            logger.warn(`Failed to convert MCP schema to Zod, using empty schema:`, error);
+            return z.object({});
+        }
+    }
     /**
      * Set session context for MCP tools
      */
@@ -490,6 +713,9 @@ export class BaseProvider {
             });
             return;
         }
+        // Store custom tools for use in getAllTools()
+        this.customTools = sdk.customTools;
+        this.toolExecutor = sdk.executeTool;
         logger.debug(`[${functionTag}] Setting up tool executor for provider`, {
             providerType: this.constructor.name,
             availableCustomTools: sdk.customTools.size,

package/dist/lib/core/conversationMemoryManager.js

@@ -3,7 +3,7 @@
  * Handles in-memory conversation storage, session management, and context injection
  */
 import { ConversationMemoryError } from "../types/conversationTypes.js";
-import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN } from "../config/conversationMemoryConfig.js";
+import { DEFAULT_MAX_TURNS_PER_SESSION, DEFAULT_MAX_SESSIONS, MESSAGES_PER_TURN, } from "../config/conversationMemoryConfig.js";
 import { logger } from "../utils/logger.js";
 export class ConversationMemoryManager {
     sessions = new Map();
@@ -49,7 +49,8 @@ export class ConversationMemoryManager {
             session.messages.push({ role: "user", content: userMessage }, { role: "assistant", content: aiResponse });
             session.lastActivity = Date.now();
             // Enforce per-session turn limit (each turn = MESSAGES_PER_TURN messages: user + assistant)
-            const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) * MESSAGES_PER_TURN;
+            const maxMessages = (this.config.maxTurnsPerSession || DEFAULT_MAX_TURNS_PER_SESSION) *
+                MESSAGES_PER_TURN;
             if (session.messages.length > maxMessages) {
                 session.messages = session.messages.slice(-maxMessages);
             }

package/dist/lib/core/dynamicModels.js

@@ -89,7 +89,7 @@ export class DynamicModelProvider {
         }
         // Log all failures for debugging
         logger.warn(`[DynamicModelProvider] All model configuration sources failed`, { errors });
-        throw new Error(`Failed to load model configuration from any source. Attempted: ${errors.map((e) => e.source).join(", ")}`);
+        throw new Error(`Failed to load model configuration from all source. Attempted: ${errors.map((e) => e.source).join(", ")}`);
     }
     /**
      * Load configuration from a source with timeout handling

package/dist/lib/core/evaluation.js

@@ -181,7 +181,7 @@ Relevance: [score]
 Accuracy: [score]
 Completeness: [score]
 Overall: [score]
-Reasoning: [Provide a detailed explanation of your evaluation, explaining why you gave these scores. Include specific observations about the response's strengths and any areas for improvement.]
+Reasoning: [Provide a detailed explanation of your evaluation, explaining why you gave these scores. Include specific observations about the response's strengths and all possible areas for improvement.]
 `;
         // Generate evaluation
         const result = await provider.generate(prompt);

package/dist/lib/core/factory.js

@@ -109,13 +109,13 @@ export class AIProviderFactory {
             const finalModelName = resolvedModelName === "default" || resolvedModelName === null
                 ? undefined
                 : resolvedModelName;
+            // Create provider with enhanced SDK
             const provider = await ProviderFactory.createProvider(normalizedName, finalModelName, sdk);
             logger.debug(componentIdentifier, "Pure factory pattern provider created", {
                 providerName: normalizedName,
                 modelName: finalModelName,
                 factoryUsed: true,
             });
-            // PURE FACTORY PATTERN: All providers handled by ProviderFactory - no switch statements needed
             // Wrap with MCP if enabled
             if (enableMCP) {
                 try {

package/dist/lib/factories/providerFactory.js

@@ -46,22 +46,16 @@ export class ProviderFactory {
             model = model || registration.defaultModel;
         }
         try {
-            // Try calling as factory function first, then fallback to constructor
             let result;
             try {
-                // Try as factory function
-                result = registration.constructor(model, providerName, sdk);
+                // Try as async factory function first (most providers are async functions)
+                result = await registration.constructor(model, providerName, sdk);
             }
-            catch (factoryError) {
-                // Fallback to constructor
+            catch (functionError) {
+                // Fallback to constructor - ensure parameters are maintained
                 result = new registration.constructor(model, providerName, sdk);
             }
-            // Only await if result is actually a Promise
-            if (result &&
-                typeof result === "object" &&
-                typeof result.then === "function") {
-                result = await result;
-            }
+            // Return result (no need to await again if already awaited in try block)
             return result;
         }
         catch (error) {

package/dist/lib/factories/providerRegistry.js

@@ -52,9 +52,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) => {
+            ProviderFactory.registerProvider(AIProviderName.VERTEX, async (modelName, providerName, sdk) => {
                 const { GoogleVertexProvider } = await import("../providers/googleVertex.js");
-                return new GoogleVertexProvider(modelName);
+                return new GoogleVertexProvider(modelName, providerName, sdk);
             }, "claude-sonnet-4@20250514", ["vertex", "googleVertex"]);
             // Register Hugging Face provider (Unified Router implementation)
             ProviderFactory.registerProvider(AIProviderName.HUGGINGFACE, async (modelName) => {

package/dist/lib/index.d.ts

@@ -10,13 +10,14 @@ import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
 export type { AIProvider, AIProviderName, ProviderConfig, StreamingOptions, ProviderAttempt, SupportedModelName, } from "./core/types.js";
 export type { GenerateOptions, GenerateResult, EnhancedProvider, } from "./types/generateTypes.js";
-export type { SimpleTool, ToolContext } from "./sdk/toolRegistration.js";
-export { createTool, createTypedTool, validateTool, } from "./sdk/toolRegistration.js";
-export type { InMemoryMCPServerConfig, InMemoryToolInfo, InMemoryToolResult, } from "./types/mcpTypes.js";
+export type { ToolContext } from "./sdk/toolRegistration.js";
+export { validateTool } from "./sdk/toolRegistration.js";
+export type { ToolResult, ToolDefinition } from "./types/tools.js";
 export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./core/types.js";
 export { getBestProvider, getAvailableProviders, isValidProvider, } from "./utils/providerUtils.js";
 export { NeuroLink } from "./neurolink.js";
-export type { ProviderStatus, MCPStatus, MCPServerInfo } from "./neurolink.js";
+export type { ProviderStatus, MCPStatus } from "./neurolink.js";
+export type { MCPServerInfo } from "./types/mcpTypes.js";
 export declare const VERSION = "1.0.0";
 /**
  * Quick start factory function

package/dist/lib/index.js

@@ -9,7 +9,7 @@
 // Core exports
 import { AIProviderFactory } from "./core/factory.js";
 export { AIProviderFactory };
-export { createTool, createTypedTool, validateTool, } from "./sdk/toolRegistration.js";
+export { validateTool } from "./sdk/toolRegistration.js";
 // Model enums
 export { BedrockModels, OpenAIModels, VertexModels, DEFAULT_PROVIDER_CONFIGS, } from "./core/types.js";
 // Utility exports