@juspay/neurolink 7.10.3 → 7.11.1

package/dist/core/baseProvider.js

@@ -1,7 +1,9 @@
 import { logger } from "../utils/logger.js";
-import { SYSTEM_LIMITS } from "../core/constants.js";
+import { SYSTEM_LIMITS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { directAgentTools } from "../agent/directTools.js";
 import { getSafeMaxTokens } from "../utils/tokenLimits.js";
+import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
+import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
 /**
  * Validates if a result contains a valid toolsObject structure
  * @param result - The result object to validate
@@ -23,8 +25,10 @@ export class BaseProvider {
     modelName;
     providerName;
     defaultTimeout = 30000; // 30 seconds
-    // Tools are ALWAYS part of the provider - no flags, no conditions
-    directTools = directAgentTools;
+    // Tools are conditionally included based on centralized configuration
+    directTools = shouldDisableBuiltinTools()
+        ? {}
+        : directAgentTools;
     mcpTools; // MCP tools loaded dynamically when available
     sessionId;
     userId;
@@ -163,7 +167,7 @@ export class BaseProvider {
                 prompt: options.prompt || options.input?.text || "",
                 system: options.systemPrompt,
                 tools,
-                maxSteps: options.maxSteps || 5,
+                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || 8192,
@@ -290,33 +294,38 @@ export class BaseProvider {
                             for (const [toolName, toolInfo] of toolEntries) {
                                 if (toolInfo && typeof toolInfo.execute === "function") {
                                     logger.debug(`[BaseProvider] Converting custom tool: ${toolName}`);
-                                    // 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({}),
-                                        execute: async (args) => {
-                                            const result = await toolInfo.execute(args);
-                                            // Handle MCP-style results
-                                            if (result &&
-                                                typeof result === "object" &&
-                                                "success" in result) {
-                                                if (result.success) {
-                                                    return result.data;
+                                    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({}),
+                                            execute: async (args) => {
+                                                const result = await toolInfo.execute(args);
+                                                // 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);
+                                                    }
                                                 }
-                                                else {
-                                                    const errorMsg = typeof result.error === "string"
-                                                        ? result.error
-                                                        : "Tool execution failed";
-                                                    throw new Error(errorMsg);
-                                                }
-                                            }
-                                            return result;
-                                        },
-                                    });
+                                                return result;
+                                            },
+                                        });
+                                    }
+                                    catch (toolCreationError) {
+                                        logger.error(`Failed to create tool: ${toolName}`, toolCreationError);
+                                    }
                                 }
                             }
                         }
@@ -348,6 +357,172 @@ export class BaseProvider {
         this.userId = userId;
     }
     // ===================
+    // CONSOLIDATED PROVIDER METHODS - MOVED FROM INDIVIDUAL PROVIDERS
+    // ===================
+    /**
+     * Execute operation with timeout and proper cleanup
+     * Consolidates identical timeout handling from 8/10 providers
+     */
+    async executeWithTimeout(operation, options) {
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, options.operationType || "generate");
+        try {
+            if (timeoutController) {
+                return await Promise.race([
+                    operation(),
+                    new Promise((_, reject) => {
+                        timeoutController.controller.signal.addEventListener("abort", () => {
+                            reject(new TimeoutError(`${this.providerName} operation timed out`, timeoutController.timeoutMs, this.providerName, options.operationType ||
+                                "generate"));
+                        });
+                    }),
+                ]);
+            }
+            else {
+                return await operation();
+            }
+        }
+        finally {
+            timeoutController?.cleanup();
+        }
+    }
+    /**
+     * Validate stream options - consolidates validation from 7/10 providers
+     */
+    validateStreamOptions(options) {
+        if (!options.input?.text || options.input.text.trim().length === 0) {
+            throw new Error("Input text is required and cannot be empty");
+        }
+        if (options.temperature !== undefined) {
+            if (options.temperature < 0 || options.temperature > 2) {
+                throw new Error("temperature must be between 0 and 2");
+            }
+        }
+        if (options.maxTokens !== undefined) {
+            if (options.maxTokens < 1) {
+                throw new Error("maxTokens must be at least 1");
+            }
+        }
+    }
+    /**
+     * Create text stream transformation - consolidates identical logic from 7/10 providers
+     */
+    createTextStream(result) {
+        return (async function* () {
+            for await (const chunk of result.textStream) {
+                yield { content: chunk };
+            }
+        })();
+    }
+    /**
+     * Create standardized stream result - consolidates result structure
+     */
+    createStreamResult(stream, additionalProps = {}) {
+        return {
+            stream,
+            provider: this.providerName,
+            model: this.modelName,
+            ...additionalProps,
+        };
+    }
+    /**
+     * Create stream analytics - consolidates analytics from 4/10 providers
+     */
+    async createStreamAnalytics(result, startTime, options) {
+        try {
+            const { createAnalytics } = await import("./analytics.js");
+            const analytics = await createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
+                requestId: `${this.providerName}-stream-${Date.now()}`,
+                streamingMode: true,
+                ...options.context,
+            });
+            return analytics;
+        }
+        catch (error) {
+            logger.warn(`Analytics creation failed for ${this.providerName}:`, error);
+            return undefined;
+        }
+    }
+    /**
+     * Handle common error patterns - consolidates error handling from multiple providers
+     */
+    handleCommonErrors(error) {
+        if (error instanceof TimeoutError) {
+            return new Error(`${this.providerName} request timed out after ${error.timeout}ms. Consider increasing timeout or using a lighter model.`);
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        // Common API key errors
+        if (message.includes("API_KEY_INVALID") ||
+            message.includes("Invalid API key") ||
+            message.includes("authentication") ||
+            message.includes("unauthorized")) {
+            return new Error(`Invalid API key for ${this.providerName}. Please check your API key environment variable.`);
+        }
+        // Common rate limit errors
+        if (message.includes("rate limit") ||
+            message.includes("quota") ||
+            message.includes("429")) {
+            return new Error(`Rate limit exceeded for ${this.providerName}. Please wait before making more requests.`);
+        }
+        return null; // Not a common error, let provider handle it
+    }
+    /**
+     * Set up tool executor for a provider to enable actual tool execution
+     * Consolidates identical setupToolExecutor logic from neurolink.ts (used in 4 places)
+     * @param sdk - The NeuroLinkSDK instance for tool execution
+     * @param functionTag - Function name for logging
+     */
+    setupToolExecutor(sdk, functionTag) {
+        // Type guard to check for setToolExecutor method
+        function hasSetToolExecutor(obj) {
+            return (typeof obj === "object" &&
+                obj !== null &&
+                typeof obj.setToolExecutor ===
+                    "function");
+        }
+        if (!hasSetToolExecutor(this)) {
+            logger.warn(`[${functionTag}] Provider does not support setToolExecutor - tools will not be executed`, {
+                hasProvider: true,
+                providerType: this.constructor.name,
+                availableCustomTools: sdk.customTools.size,
+            });
+            return;
+        }
+        logger.debug(`[${functionTag}] Setting up tool executor for provider`, {
+            providerType: this.constructor.name,
+            availableCustomTools: sdk.customTools.size,
+        });
+        // Set up tool executor to handle actual tool calls
+        this.setToolExecutor(async (toolName, params) => {
+            logger.debug(`[${functionTag}] AI provider requesting tool execution: ${toolName}`, {
+                toolName,
+                params,
+                availableCustomTools: sdk.customTools.size,
+                hasRequestedTool: sdk.customTools.has(toolName),
+            });
+            try {
+                // Execute the tool using NeuroLink's executeTool method
+                const result = await sdk.executeTool(toolName, params);
+                logger.debug(`[${functionTag}] Tool execution successful: ${toolName}`, {
+                    toolName,
+                    result: typeof result === "object"
+                        ? JSON.stringify(result).substring(0, 200)
+                        : result,
+                    resultType: typeof result,
+                });
+                return result;
+            }
+            catch (error) {
+                logger.error(`[${functionTag}] Tool execution failed: ${toolName}`, {
+                    toolName,
+                    error: error instanceof Error ? error.message : String(error),
+                    params,
+                });
+                throw error;
+            }
+        });
+    }
+    // ===================
     // TEMPLATE METHODS - COMMON FUNCTIONALITY
     // ===================
     normalizeTextOptions(optionsOrPrompt) {

package/dist/core/types.d.ts

@@ -300,6 +300,10 @@ export interface AIProvider {
     stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
     generate(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
     gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<EnhancedGenerateResult | null>;
+    setupToolExecutor(sdk: {
+        customTools: Map<string, unknown>;
+        executeTool: (toolName: string, params: unknown) => Promise<unknown>;
+    }, functionTag: string): void;
 }
 /**
  * Provider attempt result for iteration tracking

package/dist/factories/providerFactory.js

@@ -60,7 +60,7 @@ export class ProviderFactory {
             if (result &&
                 typeof result === "object" &&
                 typeof result.then === "function") {
-                return await result;
+                result = await result;
             }
             return result;
         }

package/dist/factories/providerRegistry.js

@@ -24,17 +24,17 @@ export class ProviderRegistry {
             // Register providers with dynamic import factory functions
             const { ProviderFactory } = await import("./providerFactory.js");
             // Register Google AI Studio Provider (our validated baseline)
-            ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.GOOGLE_AI, async (modelName, _providerName, sdk) => {
                 const { GoogleAIStudioProvider } = await import("../providers/googleAiStudio.js");
                 return new GoogleAIStudioProvider(modelName, sdk);
             }, GoogleAIModels.GEMINI_2_5_FLASH, ["googleAiStudio", "google", "gemini", "google-ai"]);
             // Register OpenAI provider
-            ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.OPENAI, async (modelName, _providerName, sdk) => {
                 const { OpenAIProvider } = await import("../providers/openAI.js");
-                return new OpenAIProvider(modelName);
+                return new OpenAIProvider(modelName, sdk);
             }, OpenAIModels.GPT_4O_MINI, ["gpt", "chatgpt"]);
             // Register Anthropic provider
-            ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.ANTHROPIC, async (modelName, _providerName, sdk) => {
                 const { AnthropicProvider } = await import("../providers/anthropic.js");
                 return new AnthropicProvider(modelName, sdk);
             }, "claude-3-5-sonnet-20241022", ["claude", "anthropic"]);
@@ -62,7 +62,7 @@ export class ProviderRegistry {
                 return new HuggingFaceProvider(modelName);
             }, process.env.HUGGINGFACE_MODEL || "microsoft/DialoGPT-medium", ["huggingface", "hf"]);
             // Register Mistral AI provider
-            ProviderFactory.registerProvider(AIProviderName.MISTRAL, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.MISTRAL, async (modelName, _providerName, sdk) => {
                 const { MistralProvider } = await import("../providers/mistral.js");
                 return new MistralProvider(modelName, sdk);
             }, "mistral-large-latest", ["mistral"]);
@@ -72,18 +72,18 @@ export class ProviderRegistry {
                 return new OllamaProvider(modelName);
             }, process.env.OLLAMA_MODEL || "llama3.1:8b", ["ollama", "local"]);
             // Register LiteLLM provider
-            ProviderFactory.registerProvider(AIProviderName.LITELLM, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.LITELLM, async (modelName, _providerName, sdk) => {
                 const { LiteLLMProvider } = await import("../providers/litellm.js");
                 return new LiteLLMProvider(modelName, sdk);
             }, process.env.LITELLM_MODEL || "openai/gpt-4o-mini", ["litellm"]);
             // Register OpenAI Compatible provider
-            ProviderFactory.registerProvider(AIProviderName.OPENAI_COMPATIBLE, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.OPENAI_COMPATIBLE, async (modelName, _providerName, sdk) => {
                 const { OpenAICompatibleProvider } = await import("../providers/openaiCompatible.js");
                 return new OpenAICompatibleProvider(modelName, sdk);
             }, process.env.OPENAI_COMPATIBLE_MODEL || undefined, // Enable auto-discovery when no model specified
             ["openai-compatible", "openrouter", "vllm", "compatible"]);
             // Register Amazon SageMaker provider
-            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, providerName, sdk) => {
+            ProviderFactory.registerProvider(AIProviderName.SAGEMAKER, async (modelName, _providerName, _sdk) => {
                 const { AmazonSageMakerProvider } = await import("../providers/amazonSagemaker.js");
                 return new AmazonSageMakerProvider(modelName);
             }, process.env.SAGEMAKER_MODEL || "sagemaker-model", ["sagemaker", "aws-sagemaker"]);

package/dist/lib/config/types.d.ts

@@ -9,6 +9,7 @@ export interface NeuroLinkConfig {
     providers?: Record<string, ProviderConfig>;
     performance?: PerformanceConfig;
     analytics?: AnalyticsConfig;
+    tools?: ToolConfig;
     lastUpdated?: number;
     configVersion?: string;
     [key: string]: unknown;
@@ -90,6 +91,19 @@ export interface AnalyticsConfig {
         maxEntries?: number;
     };
 }
+/**
+ * Tool configuration
+ */
+export interface ToolConfig {
+    /** Whether built-in tools should be disabled */
+    disableBuiltinTools?: boolean;
+    /** Whether custom tools are allowed */
+    allowCustomTools?: boolean;
+    /** Maximum number of tools per provider */
+    maxToolsPerProvider?: number;
+    /** Whether MCP tools should be enabled */
+    enableMCPTools?: boolean;
+}
 /**
  * Backup metadata information
  */

package/dist/lib/config/types.js

@@ -39,5 +39,11 @@ export const DEFAULT_CONFIG = {
             maxEntries: 10000,
         },
     },
+    tools: {
+        disableBuiltinTools: false,
+        allowCustomTools: true,
+        maxToolsPerProvider: 100,
+        enableMCPTools: true,
+    },
     configVersion: "3.0.1",
 };