@juspay/neurolink 7.10.3 → 7.11.0

package/dist/lib/providers/mistral.d.ts

@@ -1,5 +1,6 @@
-import { type LanguageModelV1 } from "ai";
-import type { AIProviderName, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
+import type { ZodType, ZodTypeDef } from "zod";
+import { type Schema, type LanguageModelV1 } from "ai";
+import type { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**
@@ -9,30 +10,14 @@ import { BaseProvider } from "../core/baseProvider.js";
 export declare class MistralProvider extends BaseProvider {
     private model;
     constructor(modelName?: string, sdk?: unknown);
+    protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
+    protected getProviderName(): AIProviderName;
+    protected getDefaultModel(): string;
     /**
-     * Generate text using Mistral API
+     * Returns the Vercel AI SDK model instance for Mistral
      */
-    generate(options: TextGenerationOptions): Promise<EnhancedGenerateResult>;
-    /**
-     * Stream text generation using Mistral API
-     */
-    executeStream(options: StreamOptions): Promise<StreamResult>;
-    /**
-     * Get default model name for this provider
-     */
-    getDefaultModel(): string;
-    /**
-     * Get provider name
-     */
-    getProviderName(): AIProviderName;
-    /**
-     * Get AI SDK model instance
-     */
-    getAISDKModel(): LanguageModelV1;
-    /**
-     * Handle provider-specific errors
-     */
-    handleProviderError(error: unknown): Error;
+    protected getAISDKModel(): LanguageModelV1;
+    protected handleProviderError(error: unknown): Error;
     /**
      * Validate provider configuration
      */

package/dist/lib/providers/mistral.js

@@ -2,7 +2,8 @@ import { createMistral } from "@ai-sdk/mistral";
 import { streamText } from "ai";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { createAnalytics } from "../core/analytics.js";
+import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createMistralConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 // Configuration helpers - now using consolidated utility
@@ -29,85 +30,43 @@ export class MistralProvider extends BaseProvider {
         const mistral = createMistral({
             apiKey: apiKey,
         });
-        this.model = mistral(this.modelName || getDefaultMistralModel());
+        this.model = mistral(this.modelName);
         logger.debug("Mistral Provider v2 initialized", {
             modelName: this.modelName,
             providerName: this.providerName,
         });
     }
-    /**
-     * Generate text using Mistral API
-     */
-    async generate(options) {
-        const startTime = Date.now();
-        try {
-            const result = await this.model.doGenerate({
-                inputFormat: "prompt",
-                mode: { type: "regular" },
-                prompt: [
-                    {
-                        role: "user",
-                        content: [{ type: "text", text: options.prompt || "" }],
-                    },
-                ],
-                temperature: options.temperature,
-                maxTokens: options.maxTokens,
-            });
-            const responseTime = Date.now() - startTime;
-            // Extract token usage and text content
-            const tokenUsage = result.usage;
-            const textContent = result.text || "";
-            // Create analytics data using helper
-            const analytics = createAnalytics("mistral", this.modelName, { usage: tokenUsage, content: textContent }, responseTime, { requestId: `mistral-${Date.now()}` });
-            return {
-                content: textContent,
-                usage: {
-                    inputTokens: tokenUsage?.promptTokens || 0,
-                    outputTokens: tokenUsage?.completionTokens || 0,
-                    totalTokens: (tokenUsage?.promptTokens || 0) +
-                        (tokenUsage?.completionTokens || 0),
-                },
-                provider: this.providerName,
-                model: this.modelName,
-                analytics,
-            };
-        }
-        catch (error) {
-            const responseTime = Date.now() - startTime;
-            logger.error("Mistral generation failed", {
-                error: error instanceof Error ? error.message : String(error),
-                responseTime,
-            });
-            throw new Error(`Mistral generation failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    /**
-     * Stream text generation using Mistral API
-     */
-    async executeStream(options) {
+    // generate() method is inherited from BaseProvider; this provider uses the base implementation for generation with tools
+    async executeStream(options, analysisSchema) {
+        this.validateStreamOptions(options);
         const startTime = Date.now();
+        const timeout = this.getTimeout(options);
+        const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // Get tools consistently with generate method
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools ? await this.getAllTools() : {};
             const result = await streamText({
                 model: this.model,
                 prompt: options.input.text,
+                system: options.systemPrompt,
                 temperature: options.temperature,
-                maxTokens: options.maxTokens,
-                tools: options.tools,
-                toolChoice: "auto",
+                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+                tools,
+                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                toolChoice: shouldUseTools ? "auto" : "none",
+                abortSignal: timeoutController?.controller.signal,
             });
-            // Transform stream to match StreamResult interface
-            const transformedStream = async function* () {
-                for await (const chunk of result.textStream) {
-                    yield { content: chunk };
-                }
-            };
+            timeoutController?.cleanup();
+            // Transform string stream to content object stream using BaseProvider method
+            const transformedStream = this.createTextStream(result);
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
                 requestId: `mistral-stream-${Date.now()}`,
                 streamingMode: true,
             });
             return {
-                stream: transformedStream(),
+                stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
                 analytics: analyticsPromise,
@@ -118,38 +77,41 @@ export class MistralProvider extends BaseProvider {
             };
         }
         catch (error) {
-            logger.error("Mistral streaming failed", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw new Error(`Mistral streaming failed: ${error instanceof Error ? error.message : String(error)}`);
+            timeoutController?.cleanup();
+            throw this.handleProviderError(error);
         }
     }
-    /**
-     * Get default model name for this provider
-     */
-    getDefaultModel() {
-        return getDefaultMistralModel();
-    }
-    /**
-     * Get provider name
-     */
+    // ===================
+    // ABSTRACT METHOD IMPLEMENTATIONS
+    // ===================
     getProviderName() {
         return this.providerName;
     }
+    getDefaultModel() {
+        return getDefaultMistralModel();
+    }
     /**
-     * Get AI SDK model instance
+     * Returns the Vercel AI SDK model instance for Mistral
      */
     getAISDKModel() {
         return this.model;
     }
-    /**
-     * Handle provider-specific errors
-     */
     handleProviderError(error) {
-        if (error instanceof Error) {
-            return error;
+        if (error instanceof TimeoutError) {
+            return new Error(`Mistral request timed out: ${error.message}`);
+        }
+        const errorRecord = error;
+        const message = typeof errorRecord?.message === "string"
+            ? errorRecord.message
+            : "Unknown error";
+        if (message.includes("API_KEY_INVALID") ||
+            message.includes("Invalid API key")) {
+            return new Error("Invalid Mistral API key. Please check your MISTRAL_API_KEY environment variable.");
+        }
+        if (message.includes("rate limit")) {
+            return new Error("Mistral rate limit exceeded. Please try again later.");
         }
-        return new Error(`Mistral provider error: ${String(error)}`);
+        return new Error(`Mistral error: ${message}`);
     }
     /**
      * Validate provider configuration

package/dist/lib/providers/ollama.d.ts

@@ -75,7 +75,6 @@ export declare class OllamaProvider extends BaseProvider {
      */
     private createOllamaStream;
     protected handleProviderError(error: unknown): Error;
-    private validateStreamOptions;
     /**
      * Check if Ollama service is healthy and accessible
      */

package/dist/lib/providers/ollama.js

@@ -560,18 +560,6 @@ export class OllamaProvider extends BaseProvider {
         }
         return new Error(`❌ Ollama Provider Error\n\n${error.message || "Unknown error occurred"}\n\n🔧 Troubleshooting:\n1. Check if Ollama service is running\n2. Verify model is installed: 'ollama list'\n3. Check network connectivity to ${this.baseUrl}\n4. Review Ollama logs for details`);
     }
-    validateStreamOptions(options) {
-        if (!options.input?.text?.trim()) {
-            throw new Error("Prompt is required for streaming");
-        }
-        if (options.maxTokens && options.maxTokens < 1) {
-            throw new Error("maxTokens must be greater than 0");
-        }
-        if (options.temperature &&
-            (options.temperature < 0 || options.temperature > 2)) {
-            throw new Error("temperature must be between 0 and 2");
-        }
-    }
     /**
      * Check if Ollama service is healthy and accessible
      */

package/dist/lib/providers/openAI.d.ts

@@ -2,14 +2,14 @@ import type { ZodType, ZodTypeDef } from "zod";
 import { type Schema, type LanguageModelV1 } from "ai";
 import { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
-import { BaseProvider } from "../core/baseProvider.js";
+import { BaseProvider, type NeuroLinkSDK } from "../core/baseProvider.js";
 /**
  * OpenAI Provider v2 - BaseProvider Implementation
  * Migrated to use factory pattern with exact Google AI provider pattern
  */
 export declare class OpenAIProvider extends BaseProvider {
     private model;
-    constructor(modelName?: string);
+    constructor(modelName?: string, sdk?: NeuroLinkSDK);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**
@@ -23,6 +23,5 @@ export declare class OpenAIProvider extends BaseProvider {
      * and the migration guide in the project repository.
      */
     protected executeStream(options: StreamOptions, analysisSchema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>): Promise<StreamResult>;
-    private validateStreamOptions;
 }
 export default OpenAIProvider;

package/dist/lib/providers/openAI.js

@@ -4,7 +4,7 @@ import { AIProviderName } from "../core/types.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
 import { createTimeoutController, TimeoutError, } from "../utils/timeout.js";
-import { DEFAULT_MAX_TOKENS } from "../core/constants.js";
+import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
 import { validateApiKey, createOpenAIConfig, getProviderModel, } from "../utils/providerConfig.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 // Configuration helpers - now using consolidated utility
@@ -20,8 +20,8 @@ const getOpenAIModel = () => {
  */
 export class OpenAIProvider extends BaseProvider {
     model;
-    constructor(modelName) {
-        super(modelName, AIProviderName.OPENAI);
+    constructor(modelName, sdk) {
+        super(modelName || getOpenAIModel(), AIProviderName.OPENAI, sdk);
         // Set OpenAI API key as environment variable (required by @ai-sdk/openai)
         process.env.OPENAI_API_KEY = getOpenAIApiKey();
         // Initialize model
@@ -74,30 +74,30 @@ export class OpenAIProvider extends BaseProvider {
         const timeout = this.getTimeout(options);
         const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
         try {
+            // Get tools consistently with generate method
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools ? await this.getAllTools() : {};
             const result = await streamText({
                 model: this.model,
                 prompt: options.input.text,
                 system: options.systemPrompt,
                 temperature: options.temperature,
                 maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
-                tools: options.tools,
-                toolChoice: "auto",
+                tools,
+                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                toolChoice: shouldUseTools ? "auto" : "none",
                 abortSignal: timeoutController?.controller.signal,
             });
             timeoutController?.cleanup();
-            // Transform stream to match StreamResult interface
-            const transformedStream = async function* () {
-                for await (const chunk of result.textStream) {
-                    yield { content: chunk };
-                }
-            };
+            // Transform stream to match StreamResult interface using BaseProvider method
+            const transformedStream = this.createTextStream(result);
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
                 requestId: `openai-stream-${Date.now()}`,
                 streamingMode: true,
             });
             return {
-                stream: transformedStream(),
+                stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
                 analytics: analyticsPromise,
@@ -112,14 +112,6 @@ export class OpenAIProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
-    // ===================
-    // PRIVATE VALIDATION METHODS
-    // ===================
-    validateStreamOptions(options) {
-        if (!options.input?.text || options.input.text.trim().length === 0) {
-            throw new Error("Input text is required and cannot be empty");
-        }
-    }
 }
 // Export for factory registration
 export default OpenAIProvider;

package/dist/lib/providers/openaiCompatible.d.ts

@@ -45,5 +45,4 @@ export declare class OpenAICompatibleProvider extends BaseProvider {
      * Fallback models when discovery fails
      */
     private getFallbackModels;
-    private validateStreamOptions;
 }

package/dist/lib/providers/openaiCompatible.js

@@ -249,12 +249,4 @@ export class OpenAICompatibleProvider extends BaseProvider {
             "gemini-pro",
         ];
     }
-    // ===================
-    // PRIVATE VALIDATION METHODS
-    // ===================
-    validateStreamOptions(options) {
-        if (!options.input?.text || options.input.text.trim().length === 0) {
-            throw new Error("Input text is required and cannot be empty");
-        }
-    }
 }

package/dist/lib/utils/toolUtils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Tool Utilities - Centralized tool configuration access
+ *
+ * Consolidates environment variable access to avoid scattered process.env calls
+ */
+import type { ToolConfig } from "../config/types.js";
+/**
+ * Check if built-in tools should be disabled
+ * Centralized function to replace direct process.env access
+ *
+ * @param toolConfig - Optional tool configuration (if available from config)
+ * @returns true if built-in tools should be disabled
+ */
+export declare function shouldDisableBuiltinTools(toolConfig?: ToolConfig): boolean;
+/**
+ * Check if custom tools should be allowed
+ * @param toolConfig - Optional tool configuration
+ * @returns true if custom tools should be allowed
+ */
+export declare function shouldAllowCustomTools(toolConfig?: ToolConfig): boolean;
+/**
+ * Check if MCP tools should be enabled
+ * @param toolConfig - Optional tool configuration
+ * @returns true if MCP tools should be enabled
+ */
+export declare function shouldEnableMCPTools(toolConfig?: ToolConfig): boolean;
+/**
+ * Get maximum tools per provider
+ * @param toolConfig - Optional tool configuration
+ * @returns maximum number of tools per provider
+ */
+export declare function getMaxToolsPerProvider(toolConfig?: ToolConfig): number;

package/dist/lib/utils/toolUtils.js

@@ -0,0 +1,60 @@
+/**
+ * Tool Utilities - Centralized tool configuration access
+ *
+ * Consolidates environment variable access to avoid scattered process.env calls
+ */
+/**
+ * Check if built-in tools should be disabled
+ * Centralized function to replace direct process.env access
+ *
+ * @param toolConfig - Optional tool configuration (if available from config)
+ * @returns true if built-in tools should be disabled
+ */
+export function shouldDisableBuiltinTools(toolConfig) {
+    // Priority: explicit config > environment variable > default (false)
+    if (toolConfig?.disableBuiltinTools !== undefined) {
+        return toolConfig.disableBuiltinTools;
+    }
+    // Single source of truth for environment variable access
+    return process.env.NEUROLINK_DISABLE_BUILTIN_TOOLS === "true";
+}
+/**
+ * Check if custom tools should be allowed
+ * @param toolConfig - Optional tool configuration
+ * @returns true if custom tools should be allowed
+ */
+export function shouldAllowCustomTools(toolConfig) {
+    if (toolConfig?.allowCustomTools !== undefined) {
+        return toolConfig.allowCustomTools;
+    }
+    return process.env.NEUROLINK_DISABLE_CUSTOM_TOOLS !== "true";
+}
+/**
+ * Check if MCP tools should be enabled
+ * @param toolConfig - Optional tool configuration
+ * @returns true if MCP tools should be enabled
+ */
+export function shouldEnableMCPTools(toolConfig) {
+    if (toolConfig?.enableMCPTools !== undefined) {
+        return toolConfig.enableMCPTools;
+    }
+    return process.env.NEUROLINK_DISABLE_MCP_TOOLS !== "true";
+}
+/**
+ * Get maximum tools per provider
+ * @param toolConfig - Optional tool configuration
+ * @returns maximum number of tools per provider
+ */
+export function getMaxToolsPerProvider(toolConfig) {
+    if (toolConfig?.maxToolsPerProvider !== undefined) {
+        return toolConfig.maxToolsPerProvider;
+    }
+    const envMax = process.env.NEUROLINK_MAX_TOOLS_PER_PROVIDER;
+    if (envMax) {
+        const parsed = parseInt(envMax, 10);
+        if (!isNaN(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    return 100; // Default
+}

package/dist/mcp/servers/agent/directToolsServer.js

@@ -5,6 +5,7 @@
 import { createMCPServer } from "../../factory.js";
 import { directAgentTools } from "../../../agent/directTools.js";
 import { logger } from "../../../utils/logger.js";
+import { shouldDisableBuiltinTools } from "../../../utils/toolUtils.js";
 /**
  * Direct Tools Server - Agent direct tools for immediate use
  */
@@ -17,58 +18,77 @@ export const directToolsServer = createMCPServer({
 });
 /**
  * Wrap each direct tool and register it with the server
+ * Only register if built-in tools are not disabled
  */
-Object.entries(directAgentTools).forEach(([toolName, toolDef]) => {
-    // The toolDef is a Vercel AI SDK Tool object
-    // Extract properties from the Tool object
-    const toolSpec = toolDef._spec || toolDef;
-    const description = typeof toolSpec === "object" &&
-        toolSpec &&
-        "description" in toolSpec &&
-        typeof toolSpec.description === "string"
-        ? toolSpec.description
-        : `Direct tool: ${toolName}`;
-    const inputSchema = typeof toolSpec === "object" && toolSpec && "parameters" in toolSpec
-        ? toolSpec.parameters
-        : undefined;
-    const execute = typeof toolSpec === "object" && toolSpec && "execute" in toolSpec
-        ? toolSpec.execute
-        : undefined;
-    directToolsServer.registerTool({
-        name: toolName,
-        description: description,
-        category: getToolCategory(toolName),
-        inputSchema: inputSchema,
-        isImplemented: true,
-        execute: async (params, context) => {
-            const startTime = Date.now();
-            try {
-                logger.debug(`[Direct Tools] Executing ${toolName} with params:`, params);
-                // Execute the direct tool
-                if (!execute || typeof execute !== "function") {
-                    throw new Error(`Tool ${toolName} has no execute function`);
+if (!shouldDisableBuiltinTools()) {
+    Object.entries(directAgentTools).forEach(([toolName, toolDef]) => {
+        // The toolDef is a Vercel AI SDK Tool object
+        // Extract properties from the Tool object
+        const toolSpec = toolDef._spec || toolDef;
+        const description = typeof toolSpec === "object" &&
+            toolSpec &&
+            "description" in toolSpec &&
+            typeof toolSpec.description === "string"
+            ? toolSpec.description
+            : `Direct tool: ${toolName}`;
+        const inputSchema = typeof toolSpec === "object" && toolSpec && "parameters" in toolSpec
+            ? toolSpec.parameters
+            : undefined;
+        const execute = typeof toolSpec === "object" && toolSpec && "execute" in toolSpec
+            ? toolSpec.execute
+            : undefined;
+        directToolsServer.registerTool({
+            name: toolName,
+            description: description,
+            category: getToolCategory(toolName),
+            inputSchema: inputSchema,
+            isImplemented: true,
+            execute: async (params, context) => {
+                const startTime = Date.now();
+                try {
+                    logger.debug(`[Direct Tools] Executing ${toolName} with params:`, params);
+                    // Execute the direct tool
+                    if (!execute || typeof execute !== "function") {
+                        throw new Error(`Tool ${toolName} has no execute function`);
+                    }
+                    const result = await execute(params);
+                    // Convert direct tool result to ToolResult format
+                    if (result?.success) {
+                        return {
+                            success: true,
+                            data: result.data || result,
+                            usage: {
+                                executionTime: Date.now() - startTime,
+                            },
+                            metadata: {
+                                toolName,
+                                serverId: "neurolink-direct",
+                                sessionId: context.sessionId,
+                            },
+                        };
+                    }
+                    else {
+                        return {
+                            success: false,
+                            data: null,
+                            error: String(result?.error) || "Unknown error",
+                            usage: {
+                                executionTime: Date.now() - startTime,
+                            },
+                            metadata: {
+                                toolName,
+                                serverId: "neurolink-direct",
+                                sessionId: context.sessionId,
+                            },
+                        };
+                    }
                 }
-                const result = await execute(params);
-                // Convert direct tool result to ToolResult format
-                if (result?.success) {
-                    return {
-                        success: true,
-                        data: result.data || result,
-                        usage: {
-                            executionTime: Date.now() - startTime,
-                        },
-                        metadata: {
-                            toolName,
-                            serverId: "neurolink-direct",
-                            sessionId: context.sessionId,
-                        },
-                    };
-                }
-                else {
+                catch (error) {
+                    logger.error(`[Direct Tools] Error executing ${toolName}:`, error);
                     return {
                         success: false,
                         data: null,
-                        error: String(result?.error) || "Unknown error",
+                        error: error instanceof Error ? error.message : String(error),
                         usage: {
                             executionTime: Date.now() - startTime,
                         },
@@ -79,26 +99,13 @@ Object.entries(directAgentTools).forEach(([toolName, toolDef]) => {
                         },
                     };
                 }
-            }
-            catch (error) {
-                logger.error(`[Direct Tools] Error executing ${toolName}:`, error);
-                return {
-                    success: false,
-                    data: null,
-                    error: error instanceof Error ? error.message : String(error),
-                    usage: {
-                        executionTime: Date.now() - startTime,
-                    },
-                    metadata: {
-                        toolName,
-                        serverId: "neurolink-direct",
-                        sessionId: context.sessionId,
-                    },
-                };
-            }
-        },
+            },
+        });
     });
-});
+}
+else {
+    logger.info("[Direct Tools] Built-in tools disabled via configuration");
+}
 /**
  * Get tool category based on tool name
  */
@@ -117,5 +124,10 @@ function getToolCategory(toolName) {
             return "utility";
     }
 }
-// Log successful registration
-logger.info(`[Direct Tools] Registered ${Object.keys(directAgentTools).length} direct tools`);
+// Log successful registration or disable status
+if (!shouldDisableBuiltinTools()) {
+    logger.info(`[Direct Tools] Registered ${Object.keys(directAgentTools).length} direct tools`);
+}
+else {
+    logger.info("[Direct Tools] 0 direct tools registered (disabled via environment variable)");
+}