@juspay/neurolink 7.14.0 → 7.14.1

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));
         }

package/dist/types/externalMcp.d.ts

@@ -66,6 +66,12 @@ export interface ExternalMCPServerInstance {
     maxReconnectAttempts: number;
     /** Available tools from this server */
     tools: Map<string, ExternalMCPToolInfo>;
+    /** Cached tools array for ZERO conversion - MCP format */
+    toolsArray?: Array<{
+        name: string;
+        description: string;
+        inputSchema?: object;
+    }>;
     /** Server capabilities reported by MCP */
     capabilities?: Record<string, JsonValue>;
     /** Health monitoring timer */

package/dist/types/externalMcp.js

@@ -4,3 +4,4 @@
  * Following MCP 2024-11-05 specification
  */
 export {};
+// Note: In Phase 2, these interfaces will be consolidated into MCPServerInfo

package/dist/types/index.d.ts

@@ -1,6 +1,5 @@
 /**
  * Centralized type exports for NeuroLink
- * Provides type-safe alternatives to 'any' usage throughout the codebase
  */
 export * from "./common.js";
 export * from "./tools.js";
@@ -10,8 +9,8 @@ export type { Unknown, UnknownRecord, UnknownArray, JsonValue, JsonObject, JsonA
 export type { ToolArgs, ToolContext, ToolResult, ToolDefinition, SimpleTool, AvailableTool, ToolExecution, } from "./tools.js";
 export type { AISDKModel, ProviderError, TokenUsage, AnalyticsData, EvaluationData, ProviderConfig, } from "./providers.js";
 export type { BaseCommandArgs, GenerateCommandArgs, MCPCommandArgs, ModelsCommandArgs, CommandResult, GenerateResult, StreamChunk, } from "./cli.js";
-export type { MCPTransportType, MCPServerStatus, MCPDiscoveredServer, MCPConnectedServer, MCPServerConfig, MCPToolInfo, MCPServerMetadata, MCPToolMetadata, MCPServerRegistryEntry, } from "./mcpTypes.js";
-export type { ExternalMCPServerConfig, ExternalMCPServerInstance, ExternalMCPServerStatus, ExternalMCPToolInfo, ExternalMCPServerHealth, ExternalMCPConfigValidation, ExternalMCPOperationResult, ExternalMCPToolContext, ExternalMCPToolResult, ExternalMCPServerEvents, ExternalMCPManagerConfig, } from "./externalMcp.js";
+export type { MCPTransportType, MCPServerConnectionStatus, MCPServerCategory, MCPServerStatus, MCPDiscoveredServer, MCPConnectedServer, MCPToolInfo, MCPExecutableTool, MCPServerMetadata, MCPToolMetadata, MCPServerRegistryEntry, } from "./mcpTypes.js";
+export type { ExternalMCPServerInstance, ExternalMCPServerStatus, ExternalMCPToolInfo, ExternalMCPServerHealth, ExternalMCPConfigValidation, ExternalMCPOperationResult, ExternalMCPToolContext, ExternalMCPToolResult, ExternalMCPServerEvents, ExternalMCPManagerConfig, } from "./externalMcp.js";
 export type { ModelCapability, ModelUseCase, ModelFilter, ModelResolutionContext, ModelStats, ModelPricing, } from "./providers.js";
 export type { ToolCallResults, ToolCalls, StreamAnalyticsData, } from "./streamTypes.js";
 export type { DomainType, DomainConfig, DomainTemplate, DomainConfigOptions, DomainEvaluationCriteria, DomainValidationRule, } from "./domainTypes.js";

package/dist/types/index.js

@@ -1,6 +1,5 @@
 /**
  * Centralized type exports for NeuroLink
- * Provides type-safe alternatives to 'any' usage throughout the codebase
  */
 // Common utility types
 export * from "./common.js";

package/dist/types/mcpTypes.d.ts

@@ -6,93 +6,57 @@ import type { JsonValue, JsonObject } from "./common.js";
 /**
  * In-memory MCP server configuration
  */
-export interface InMemoryMCPServerConfig {
-    /**
-     * The actual server instance with tools
-     */
-    server: {
-        /**
-         * Server title for display
-         */
-        title?: string;
-        /**
-         * Map of tool name to tool implementation
-         */
-        tools: Map<string, InMemoryToolInfo> | Record<string, InMemoryToolInfo>;
-        /**
-         * Optional server description
-         */
-        description?: string;
-    };
-    /**
-     * Category for grouping tools
-     */
-    category?: string;
-    /**
-     * Metadata about the server
-     */
-    metadata?: {
-        provider?: string;
-        version?: string;
-        author?: string;
-        [key: string]: unknown;
-    };
-}
 /**
- * In-memory tool information
+ * MCP Transport Types - Maximally Reusable
  */
-export interface InMemoryToolInfo {
-    /**
-     * Tool description
-     */
-    description: string;
-    /**
-     * Tool execution function
-     */
-    execute: (params: unknown) => Promise<InMemoryToolResult> | InMemoryToolResult;
-    /**
-     * Input parameter schema (Zod or JSON Schema)
-     */
-    inputSchema?: unknown;
-    /**
-     * Whether the tool is implemented (default: true)
-     */
-    isImplemented?: boolean;
-    /**
-     * Optional metadata
-     */
-    metadata?: Record<string, unknown>;
-}
+export type MCPTransportType = "stdio" | "sse" | "websocket" | "ws" | "tcp" | "unix";
 /**
- * Result from in-memory tool execution
+ * MCP Server Connection Status - Individual server status
  */
-export interface InMemoryToolResult {
-    /**
-     * Whether execution was successful
-     */
-    success: boolean;
-    /**
-     * Result data if successful
-     */
-    data?: unknown;
-    /**
-     * Error message if failed
-     */
+export type MCPServerConnectionStatus = "initializing" | "connecting" | "connected" | "disconnected" | "failed" | "restarting" | "stopping" | "stopped";
+/**
+ * MCP Server Category Types - Organizational classification
+ */
+export type MCPServerCategory = "external" | "in-memory" | "built-in" | "user-defined" | "custom" | "uncategorized";
+/**
+ * Universal MCP Server - Unified configuration and runtime state
+ * MCP 2024-11-05 specification compliant
+ * Replaces both MCPServerInfo and MCPServerConfig
+ */
+export interface MCPServerInfo {
+    id: string;
+    name: string;
+    description: string;
+    transport: MCPTransportType;
+    status: MCPServerConnectionStatus;
+    tools: Array<{
+        name: string;
+        description: string;
+        inputSchema?: object;
+        execute?: (params: unknown, context?: unknown) => Promise<unknown> | unknown;
+    }>;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    timeout?: number;
+    retries?: number;
     error?: string;
-    /**
-     * Optional metadata about execution
-     */
+    installed?: boolean;
+    cwd?: string;
+    autoRestart?: boolean;
+    healthCheckInterval?: number;
     metadata?: {
-        executionTime?: number;
-        toolName?: string;
-        serverId?: string;
+        uptime?: number;
+        toolCount?: number;
+        category?: MCPServerCategory;
+        provider?: string;
+        version?: string;
+        author?: string;
+        tags?: string[];
         [key: string]: unknown;
     };
 }
-/**
- * MCP Transport Types - Maximally Reusable
- */
-export type MCPTransportType = "stdio" | "websocket" | "tcp" | "unix";
 /**
  * MCP Server Status for CLI Operations - High Reusability
  */
@@ -111,7 +75,7 @@ export interface MCPServerStatus {
     customToolsCount: number;
     /** Number of in-memory servers */
     inMemoryServersCount: number;
-    /** Error message if any */
+    /** Error message */
     error?: string;
     /** Auto-discovered servers from various sources */
     autoDiscoveredServers?: MCPDiscoveredServer[];
@@ -120,14 +84,14 @@ export interface MCPServerStatus {
     /** Available tools across all servers */
     availableTools: MCPToolInfo[];
     /** Server registry entries */
-    serverRegistry?: Record<string, MCPServerConfig>;
+    serverRegistry?: Record<string, MCPServerInfo>;
 }
 /**
  * Auto-discovered MCP Server - High Reusability
  */
 export interface MCPDiscoveredServer {
     name: string;
-    status: "connected" | "disconnected" | "error" | "pending" | "failed";
+    status: MCPServerConnectionStatus;
     source: string;
     transport: MCPTransportType;
     description?: string;
@@ -149,21 +113,6 @@ export interface MCPConnectedServer {
     connectionTime?: Date;
     metadata?: MCPServerMetadata;
 }
-/**
- * MCP Server Configuration - Maximally Reusable
- */
-export interface MCPServerConfig {
-    name: string;
-    transport: MCPTransportType;
-    description?: string;
-    command?: string;
-    args?: string[];
-    env?: Record<string, string>;
-    url?: string;
-    timeout?: number;
-    retries?: number;
-    metadata?: MCPServerMetadata;
-}
 /**
  * MCP Tool Information - High Reusability
  */
@@ -177,6 +126,11 @@ export interface MCPToolInfo {
     outputSchema?: JsonObject;
     metadata?: MCPToolMetadata;
 }
+/**
+ * MCP Executable Tool - Tool with execution capability
+ * Extracted from MCPServerInfo.tools array for better readability
+ */
+export type MCPExecutableTool = MCPServerInfo["tools"][0];
 /**
  * MCP Server Metadata - Extensible
  */
@@ -203,7 +157,7 @@ export type MCPToolMetadata = {
 /**
  * MCP Server Registry Entry - For Object.entries() usage
  */
-export type MCPServerRegistryEntry = [string, MCPServerConfig];
+export type MCPServerRegistryEntry = [string, MCPServerInfo];
 /**
  * Unified MCP Registry interface
  */
@@ -211,7 +165,7 @@ export interface UnifiedMCPRegistry {
     /**
      * Register an in-memory server
      */
-    registerInMemoryServer(serverId: string, config: InMemoryMCPServerConfig): Promise<void>;
+    registerInMemoryServer(serverId: string, serverInfo: MCPServerInfo): Promise<void>;
     /**
      * Get all available tools
      */
@@ -219,7 +173,7 @@ export interface UnifiedMCPRegistry {
     /**
      * Execute a tool
      */
-    executeTool(toolName: string, params: JsonObject, context: JsonObject): Promise<InMemoryToolResult>;
+    executeTool(toolName: string, params: JsonObject, context: JsonObject): Promise<unknown>;
     /**
      * Check if connected to a server
      */

package/dist/types/providers.d.ts

@@ -1,6 +1,5 @@
 /**
  * Provider-specific type definitions for NeuroLink
- * Replaces 'any' types in provider implementations
  */
 import type { UnknownRecord, JsonValue } from "./common.js";
 /**

package/dist/types/providers.js

@@ -1,6 +1,5 @@
 /**
  * Provider-specific type definitions for NeuroLink
- * Replaces 'any' types in provider implementations
  */
 /**
  * Type guard for provider error

package/dist/types/tools.d.ts

@@ -1,6 +1,6 @@
 /**
- * Tool system type definitions for NeuroLink
- * Replaces 'any' types in tool registration and execution
+ * Type definitions for NeuroLink tool system, including parameter schemas,
+ * argument patterns, execution metadata, context, and result types.
  */
 import { z } from "zod";
 import type { Result, JsonValue, ErrorInfo } from "./common.js";

package/dist/types/tools.js

@@ -1,6 +1,6 @@
 /**
- * Tool system type definitions for NeuroLink
- * Replaces 'any' types in tool registration and execution
+ * Type definitions for NeuroLink tool system, including parameter schemas,
+ * argument patterns, execution metadata, context, and result types.
  */
 /**
  * Type guard for tool result

package/dist/utils/factoryProcessing.js

@@ -204,7 +204,7 @@ class FactoryProcessingCache {
         return hash >>> 0;
     }
     /**
-     * Hash any value to a numeric hash
+     * Hash random value to a numeric hash
      * Optimized for different value types
      */
     hashValue(value) {

package/dist/utils/mcpDefaults.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Smart Defaults for MCPServerInfo Creation
+ * Eliminates boilerplate manual object creation
+ */
+import type { MCPServerInfo, MCPExecutableTool, MCPServerCategory } from "../types/mcpTypes.js";
+/**
+ * Smart category detection based on context
+ */
+export declare function detectCategory(context: {
+    isCustomTool?: boolean;
+    isExternal?: boolean;
+    isBuiltIn?: boolean;
+    serverId?: string;
+    existingCategory?: string;
+}): MCPServerCategory;
+/**
+ * Create MCPServerInfo with smart defaults
+ * Eliminates manual boilerplate object creation
+ */
+export declare function createMCPServerInfo(options: {
+    id?: string;
+    name: string;
+    tool?: MCPExecutableTool;
+    tools?: MCPServerInfo["tools"];
+    transport?: MCPServerInfo["transport"];
+    status?: MCPServerInfo["status"];
+    description?: string;
+    category?: string;
+    isCustomTool?: boolean;
+    isExternal?: boolean;
+    isBuiltIn?: boolean;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+}): MCPServerInfo;
+/**
+ * Create MCPServerInfo for custom tool registration
+ * Specialized version with smart defaults for registerTool usage
+ */
+export declare function createCustomToolServerInfo(toolName: string, tool: MCPExecutableTool): MCPServerInfo;
+/**
+ * Create MCPServerInfo for external servers
+ * Specialized version with smart defaults for external server usage
+ */
+export declare function createExternalServerInfo(options: {
+    id: string;
+    name?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    transport?: MCPServerInfo["transport"];
+    description?: string;
+    tools?: MCPServerInfo["tools"];
+}): MCPServerInfo;