@juspay/neurolink 7.14.0 → 7.14.1

package/dist/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/core/dynamicModels.d.ts

@@ -20,10 +20,10 @@ declare const ModelConfigSchema: z.ZodObject<{
     contextWindow: z.ZodNumber;
     releaseDate: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    id: string;
-    displayName: string;
     capabilities: string[];
+    id: string;
     deprecated: boolean;
+    displayName: string;
     pricing: {
         input: number;
         output: number;
@@ -31,10 +31,10 @@ declare const ModelConfigSchema: z.ZodObject<{
     contextWindow: number;
     releaseDate: string;
 }, {
-    id: string;
-    displayName: string;
     capabilities: string[];
+    id: string;
     deprecated: boolean;
+    displayName: string;
     pricing: {
         input: number;
         output: number;
@@ -63,10 +63,10 @@ declare const ModelRegistrySchema: z.ZodObject<{
         contextWindow: z.ZodNumber;
         releaseDate: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        id: string;
-        displayName: string;
         capabilities: string[];
+        id: string;
         deprecated: boolean;
+        displayName: string;
         pricing: {
             input: number;
             output: number;
@@ -74,10 +74,10 @@ declare const ModelRegistrySchema: z.ZodObject<{
         contextWindow: number;
         releaseDate: string;
     }, {
-        id: string;
-        displayName: string;
         capabilities: string[];
+        id: string;
         deprecated: boolean;
+        displayName: string;
         pricing: {
             input: number;
             output: number;
@@ -89,11 +89,12 @@ declare const ModelRegistrySchema: z.ZodObject<{
     defaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     version: string;
+    lastUpdated: string;
     models: Record<string, Record<string, {
-        id: string;
-        displayName: string;
         capabilities: string[];
+        id: string;
         deprecated: boolean;
+        displayName: string;
         pricing: {
             input: number;
             output: number;
@@ -101,16 +102,16 @@ declare const ModelRegistrySchema: z.ZodObject<{
         contextWindow: number;
         releaseDate: string;
     }>>;
-    lastUpdated: string;
     defaults?: Record<string, string> | undefined;
     aliases?: Record<string, string> | undefined;
 }, {
     version: string;
+    lastUpdated: string;
     models: Record<string, Record<string, {
-        id: string;
-        displayName: string;
         capabilities: string[];
+        id: string;
         deprecated: boolean;
+        displayName: string;
         pricing: {
             input: number;
             output: number;
@@ -118,7 +119,6 @@ declare const ModelRegistrySchema: z.ZodObject<{
         contextWindow: number;
         releaseDate: string;
     }>>;
-    lastUpdated: string;
     defaults?: Record<string, string> | undefined;
     aliases?: Record<string, string> | undefined;
 }>;

package/dist/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/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/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/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/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

package/dist/lib/agent/directTools.js

@@ -163,7 +163,7 @@ export const directAgentTools = {
                     for (const func of allowedMathFunctions) {
                         safeExpression = safeExpression.replace(new RegExp(func, "g"), func);
                     }
-                    // Remove any remaining non-safe characters except Math functions
+                    // Remove remaining non-safe characters except Math functions
                     const mathSafe = /^[0-9+\-*/().\s]|Math\.(abs|ceil|floor|round|sqrt|pow|sin|cos|tan|log|exp|PI|E)/g;
                     if (!safeExpression
                         .split("")

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

@@ -3,43 +3,8 @@ import type { Schema } from "ai";
 import type { Tool, LanguageModelV1 } from "ai";
 import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult, AnalyticsData, AIProviderName, EvaluationData } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
-import type { JsonValue, UnknownRecord } from "../types/common.js";
-import type { ToolResult } from "../types/tools.js";
-/**
- * Interface for SDK with in-memory MCP servers and external MCP support
- */
-export interface NeuroLinkSDK {
-    getInMemoryServers?: () => Map<string, {
-        server: {
-            title?: string;
-            description?: string;
-            tools?: Map<string, ToolInfo> | Record<string, ToolInfo>;
-        };
-        category?: string;
-        metadata?: UnknownRecord;
-    }>;
-    externalServerManager?: {
-        getAllTools: () => Array<{
-            name: string;
-            description: string;
-            serverId: string;
-            isAvailable: boolean;
-            inputSchema?: Record<string, unknown>;
-        }>;
-        executeTool: (serverId: string, toolName: string, params: any) => Promise<any>;
-    };
-}
-/**
- * Interface for tool information in MCP servers
- */
-interface ToolInfo {
-    description?: string;
-    inputSchema?: ZodType<JsonValue>;
-    parameters?: ZodType<JsonValue>;
-    execute: (args: JsonValue) => Promise<JsonValue | ToolResult> | JsonValue | ToolResult;
-    isImplemented?: boolean;
-    metadata?: UnknownRecord;
-}
+import type { UnknownRecord } from "../types/common.js";
+import type { NeuroLink } from "../neurolink.js";
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -50,10 +15,12 @@ export declare abstract class BaseProvider implements AIProvider {
     protected readonly defaultTimeout: number;
     protected readonly directTools: {};
     protected mcpTools?: Record<string, Tool>;
+    protected customTools?: Map<string, unknown>;
+    protected toolExecutor?: (toolName: string, params: unknown) => Promise<unknown>;
     protected sessionId?: string;
     protected userId?: string;
-    protected sdk?: NeuroLinkSDK;
-    constructor(modelName?: string, providerName?: AIProviderName, sdk?: NeuroLinkSDK);
+    protected neurolink?: NeuroLink;
+    constructor(modelName?: string, providerName?: AIProviderName, neurolink?: NeuroLink);
     /**
      * Check if this provider supports tool/function calling
      * Override in subclasses to disable tools for specific providers or models
@@ -176,4 +143,3 @@ export declare abstract class BaseProvider implements AIProvider {
      */
     static chunkPrompt(prompt: string, maxChunkSize?: number, overlap?: number): string[];
 }
-export {};