@juspay/neurolink 7.10.2 → 7.11.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [7.11.0](https://github.com/juspay/neurolink/compare/v7.10.3...v7.11.0) (2025-08-14)
+
+### Features
+
+- **(providers):** consolidate provider logic to BaseProvider for consistency and performance ([a5da739](https://github.com/juspay/neurolink/commit/a5da73982523f4cee57bbdf108b54a339a62d9b3))
+
+## [7.10.3](https://github.com/juspay/neurolink/compare/v7.10.2...v7.10.3) (2025-08-13)
+
+### Bug Fixes
+
+- **(ci):** make comment posting non-blocking for external contributor PRs ([f40b3f7](https://github.com/juspay/neurolink/commit/f40b3f75a8162df41461ef5ca1b2bb97d62719c2))
+
 ## [7.10.2](https://github.com/juspay/neurolink/compare/v7.10.1...v7.10.2) (2025-08-13)
 
 ### Bug Fixes

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

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