@juspay/neurolink 7.10.2 → 7.11.0

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

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "7.10.2",
+  "version": "7.11.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",