@juspay/neurolink 7.13.0 → 7.14.1

package/dist/providers/googleVertex.d.ts

@@ -25,7 +25,7 @@ export declare class GoogleVertexProvider extends BaseProvider {
     private static readonly MAX_CACHE_SIZE;
     private static maxTokensCache;
     private static maxTokensCacheTime;
-    constructor(modelName?: string, sdk?: unknown);
+    constructor(modelName?: string, providerName?: string, sdk?: unknown);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**
@@ -90,6 +90,12 @@ export declare class GoogleVertexProvider extends BaseProvider {
      * @returns The current tool execution context
      */
     getToolContext(): Record<string, unknown>;
+    /**
+     * Set the tool executor function for custom tool execution
+     * This method is called by BaseProvider.setupToolExecutor()
+     * @param executor Function to execute tools by name
+     */
+    setToolExecutor(executor: (toolName: string, params: unknown) => Promise<unknown>): void;
     /**
      * Clear all static caches - useful for testing and memory cleanup
      * Public method to allow external cache management

package/dist/providers/googleVertex.js

@@ -125,7 +125,7 @@ export class GoogleVertexProvider extends BaseProvider {
     // Memory-managed cache for maxTokens handling decisions to optimize streaming performance
     static maxTokensCache = new Map();
     static maxTokensCacheTime = 0;
-    constructor(modelName, sdk) {
+    constructor(modelName, providerName, sdk) {
         super(modelName, "vertex", sdk);
         // Validate Google Cloud credentials - now using consolidated utility
         if (!hasGoogleCredentials()) {
@@ -198,6 +198,14 @@ export class GoogleVertexProvider extends BaseProvider {
                 hasSchema: !!analysisSchema,
             });
             const model = await this.getModel();
+            // Get all available tools (direct + MCP + external) for streaming
+            const shouldUseTools = !options.disableTools && this.supportsTools();
+            const tools = shouldUseTools ? await this.getAllTools() : {};
+            logger.debug(`${functionTag}: Tools for streaming`, {
+                shouldUseTools,
+                toolCount: Object.keys(tools).length,
+                toolNames: Object.keys(tools),
+            });
             // Model-specific maxTokens handling
             const modelName = this.modelName || getDefaultVertexModel();
             // Use cached model configuration to determine maxTokens handling for streaming performance
@@ -206,18 +214,19 @@ export class GoogleVertexProvider extends BaseProvider {
             const maxTokens = shouldSetMaxTokens
                 ? options.maxTokens || DEFAULT_MAX_TOKENS
                 : undefined;
-            // Get tools consistently with generate method (using BaseProvider pattern)
-            const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools ? await this.getAllTools() : {};
             // Build complete stream options with proper typing
             let streamOptions = {
                 model: model,
                 messages: messages,
                 temperature: options.temperature,
                 ...(maxTokens && { maxTokens }),
-                tools,
-                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-                toolChoice: shouldUseTools ? "auto" : "none",
+                // Add tools support for streaming
+                ...(shouldUseTools &&
+                    Object.keys(tools).length > 0 && {
+                    tools,
+                    toolChoice: "auto",
+                    maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
+                }),
                 abortSignal: timeoutController?.controller.signal,
                 onError: (event) => {
                     const error = event.error;
@@ -258,10 +267,17 @@ export class GoogleVertexProvider extends BaseProvider {
             timeoutController?.cleanup();
             // Transform string stream to content object stream using BaseProvider method
             const transformedStream = this.createTextStream(result);
+            // Track tool calls and results for streaming
+            const toolCalls = [];
+            const toolResults = [];
             return {
                 stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
+                ...(shouldUseTools && {
+                    toolCalls,
+                    toolResults,
+                }),
             };
         }
         catch (error) {
@@ -488,6 +504,17 @@ export class GoogleVertexProvider extends BaseProvider {
     getToolContext() {
         return { ...this.toolContext };
     }
+    /**
+     * Set the tool executor function for custom tool execution
+     * This method is called by BaseProvider.setupToolExecutor()
+     * @param executor Function to execute tools by name
+     */
+    setToolExecutor(executor) {
+        this.toolExecutor = executor;
+        logger.debug("GoogleVertexProvider.setToolExecutor: Tool executor set", {
+            hasExecutor: typeof executor === "function",
+        });
+    }
     /**
      * Clear all static caches - useful for testing and memory cleanup
      * Public method to allow external cache management

package/dist/providers/huggingFace.js

@@ -87,7 +87,7 @@ export class HuggingFaceProvider extends BaseProvider {
             "openchat",
             "wizardcoder",
         ];
-        // Check if current model matches any tool-capable model patterns
+        // Check if current model matches tool-capable model patterns
         const isToolCapable = toolCapableModels.some((capableModel) => modelName.includes(capableModel));
         if (isToolCapable) {
             logger.debug("HuggingFace tool calling enabled", {

package/dist/providers/mistral.js

@@ -21,11 +21,11 @@ const getDefaultMistralModel = () => {
 export class MistralProvider extends BaseProvider {
     model;
     constructor(modelName, sdk) {
-        // Type guard for NeuroLinkSDK parameter validation
-        const validatedSdk = sdk && typeof sdk === "object" && "getInMemoryServers" in sdk
+        // Type guard for NeuroLink parameter validation
+        const validatedNeurolink = sdk && typeof sdk === "object" && "getInMemoryServers" in sdk
             ? sdk
             : undefined;
-        super(modelName, "mistral", validatedSdk);
+        super(modelName, "mistral", validatedNeurolink);
         // Initialize Mistral model with API key validation
         const apiKey = getMistralApiKey();
         const mistral = createMistral({

package/dist/providers/ollama.js

@@ -270,7 +270,7 @@ export class OllamaProvider extends BaseProvider {
         // Get tool-capable models from configuration
         const ollamaConfig = modelConfig.getProviderConfig("ollama");
         const toolCapableModels = ollamaConfig?.modelBehavior?.toolCapableModels || [];
-        // Check if current model matches any tool-capable model patterns
+        // Check if current model matches tool-capable model patterns
         const isToolCapable = toolCapableModels.some((capableModel) => modelName.includes(capableModel));
         if (isToolCapable) {
             logger.debug("Ollama tool calling enabled", {

package/dist/providers/openAI.d.ts

@@ -2,14 +2,15 @@ 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, type NeuroLinkSDK } from "../core/baseProvider.js";
+import { BaseProvider } from "../core/baseProvider.js";
+import type { NeuroLink } from "../neurolink.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, sdk?: NeuroLinkSDK);
+    constructor(modelName?: string, neurolink?: NeuroLink);
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**

package/dist/providers/openAI.js

@@ -21,8 +21,8 @@ const getOpenAIModel = () => {
  */
 export class OpenAIProvider extends BaseProvider {
     model;
-    constructor(modelName, sdk) {
-        super(modelName || getOpenAIModel(), AIProviderName.OPENAI, sdk);
+    constructor(modelName, neurolink) {
+        super(modelName || getOpenAIModel(), AIProviderName.OPENAI, neurolink);
         // Set OpenAI API key as environment variable (required by @ai-sdk/openai)
         process.env.OPENAI_API_KEY = getOpenAIApiKey();
         // Initialize model

package/dist/providers/openaiCompatible.d.ts

@@ -5,7 +5,7 @@ import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
 /**
  * OpenAI Compatible Provider - BaseProvider Implementation
- * Provides access to any OpenAI-compatible endpoint (OpenRouter, vLLM, LiteLLM, etc.)
+ * Provides access to one of the OpenAI-compatible endpoint (OpenRouter, vLLM, LiteLLM, etc.)
  */
 export declare class OpenAICompatibleProvider extends BaseProvider {
     private model?;

package/dist/providers/openaiCompatible.js

@@ -35,7 +35,7 @@ const getDefaultOpenAICompatibleModel = () => {
 };
 /**
  * OpenAI Compatible Provider - BaseProvider Implementation
- * Provides access to any OpenAI-compatible endpoint (OpenRouter, vLLM, LiteLLM, etc.)
+ * Provides access to one of the OpenAI-compatible endpoint (OpenRouter, vLLM, LiteLLM, etc.)
  */
 export class OpenAICompatibleProvider extends BaseProvider {
     model;
@@ -47,7 +47,7 @@ export class OpenAICompatibleProvider extends BaseProvider {
         // Initialize OpenAI Compatible configuration
         this.config = getOpenAICompatibleConfig();
         // Create OpenAI SDK instance configured for custom endpoint
-        // This allows us to use any OpenAI-compatible API by simply changing the baseURL
+        // This allows us to use OpenAI-compatible API by simply changing the baseURL
         this.customOpenAI = createOpenAI({
             baseURL: this.config.baseURL,
             apiKey: this.config.apiKey,

package/dist/providers/sagemaker/config.js

@@ -168,7 +168,7 @@ function checkAccessKeyPresence(accessKeyId) {
     if (!accessKeyId || accessKeyId.trim() === "") {
         return { isValid: false };
     }
-    // Accept any non-empty string - let AWS handle validation
+    // Accept non-empty string - let AWS handle validation
     // This prevents attackers from learning about valid formats
     return { isValid: true };
 }

package/dist/sdk/toolRegistration.d.ts

@@ -3,9 +3,8 @@
  * Simple interface for developers to register custom tools
  */
 import { z } from "zod";
-import type { Tool } from "ai";
 import { logger } from "../utils/logger.js";
-import type { InMemoryMCPServerConfig, InMemoryToolInfo } from "../types/mcpTypes.js";
+import type { MCPServerInfo, MCPServerCategory } from "../types/mcpTypes.js";
 import type { ToolArgs, ToolContext as CoreToolContext, ToolResult, SimpleTool as CoreSimpleTool } from "../types/tools.js";
 import type { JsonValue } from "../types/common.js";
 /**
@@ -76,24 +75,16 @@ export interface SimpleTool<TArgs = ToolArgs, TResult = JsonValue> extends Omit<
     };
 }
 /**
- * Converts a SimpleTool to Vercel AI SDK format
- */
-export declare function convertToAISDKTool(name: string, simpleTool: SimpleTool): Tool;
-/**
- * Converts a SimpleTool to MCP tool format
- */
-export declare function convertToMCPTool(simpleTool: SimpleTool): InMemoryToolInfo;
-/**
- * Creates an in-memory MCP server configuration from a set of tools
+ * Creates a MCPServerInfo from a set of tools
  */
 export declare function createMCPServerFromTools(serverId: string, tools: Record<string, SimpleTool>, metadata?: {
     title?: string;
     description?: string;
-    category?: string;
+    category?: MCPServerCategory;
     version?: string;
     author?: string;
     [key: string]: JsonValue | undefined;
-}): InMemoryMCPServerConfig;
+}): MCPServerInfo;
 /**
  * Helper to create a tool with type safety
  */

package/dist/sdk/toolRegistration.js

@@ -2,9 +2,8 @@
  * NeuroLink SDK Tool Registration API
  * Simple interface for developers to register custom tools
  */
-import { z } from "zod";
-import { tool as createAISDKTool } from "ai";
 import { logger } from "../utils/logger.js";
+import { createMCPServerInfo } from "../utils/mcpDefaults.js";
 /**
  * Configuration constants for tool validation
  */
@@ -65,75 +64,29 @@ const VALIDATION_CONFIG = {
     ].map((pattern) => new RegExp(pattern.replace(/_/g, "[_-]"), "i")),
 };
 /**
- * Converts a SimpleTool to Vercel AI SDK format
- */
-export function convertToAISDKTool(name, simpleTool) {
-    return createAISDKTool({
-        description: simpleTool.description,
-        parameters: simpleTool.parameters || z.object({}),
-        execute: async (args) => {
-            try {
-                // Create a minimal context for standalone execution
-                const context = {
-                    sessionId: `tool-${name}-${Date.now()}`,
-                    logger,
-                };
-                const result = await simpleTool.execute(args, context);
-                return result;
-            }
-            catch (error) {
-                logger.error(`Tool ${name} execution failed:`, error);
-                throw error;
-            }
-        },
-    });
-}
-/**
- * Converts a SimpleTool to MCP tool format
- */
-export function convertToMCPTool(simpleTool) {
-    return {
-        description: simpleTool.description,
-        execute: async (params) => {
-            const typedParams = params;
-            try {
-                const result = await simpleTool.execute(typedParams);
-                return {
-                    success: true,
-                    data: result,
-                };
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                logger.error("MCP tool execution failed:", error);
-                return {
-                    success: false,
-                    error: errorMessage,
-                };
-            }
-        },
-        inputSchema: simpleTool.parameters,
-        isImplemented: true,
-        metadata: simpleTool.metadata,
-    };
-}
-/**
- * Creates an in-memory MCP server configuration from a set of tools
+ * Creates a MCPServerInfo from a set of tools
  */
 export function createMCPServerFromTools(serverId, tools, metadata) {
-    const mcpTools = {};
+    const mcpTools = [];
     for (const [name, tool] of Object.entries(tools)) {
-        mcpTools[name] = convertToMCPTool(tool);
+        mcpTools.push({
+            name,
+            description: tool.description || name,
+            inputSchema: {},
+        });
     }
-    return {
-        server: {
-            title: metadata?.title || serverId,
-            description: metadata?.description,
-            tools: mcpTools,
-        },
+    // SMART DEFAULTS: Use utility to eliminate manual MCPServerInfo creation
+    return createMCPServerInfo({
+        id: serverId,
+        name: metadata?.title || serverId,
+        tools: mcpTools,
+        description: metadata?.description || serverId,
         category: metadata?.category,
-        metadata: metadata || {},
-    };
+        // Detect category based on context if not provided
+        isExternal: metadata?.category === "external",
+        isBuiltIn: metadata?.category === "built-in",
+        isCustomTool: false,
+    });
 }
 /**
  * Helper to create a tool with type safety

package/dist/types/cli.d.ts

@@ -1,6 +1,5 @@
 /**
  * CLI-specific type definitions for NeuroLink
- * Replaces 'any' types in CLI commands and arguments
  */
 import type { UnknownRecord, JsonValue } from "./common.js";
 import type { AnalyticsData, EvaluationData, TokenUsage } from "./providers.js";

package/dist/types/cli.js

@@ -1,6 +1,5 @@
 /**
  * CLI-specific type definitions for NeuroLink
- * Replaces 'any' types in CLI commands and arguments
  */
 /**
  * Type guard for generate result

package/dist/types/common.d.ts

@@ -1,9 +1,8 @@
 /**
  * Common utility types for NeuroLink
- * These types provide type-safe alternatives to 'any' usage
  */
 /**
- * Type-safe unknown value - use instead of 'any' when type is truly unknown
+ * Type-safe unknown value - use when type is truly unknown
  */
 export type Unknown = unknown;
 /**

package/dist/types/common.js

@@ -1,6 +1,5 @@
 /**
  * Common utility types for NeuroLink
- * These types provide type-safe alternatives to 'any' usage
  */
 /**
  * Type guard to check if value is Error

package/dist/types/contextTypes.d.ts

@@ -162,7 +162,7 @@ export declare class ContextConverter {
      */
     static convertBusinessContext(legacyContext: Record<string, unknown>, domainType: string, options?: ContextConversionOptions): ExecutionContext;
     /**
-     * Create execution context for any domain
+     * Create execution context for required domain
      */
     static createDomainContext(domainType: string, domainData: Record<string, unknown>, sessionInfo?: {
         sessionId?: string;

package/dist/types/contextTypes.js

@@ -327,7 +327,7 @@ export class ContextConverter {
                             projectId: legacyContext.projectId,
                         }
                         : {}),
-                    // Include any additional custom data
+                    // Include all additional custom data
                     ...this.extractCustomData(legacyContext),
                 },
             },
@@ -342,7 +342,7 @@ export class ContextConverter {
         };
     }
     /**
-     * Create execution context for any domain
+     * Create execution context for required domain
      */
     static createDomainContext(domainType, domainData, sessionInfo = {}) {
         return {
@@ -385,7 +385,7 @@ export class ContextConverter {
                 ...(config.additionalFields || []),
             ]);
         }
-        // Remove any fields that should be included despite being in the exclude list
+        // Remove filtered fields that should be included despite being in the exclude list
         if (config.includeFields) {
             config.includeFields.forEach((field) => fieldsToExclude.delete(field));
         }