@juspay/neurolink 7.13.0 → 7.14.0

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

package/dist/lib/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) {

package/dist/lib/types/externalMcp.d.ts

@@ -0,0 +1,282 @@
+/**
+ * External MCP Server Types
+ * Comprehensive type system for external MCP server integration
+ * Following MCP 2024-11-05 specification
+ */
+import type { JsonValue, JsonObject } from "./common.js";
+import type { ChildProcess } from "child_process";
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+/**
+ * Supported MCP transport protocols
+ */
+export type MCPTransportType = "stdio" | "sse" | "websocket";
+/**
+ * External MCP server configuration for process spawning
+ */
+export interface ExternalMCPServerConfig {
+    /** Unique identifier for the server */
+    id: string;
+    /** Command to execute (e.g., 'npx', 'node', 'python') */
+    command: string;
+    /** Arguments to pass to the command */
+    args: string[];
+    /** Environment variables for the process */
+    env?: Record<string, string>;
+    /** Transport protocol to use */
+    transport: MCPTransportType;
+    /** Connection timeout in milliseconds (default: 10000) */
+    timeout?: number;
+    /** Maximum retry attempts for connection (default: 3) */
+    retries?: number;
+    /** Health check interval in milliseconds (default: 30000) */
+    healthCheckInterval?: number;
+    /** Whether to automatically restart on failure (default: true) */
+    autoRestart?: boolean;
+    /** Working directory for the process */
+    cwd?: string;
+    /** URL for SSE/WebSocket transports */
+    url?: string;
+    /** Additional metadata */
+    metadata?: Record<string, JsonValue>;
+}
+/**
+ * Runtime state of an external MCP server instance
+ */
+export interface ExternalMCPServerInstance {
+    /** Server configuration */
+    config: ExternalMCPServerConfig;
+    /** Child process (for stdio transport) */
+    process: ChildProcess | null;
+    /** MCP client instance */
+    client: Client | null;
+    /** Transport instance */
+    transport: Transport | null;
+    /** Current server status */
+    status: ExternalMCPServerStatus;
+    /** Last error message if any */
+    lastError?: string;
+    /** When the server was started */
+    startTime?: Date;
+    /** When the server was last seen healthy */
+    lastHealthCheck?: Date;
+    /** Number of reconnection attempts */
+    reconnectAttempts: number;
+    /** Maximum reconnection attempts before giving up */
+    maxReconnectAttempts: number;
+    /** Available tools from this server */
+    tools: Map<string, ExternalMCPToolInfo>;
+    /** Server capabilities reported by MCP */
+    capabilities?: Record<string, JsonValue>;
+    /** Health monitoring timer */
+    healthTimer?: NodeJS.Timeout;
+    /** Restart backoff timer */
+    restartTimer?: NodeJS.Timeout;
+    /** Performance metrics */
+    metrics: {
+        totalConnections: number;
+        totalDisconnections: number;
+        totalErrors: number;
+        totalToolCalls: number;
+        averageResponseTime: number;
+        lastResponseTime: number;
+    };
+}
+/**
+ * External MCP server status states
+ */
+export type ExternalMCPServerStatus = "initializing" | "connecting" | "connected" | "disconnected" | "failed" | "restarting" | "stopping" | "stopped";
+/**
+ * Tool information from external MCP server
+ */
+export interface ExternalMCPToolInfo {
+    /** Tool name */
+    name: string;
+    /** Tool description */
+    description: string;
+    /** Server ID that provides this tool */
+    serverId: string;
+    /** Input schema (JSON Schema) */
+    inputSchema?: JsonObject;
+    /** Whether the tool is currently available */
+    isAvailable: boolean;
+    /** Tool metadata */
+    metadata?: Record<string, JsonValue>;
+    /** When the tool was last successfully called */
+    lastCalled?: Date;
+    /** Tool execution statistics */
+    stats: {
+        totalCalls: number;
+        successfulCalls: number;
+        failedCalls: number;
+        averageExecutionTime: number;
+        lastExecutionTime: number;
+    };
+}
+/**
+ * External MCP server health status
+ */
+export interface ExternalMCPServerHealth {
+    /** Server ID */
+    serverId: string;
+    /** Whether the server is healthy */
+    isHealthy: boolean;
+    /** Current status */
+    status: ExternalMCPServerStatus;
+    /** When the health check was performed */
+    checkedAt: Date;
+    /** Response time for health check */
+    responseTime?: number;
+    /** Number of available tools */
+    toolCount: number;
+    /** Any health issues detected */
+    issues: string[];
+    /** Performance metrics */
+    performance: {
+        uptime: number;
+        memoryUsage?: number;
+        cpuUsage?: number;
+        averageResponseTime: number;
+    };
+}
+/**
+ * External MCP server configuration validation result
+ */
+export interface ExternalMCPConfigValidation {
+    /** Whether the configuration is valid */
+    isValid: boolean;
+    /** Validation errors */
+    errors: string[];
+    /** Validation warnings */
+    warnings: string[];
+    /** Suggestions for improvement */
+    suggestions: string[];
+}
+/**
+ * External MCP server operation result
+ */
+export interface ExternalMCPOperationResult<T = unknown> {
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Result data if successful */
+    data?: T;
+    /** Error message if failed */
+    error?: string;
+    /** Server ID */
+    serverId?: string;
+    /** Operation duration in milliseconds */
+    duration?: number;
+    /** Additional metadata */
+    metadata?: {
+        timestamp: number;
+        operation: string;
+        [key: string]: JsonValue;
+    };
+}
+/**
+ * External MCP tool execution context
+ */
+export interface ExternalMCPToolContext {
+    /** Execution session ID */
+    sessionId: string;
+    /** User ID if available */
+    userId?: string;
+    /** Server ID executing the tool */
+    serverId: string;
+    /** Tool name being executed */
+    toolName: string;
+    /** Execution timeout in milliseconds */
+    timeout?: number;
+    /** Additional context data */
+    metadata?: Record<string, JsonValue>;
+}
+/**
+ * External MCP tool execution result
+ */
+export interface ExternalMCPToolResult {
+    /** Whether the execution was successful */
+    success: boolean;
+    /** Result data if successful */
+    data?: unknown;
+    /** Error message if failed */
+    error?: string;
+    /** Execution duration in milliseconds */
+    duration: number;
+    /** Tool execution metadata */
+    metadata?: {
+        toolName: string;
+        serverId: string;
+        timestamp: number;
+        [key: string]: JsonValue;
+    };
+}
+/**
+ * External MCP server events
+ */
+export interface ExternalMCPServerEvents {
+    /** Server status changed */
+    statusChanged: {
+        serverId: string;
+        oldStatus: ExternalMCPServerStatus;
+        newStatus: ExternalMCPServerStatus;
+        timestamp: Date;
+    };
+    /** Server connected successfully */
+    connected: {
+        serverId: string;
+        toolCount: number;
+        timestamp: Date;
+    };
+    /** Server disconnected */
+    disconnected: {
+        serverId: string;
+        reason?: string;
+        timestamp: Date;
+    };
+    /** Server failed */
+    failed: {
+        serverId: string;
+        error: string;
+        timestamp: Date;
+    };
+    /** Tool discovered */
+    toolDiscovered: {
+        serverId: string;
+        toolName: string;
+        toolInfo: ExternalMCPToolInfo;
+        timestamp: Date;
+    };
+    /** Tool removed */
+    toolRemoved: {
+        serverId: string;
+        toolName: string;
+        timestamp: Date;
+    };
+    /** Health check completed */
+    healthCheck: {
+        serverId: string;
+        health: ExternalMCPServerHealth;
+        timestamp: Date;
+    };
+}
+/**
+ * External MCP manager configuration
+ */
+export interface ExternalMCPManagerConfig {
+    /** Maximum number of concurrent servers */
+    maxServers?: number;
+    /** Default timeout for operations */
+    defaultTimeout?: number;
+    /** Default health check interval */
+    defaultHealthCheckInterval?: number;
+    /** Whether to enable automatic restart */
+    enableAutoRestart?: boolean;
+    /** Maximum restart attempts per server */
+    maxRestartAttempts?: number;
+    /** Restart backoff multiplier */
+    restartBackoffMultiplier?: number;
+    /** Whether to enable performance monitoring */
+    enablePerformanceMonitoring?: boolean;
+    /** Log level for external MCP operations */
+    logLevel?: "debug" | "info" | "warn" | "error";
+}

package/dist/lib/types/externalMcp.js

@@ -0,0 +1,6 @@
+/**
+ * External MCP Server Types
+ * Comprehensive type system for external MCP server integration
+ * Following MCP 2024-11-05 specification
+ */
+export {};

package/dist/lib/types/generateTypes.d.ts

@@ -73,7 +73,6 @@ export interface GenerateResult {
         name: string;
         input: Record<string, unknown>;
         output: unknown;
-        duration: number;
     }>;
     enhancedWithTools?: boolean;
     availableTools?: Array<{

package/dist/lib/types/index.d.ts

@@ -11,6 +11,7 @@ export type { ToolArgs, ToolContext, ToolResult, ToolDefinition, SimpleTool, Ava
 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 { 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/mcp/externalServerManager.d.ts

@@ -0,0 +1,115 @@
+/**
+ * External MCP Server Manager
+ * Handles lifecycle management of external MCP servers including:
+ * - Process spawning and management
+ * - Health monitoring and automatic restart
+ * - Connection management and cleanup
+ * - Tool discovery and registration
+ */
+import { EventEmitter } from "events";
+import { ToolDiscoveryService } from "./toolDiscoveryService.js";
+import type { ExternalMCPServerConfig, ExternalMCPServerInstance, ExternalMCPServerHealth, ExternalMCPConfigValidation, ExternalMCPOperationResult, ExternalMCPManagerConfig, ExternalMCPToolInfo } from "../types/externalMcp.js";
+/**
+ * ExternalServerManager
+ * Core class for managing external MCP servers
+ */
+export declare class ExternalServerManager extends EventEmitter {
+    private servers;
+    private config;
+    private isShuttingDown;
+    private toolDiscovery;
+    constructor(config?: ExternalMCPManagerConfig);
+    /**
+     * Validate external MCP server configuration
+     */
+    validateConfig(config: ExternalMCPServerConfig): ExternalMCPConfigValidation;
+    /**
+     * Add a new external MCP server
+     */
+    addServer(serverId: string, config: ExternalMCPServerConfig): Promise<ExternalMCPOperationResult<ExternalMCPServerInstance>>;
+    /**
+     * Remove an external MCP server
+     */
+    removeServer(serverId: string): Promise<ExternalMCPOperationResult<void>>;
+    /**
+     * Start an external MCP server
+     */
+    private startServer;
+    /**
+     * Stop an external MCP server
+     */
+    private stopServer;
+    /**
+     * Update server status and emit events
+     */
+    private updateServerStatus;
+    /**
+     * Handle server errors
+     */
+    private handleServerError;
+    /**
+     * Handle server disconnection
+     */
+    private handleServerDisconnection;
+    /**
+     * Schedule server restart with exponential backoff
+     */
+    private scheduleRestart;
+    /**
+     * Start health monitoring for a server
+     */
+    private startHealthMonitoring;
+    /**
+     * Perform health check on a server
+     */
+    private performHealthCheck;
+    /**
+     * Get server instance
+     */
+    getServer(serverId: string): ExternalMCPServerInstance | undefined;
+    /**
+     * Get all servers
+     */
+    getAllServers(): Map<string, ExternalMCPServerInstance>;
+    /**
+     * Get server statuses
+     */
+    getServerStatuses(): ExternalMCPServerHealth[];
+    /**
+     * Shutdown all servers
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get manager statistics
+     */
+    getStatistics(): {
+        totalServers: number;
+        connectedServers: number;
+        failedServers: number;
+        totalTools: number;
+        totalConnections: number;
+        totalErrors: number;
+    };
+    /**
+     * Discover tools from a server
+     */
+    private discoverServerTools;
+    /**
+     * Execute a tool on a specific server
+     */
+    executeTool(serverId: string, toolName: string, parameters: Record<string, any>, options?: {
+        timeout?: number;
+    }): Promise<any>;
+    /**
+     * Get all tools from all servers
+     */
+    getAllTools(): ExternalMCPToolInfo[];
+    /**
+     * Get tools for a specific server
+     */
+    getServerTools(serverId: string): ExternalMCPToolInfo[];
+    /**
+     * Get tool discovery service
+     */
+    getToolDiscovery(): ToolDiscoveryService;
+}