@juspay/neurolink 7.10.3 → 7.11.0

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

@@ -38,346 +38,7 @@ export declare abstract class BaseProvider implements AIProvider {
     protected readonly modelName: string;
     protected readonly providerName: AIProviderName;
     protected readonly defaultTimeout: number;
-    protected readonly directTools: {
-        getCurrentTime: Tool<import("zod").ZodObject<{
-            timezone: import("zod").ZodOptional<import("zod").ZodString>;
-        }, "strip", import("zod").ZodTypeAny, {
-            timezone?: string | undefined;
-        }, {
-            timezone?: string | undefined;
-        }>, {
-            success: boolean;
-            time: string;
-            timezone: string;
-            iso: string;
-            timestamp?: undefined;
-            error?: undefined;
-        } | {
-            success: boolean;
-            time: string;
-            iso: string;
-            timestamp: number;
-            timezone?: undefined;
-            error?: undefined;
-        } | {
-            success: boolean;
-            error: string;
-            time?: undefined;
-            timezone?: undefined;
-            iso?: undefined;
-            timestamp?: undefined;
-        }> & {
-            execute: (args: {
-                timezone?: string | undefined;
-            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
-                success: boolean;
-                time: string;
-                timezone: string;
-                iso: string;
-                timestamp?: undefined;
-                error?: undefined;
-            } | {
-                success: boolean;
-                time: string;
-                iso: string;
-                timestamp: number;
-                timezone?: undefined;
-                error?: undefined;
-            } | {
-                success: boolean;
-                error: string;
-                time?: undefined;
-                timezone?: undefined;
-                iso?: undefined;
-                timestamp?: undefined;
-            }>;
-        };
-        readFile: Tool<import("zod").ZodObject<{
-            path: import("zod").ZodString;
-        }, "strip", import("zod").ZodTypeAny, {
-            path: string;
-        }, {
-            path: string;
-        }>, {
-            success: boolean;
-            error: string;
-            content?: undefined;
-            size?: undefined;
-            path?: undefined;
-            lastModified?: undefined;
-        } | {
-            success: boolean;
-            content: string;
-            size: number;
-            path: string;
-            lastModified: string;
-            error?: undefined;
-        } | {
-            success: boolean;
-            error: string;
-            path: string;
-            content?: undefined;
-            size?: undefined;
-            lastModified?: undefined;
-        }> & {
-            execute: (args: {
-                path: string;
-            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
-                success: boolean;
-                error: string;
-                content?: undefined;
-                size?: undefined;
-                path?: undefined;
-                lastModified?: undefined;
-            } | {
-                success: boolean;
-                content: string;
-                size: number;
-                path: string;
-                lastModified: string;
-                error?: undefined;
-            } | {
-                success: boolean;
-                error: string;
-                path: string;
-                content?: undefined;
-                size?: undefined;
-                lastModified?: undefined;
-            }>;
-        };
-        listDirectory: Tool<import("zod").ZodObject<{
-            path: import("zod").ZodString;
-            includeHidden: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
-        }, "strip", import("zod").ZodTypeAny, {
-            path: string;
-            includeHidden: boolean;
-        }, {
-            path: string;
-            includeHidden?: boolean | undefined;
-        }>, {
-            success: boolean;
-            path: string;
-            items: {
-                name: string;
-                type: string;
-                size: number | undefined;
-                lastModified: string;
-            }[];
-            count: number;
-            error?: undefined;
-        } | {
-            success: boolean;
-            error: string;
-            path: string;
-            items?: undefined;
-            count?: undefined;
-        }> & {
-            execute: (args: {
-                path: string;
-                includeHidden: boolean;
-            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
-                success: boolean;
-                path: string;
-                items: {
-                    name: string;
-                    type: string;
-                    size: number | undefined;
-                    lastModified: string;
-                }[];
-                count: number;
-                error?: undefined;
-            } | {
-                success: boolean;
-                error: string;
-                path: string;
-                items?: undefined;
-                count?: undefined;
-            }>;
-        };
-        calculateMath: Tool<import("zod").ZodObject<{
-            expression: import("zod").ZodString;
-            precision: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
-        }, "strip", import("zod").ZodTypeAny, {
-            expression: string;
-            precision: number;
-        }, {
-            expression: string;
-            precision?: number | undefined;
-        }>, {
-            success: boolean;
-            error: string;
-            expression?: undefined;
-            result?: undefined;
-            type?: undefined;
-        } | {
-            success: boolean;
-            expression: string;
-            result: any;
-            type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-            error?: undefined;
-        } | {
-            success: boolean;
-            error: string;
-            expression: string;
-            result?: undefined;
-            type?: undefined;
-        }> & {
-            execute: (args: {
-                expression: string;
-                precision: number;
-            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
-                success: boolean;
-                error: string;
-                expression?: undefined;
-                result?: undefined;
-                type?: undefined;
-            } | {
-                success: boolean;
-                expression: string;
-                result: any;
-                type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-                error?: undefined;
-            } | {
-                success: boolean;
-                error: string;
-                expression: string;
-                result?: undefined;
-                type?: undefined;
-            }>;
-        };
-        writeFile: Tool<import("zod").ZodObject<{
-            path: import("zod").ZodString;
-            content: import("zod").ZodString;
-            mode: import("zod").ZodDefault<import("zod").ZodEnum<["create", "overwrite", "append"]>>;
-        }, "strip", import("zod").ZodTypeAny, {
-            path: string;
-            content: string;
-            mode: "create" | "overwrite" | "append";
-        }, {
-            path: string;
-            content: string;
-            mode?: "create" | "overwrite" | "append" | undefined;
-        }>, {
-            success: boolean;
-            error: string;
-            path?: undefined;
-            mode?: undefined;
-            size?: undefined;
-            written?: undefined;
-        } | {
-            success: boolean;
-            path: string;
-            mode: "create" | "overwrite" | "append";
-            size: number;
-            written: number;
-            error?: undefined;
-        } | {
-            success: boolean;
-            error: string;
-            path: string;
-            mode?: undefined;
-            size?: undefined;
-            written?: undefined;
-        }> & {
-            execute: (args: {
-                path: string;
-                content: string;
-                mode: "create" | "overwrite" | "append";
-            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
-                success: boolean;
-                error: string;
-                path?: undefined;
-                mode?: undefined;
-                size?: undefined;
-                written?: undefined;
-            } | {
-                success: boolean;
-                path: string;
-                mode: "create" | "overwrite" | "append";
-                size: number;
-                written: number;
-                error?: undefined;
-            } | {
-                success: boolean;
-                error: string;
-                path: string;
-                mode?: undefined;
-                size?: undefined;
-                written?: undefined;
-            }>;
-        };
-        searchFiles: Tool<import("zod").ZodObject<{
-            directory: import("zod").ZodString;
-            pattern: import("zod").ZodString;
-            recursive: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
-        }, "strip", import("zod").ZodTypeAny, {
-            directory: string;
-            pattern: string;
-            recursive: boolean;
-        }, {
-            directory: string;
-            pattern: string;
-            recursive?: boolean | undefined;
-        }>, {
-            success: boolean;
-            error: string;
-            directory?: undefined;
-            pattern?: undefined;
-            matches?: undefined;
-            count?: undefined;
-        } | {
-            success: boolean;
-            directory: string;
-            pattern: string;
-            matches: {
-                name: string;
-                path: string;
-                size: number;
-                lastModified: string;
-            }[];
-            count: number;
-            error?: undefined;
-        } | {
-            success: boolean;
-            error: string;
-            directory: string;
-            pattern: string;
-            matches?: undefined;
-            count?: undefined;
-        }> & {
-            execute: (args: {
-                directory: string;
-                pattern: string;
-                recursive: boolean;
-            }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
-                success: boolean;
-                error: string;
-                directory?: undefined;
-                pattern?: undefined;
-                matches?: undefined;
-                count?: undefined;
-            } | {
-                success: boolean;
-                directory: string;
-                pattern: string;
-                matches: {
-                    name: string;
-                    path: string;
-                    size: number;
-                    lastModified: string;
-                }[];
-                count: number;
-                error?: undefined;
-            } | {
-                success: boolean;
-                error: string;
-                directory: string;
-                pattern: string;
-                matches?: undefined;
-                count?: undefined;
-            }>;
-        };
-    };
+    protected readonly directTools: {};
     protected mcpTools?: Record<string, Tool>;
     protected sessionId?: string;
     protected userId?: string;
@@ -433,6 +94,50 @@ export declare abstract class BaseProvider implements AIProvider {
      * Provider-specific error handling
      */
     protected abstract handleProviderError(error: unknown): Error;
+    /**
+     * Execute operation with timeout and proper cleanup
+     * Consolidates identical timeout handling from 8/10 providers
+     */
+    protected executeWithTimeout<T>(operation: () => Promise<T>, options: {
+        timeout?: number | string;
+        operationType?: string;
+    }): Promise<T>;
+    /**
+     * Validate stream options - consolidates validation from 7/10 providers
+     */
+    protected validateStreamOptions(options: StreamOptions): void;
+    /**
+     * Create text stream transformation - consolidates identical logic from 7/10 providers
+     */
+    protected createTextStream(result: {
+        textStream: AsyncIterable<string>;
+    }): AsyncGenerator<{
+        content: string;
+    }>;
+    /**
+     * Create standardized stream result - consolidates result structure
+     */
+    protected createStreamResult(stream: AsyncGenerator<{
+        content: string;
+    }>, additionalProps?: Partial<StreamResult>): StreamResult;
+    /**
+     * Create stream analytics - consolidates analytics from 4/10 providers
+     */
+    protected createStreamAnalytics(result: UnknownRecord, startTime: number, options: StreamOptions): Promise<UnknownRecord | undefined>;
+    /**
+     * Handle common error patterns - consolidates error handling from multiple providers
+     */
+    protected handleCommonErrors(error: unknown): Error | null;
+    /**
+     * 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: {
+        customTools: Map<string, unknown>;
+        executeTool: (toolName: string, params: unknown) => Promise<unknown>;
+    }, functionTag: string): void;
     protected normalizeTextOptions(optionsOrPrompt: TextGenerationOptions | string): TextGenerationOptions;
     protected normalizeStreamOptions(optionsOrPrompt: StreamOptions | string): StreamOptions;
     protected enhanceResult(result: EnhancedGenerateResult, options: TextGenerationOptions, startTime: number): Promise<EnhancedGenerateResult>;

package/dist/lib/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/lib/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/lib/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;
         }