@juspay/neurolink 7.14.0 → 7.14.2

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 };
                                 }
@@ -334,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
@@ -399,55 +440,40 @@ export class BaseProvider {
                 // Not an error - custom tools are optional
             }
         }
-        // ✅ CRITICAL FIX: Add external MCP tools if SDK has external server manager
-        if (this.sdk &&
-            this.sdk.externalServerManager &&
-            typeof this.sdk.externalServerManager.getAllTools === "function") {
+        if (this.neurolink &&
+            typeof this.neurolink.getExternalMCPTools === "function") {
             try {
-                logger.debug(`[BaseProvider] Loading external MCP tools from SDK via externalServerManager`);
-                const externalTools = this.sdk.externalServerManager.getAllTools();
-                logger.debug(`[BaseProvider] Found ${externalTools.length} external MCP tools`, {
-                    tools: externalTools.map((t) => ({
-                        name: t.name,
-                        available: t.isAvailable,
-                        server: t.serverId,
-                    })),
-                });
-                for (const externalTool of externalTools) {
-                    if (externalTool.isAvailable) {
-                        logger.debug(`[BaseProvider] Converting external MCP tool: ${externalTool.name} from ${externalTool.serverId}`);
+                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");
-                        const { z } = await import("zod");
-                        tools[externalTool.name] = createAISDKTool({
-                            description: externalTool.description ||
-                                `External MCP tool ${externalTool.name}`,
-                            parameters: await this.convertMCPSchemaToZod(externalTool.inputSchema),
+                        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: ${externalTool.name}`, { args });
-                                // Execute via SDK's external server manager
-                                if (this.sdk &&
-                                    this.sdk.externalServerManager &&
-                                    typeof this.sdk.externalServerManager.executeTool ===
-                                        "function") {
-                                    return await this.sdk.externalServerManager.executeTool(externalTool.serverId, externalTool.name, 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: SDK externalServerManager.executeTool not available`);
+                                    throw new Error(`Cannot execute external MCP tool: NeuroLink executeExternalMCPTool not available`);
                                 }
                             },
                         });
-                        logger.debug(`[BaseProvider] Successfully added external MCP tool: ${externalTool.name}`);
+                        logger.debug(`[BaseProvider] Successfully added external MCP tool: ${tool.name}`);
                     }
-                    else {
-                        logger.debug(`[BaseProvider] Skipping unavailable external MCP tool: ${externalTool.name}`);
+                    catch (toolCreationError) {
+                        logger.error(`Failed to create external MCP tool: ${tool.name}`, toolCreationError);
                     }
                 }
                 logger.debug(`[BaseProvider] External MCP tools loading complete`, {
-                    totalExternalTools: externalTools.length,
-                    availableExternalTools: externalTools.filter((t) => t.isAvailable)
-                        .length,
-                    addedToTools: externalTools.filter((t) => t.isAvailable).length,
+                    totalToolsAdded: externalTools.length,
                 });
             }
             catch (error) {
@@ -456,12 +482,10 @@ export class BaseProvider {
             }
         }
         else {
-            logger.debug(`[BaseProvider] No external MCP tools interface available`, {
-                hasSDK: !!this.sdk,
-                hasExternalServerManager: this.sdk && !!this.sdk.externalServerManager,
-                hasGetAllTools: this.sdk &&
-                    this.sdk.externalServerManager &&
-                    typeof this.sdk.externalServerManager.getAllTools === "function",
+            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
@@ -689,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/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,19 +109,8 @@ export class AIProviderFactory {
             const finalModelName = resolvedModelName === "default" || resolvedModelName === null
                 ? undefined
                 : resolvedModelName;
-            // ✅ CRITICAL FIX: Pass external MCP tools interface to BaseProvider
-            let finalSdk = sdk;
-            if (sdk && typeof sdk.getExternalMCPTools === "function") {
-                finalSdk = {
-                    ...sdk,
-                    externalServerManager: {
-                        getAllTools: () => sdk.getExternalMCPTools(),
-                        executeTool: (serverId, toolName, params) => sdk.executeExternalMCPTool(serverId, toolName, params),
-                    },
-                };
-            }
             // Create provider with enhanced SDK
-            const provider = await ProviderFactory.createProvider(normalizedName, finalModelName, finalSdk);
+            const provider = await ProviderFactory.createProvider(normalizedName, finalModelName, sdk);
             logger.debug(componentIdentifier, "Pure factory pattern provider created", {
                 providerName: normalizedName,
                 modelName: finalModelName,

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
@@ -83,3 +84,21 @@ export declare function getTelemetryStatus(): {
     enabled: boolean;
     initialized: boolean;
 };
+export type { TextGenerationOptions, TextGenerationResult, AnalyticsData, EvaluationData, } from "./core/types.js";
+/**
+ * BACKWARD COMPATIBILITY: Legacy generateText function
+ * Provides standalone generateText function for existing code that uses it
+ *
+ * @example
+ * ```typescript
+ * import { generateText } from '@juspay/neurolink';
+ *
+ * const result = await generateText({
+ *   prompt: 'Hello, AI!',
+ *   provider: 'bedrock',
+ *   model: 'claude-3-sonnet'
+ * });
+ * console.log(result.content);
+ * ```
+ */
+export declare function generateText(options: import("./core/types.js").TextGenerationOptions): Promise<import("./core/types.js").TextGenerationResult>;

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
@@ -107,3 +107,24 @@ export function getTelemetryStatus() {
     }
     return { enabled: false, initialized: false };
 }
+/**
+ * BACKWARD COMPATIBILITY: Legacy generateText function
+ * Provides standalone generateText function for existing code that uses it
+ *
+ * @example
+ * ```typescript
+ * import { generateText } from '@juspay/neurolink';
+ *
+ * const result = await generateText({
+ *   prompt: 'Hello, AI!',
+ *   provider: 'bedrock',
+ *   model: 'claude-3-sonnet'
+ * });
+ * console.log(result.content);
+ * ```
+ */
+export async function generateText(options) {
+    // Import neurolink instance to avoid circular dependencies
+    const { neurolink } = await import("./neurolink.js");
+    return await neurolink.generateText(options);
+}

package/dist/lib/mcp/externalServerManager.d.ts

@@ -8,25 +8,45 @@
  */
 import { EventEmitter } from "events";
 import { ToolDiscoveryService } from "./toolDiscoveryService.js";
-import type { ExternalMCPServerConfig, ExternalMCPServerInstance, ExternalMCPServerHealth, ExternalMCPConfigValidation, ExternalMCPOperationResult, ExternalMCPManagerConfig, ExternalMCPToolInfo } from "../types/externalMcp.js";
-/**
- * ExternalServerManager
- * Core class for managing external MCP servers
- */
+import type { ExternalMCPServerInstance, ExternalMCPServerHealth, ExternalMCPConfigValidation, ExternalMCPOperationResult, ExternalMCPManagerConfig, ExternalMCPToolInfo } from "../types/externalMcp.js";
+import type { MCPServerInfo } from "../types/mcpTypes.js";
+import type { JsonObject } from "../types/common.js";
 export declare class ExternalServerManager extends EventEmitter {
     private servers;
     private config;
     private isShuttingDown;
     private toolDiscovery;
-    constructor(config?: ExternalMCPManagerConfig);
+    private enableMainRegistryIntegration;
+    constructor(config?: ExternalMCPManagerConfig, options?: {
+        enableMainRegistryIntegration?: boolean;
+    });
+    /**
+     * Load MCP server configurations from .mcp-config.json file
+     * Automatically registers servers found in the configuration
+     * @param configPath Optional path to config file (defaults to .mcp-config.json in cwd)
+     * @returns Promise resolving to number of servers loaded
+     */
+    loadMCPConfiguration(configPath?: string): Promise<{
+        serversLoaded: number;
+        errors: string[];
+    }>;
     /**
      * Validate external MCP server configuration
      */
-    validateConfig(config: ExternalMCPServerConfig): ExternalMCPConfigValidation;
+    validateConfig(config: MCPServerInfo): ExternalMCPConfigValidation;
+    /**
+     * Convert MCPServerInfo format (keeping for backward compatibility)
+     * Helper function for transitioning to zero-conversion architecture
+     */
+    private convertConfigToMCPServerInfo;
+    /**
+     * Add a new external MCP server - Backward compatibility overload
+     */
+    addServer(serverId: string, config: MCPServerInfo): Promise<ExternalMCPOperationResult<ExternalMCPServerInstance>>;
     /**
-     * Add a new external MCP server
+     * Add a new external MCP server - Updated to accept MCPServerInfo
      */
-    addServer(serverId: string, config: ExternalMCPServerConfig): Promise<ExternalMCPOperationResult<ExternalMCPServerInstance>>;
+    addServer(serverId: string, serverInfo: MCPServerInfo): Promise<ExternalMCPOperationResult<ExternalMCPServerInstance>>;
     /**
      * Remove an external MCP server
      */
@@ -64,13 +84,17 @@ export declare class ExternalServerManager extends EventEmitter {
      */
     private performHealthCheck;
     /**
-     * Get server instance
+     * Get server instance - converted to ExternalMCPServerInstance for compatibility
      */
     getServer(serverId: string): ExternalMCPServerInstance | undefined;
     /**
-     * Get all servers
+     * Get all servers - converted to ExternalMCPServerInstance for compatibility
      */
     getAllServers(): Map<string, ExternalMCPServerInstance>;
+    /**
+     * List servers as MCPServerInfo - ZERO conversion needed
+     */
+    listServers(): MCPServerInfo[];
     /**
      * Get server statuses
      */
@@ -94,12 +118,21 @@ export declare class ExternalServerManager extends EventEmitter {
      * Discover tools from a server
      */
     private discoverServerTools;
+    /**
+     * Register server tools with main tool registry for unified access
+     * This enables external MCP tools to be accessed via the main toolRegistry.executeTool()
+     */
+    private registerServerToolsWithMainRegistry;
+    /**
+     * Unregister server tools from main tool registry
+     */
+    private unregisterServerToolsFromMainRegistry;
     /**
      * Execute a tool on a specific server
      */
-    executeTool(serverId: string, toolName: string, parameters: Record<string, any>, options?: {
+    executeTool(serverId: string, toolName: string, parameters: JsonObject, options?: {
         timeout?: number;
-    }): Promise<any>;
+    }): Promise<unknown>;
     /**
      * Get all tools from all servers
      */