@juspay/neurolink 5.1.0 → 5.3.0

package/dist/services/websocket/websocket-server.js

@@ -1,6 +1,7 @@
 import { WebSocketServer, WebSocket } from "ws";
 import { EventEmitter } from "events";
 import { randomUUID } from "crypto";
+import { logger } from "../../utils/logger.js";
 export class NeuroLinkWebSocketServer extends EventEmitter {
     wss;
     connections = new Map();
@@ -32,7 +33,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
             this.handleConnection(ws, request);
         });
         this.wss.on("error", (error) => {
-            console.error("[WebSocket Server] Error:", error);
+            logger.error("[WebSocket Server] Error:", error);
             this.emit("error", error);
         });
     }
@@ -64,7 +65,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
             this.handleDisconnection(connectionId);
         });
         ws.on("error", (error) => {
-            console.error(`[WebSocket] Connection ${connectionId} error:`, error);
+            logger.error(`[WebSocket] Connection ${connectionId} error:`, error);
             this.handleDisconnection(connectionId);
         });
         // Send connection confirmation
@@ -82,7 +83,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
                 },
             },
         });
-        console.log(`[WebSocket] New connection: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
+        logger.debug(`[WebSocket] New connection: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
         this.emit("connection", { connectionId, userAgent, ipAddress });
     }
     handleMessage(connectionId, data) {
@@ -101,7 +102,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
             }
         }
         catch (error) {
-            console.error(`[WebSocket] Invalid message from ${connectionId}:`, error);
+            logger.error(`[WebSocket] Invalid message from ${connectionId}:`, error);
             this.sendError(connectionId, "Invalid message format");
         }
     }
@@ -124,7 +125,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
         // Clean up
         this.connections.delete(connectionId);
         this.connectionInfo.delete(connectionId);
-        console.log(`[WebSocket] Disconnected: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
+        logger.debug(`[WebSocket] Disconnected: ${connectionId} (${this.connections.size}/${this.options.maxConnections})`);
         this.emit("disconnection", { connectionId });
     }
     // Room Management
@@ -150,7 +151,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
                 memberCount: this.rooms.get(roomId).size,
             },
         });
-        console.log(`[WebSocket] ${connectionId} joined room ${roomId}`);
+        logger.debug(`[WebSocket] ${connectionId} joined room ${roomId}`);
         return true;
     }
     leaveRoom(connectionId, roomId) {
@@ -179,7 +180,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
                 memberCount: room.size,
             },
         });
-        console.log(`[WebSocket] ${connectionId} left room ${roomId}`);
+        logger.debug(`[WebSocket] ${connectionId} left room ${roomId}`);
         return true;
     }
     broadcastToRoom(roomId, message) {
@@ -231,7 +232,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
             return true;
         }
         catch (error) {
-            console.error(`[WebSocket] Failed to send message to ${connectionId}:`, error);
+            logger.error(`[WebSocket] Failed to send message to ${connectionId}:`, error);
             return false;
         }
     }
@@ -269,7 +270,7 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
                     const connection = this.connectionInfo.get(connectionId);
                     if (connection &&
                         Date.now() - connection.lastActivity > this.options.timeoutMs) {
-                        console.log(`[WebSocket] Timeout for connection ${connectionId}`);
+                        logger.debug(`[WebSocket] Timeout for connection ${connectionId}`);
                         ws.terminate();
                     }
                 }
@@ -296,9 +297,9 @@ export class NeuroLinkWebSocketServer extends EventEmitter {
         // Implementation for channel data handling
     }
     handleChannelError(channelId, error) {
-        console.error(`[Streaming Channel] ${channelId} error:`, error);
+        logger.error(`[Streaming Channel] ${channelId} error:`, error);
     }
     handleChannelClose(channelId) {
-        console.log(`[Streaming Channel] ${channelId} closed`);
+        logger.debug(`[Streaming Channel] ${channelId} closed`);
     }
 }

package/dist/telemetry/telemetry-service.js

@@ -6,6 +6,7 @@ import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { Resource } from "@opentelemetry/resources";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
 import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { logger } from "../utils/logger.js";
 export class TelemetryService {
     static instance;
     sdk;
@@ -27,7 +28,7 @@ export class TelemetryService {
             this.initializeTelemetry();
         }
         else {
-            console.log("[Telemetry] Disabled - set NEUROLINK_TELEMETRY_ENABLED=true or configure OTEL_EXPORTER_OTLP_ENDPOINT to enable");
+            logger.debug("[Telemetry] Disabled - set NEUROLINK_TELEMETRY_ENABLED=true or configure OTEL_EXPORTER_OTLP_ENDPOINT to enable");
         }
     }
     static getInstance() {
@@ -58,10 +59,10 @@ export class TelemetryService {
             this.meter = metrics.getMeter("neurolink-ai");
             this.tracer = trace.getTracer("neurolink-ai");
             this.initializeMetrics();
-            console.log("[Telemetry] Initialized with endpoint:", process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
+            logger.debug("[Telemetry] Initialized with endpoint:", process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
         }
         catch (error) {
-            console.error("[Telemetry] Failed to initialize:", error);
+            logger.error("[Telemetry] Failed to initialize:", error);
             this.enabled = false;
         }
     }
@@ -97,10 +98,10 @@ export class TelemetryService {
         }
         try {
             await this.sdk?.start();
-            console.log("[Telemetry] SDK started successfully");
+            logger.debug("[Telemetry] SDK started successfully");
         }
         catch (error) {
-            console.error("[Telemetry] Failed to start SDK:", error);
+            logger.error("[Telemetry] Failed to start SDK:", error);
             this.enabled = false;
         }
     }
@@ -251,10 +252,10 @@ export class TelemetryService {
         if (this.enabled && this.sdk) {
             try {
                 await this.sdk.shutdown();
-                console.log("[Telemetry] SDK shutdown completed");
+                logger.debug("[Telemetry] SDK shutdown completed");
             }
             catch (error) {
-                console.error("[Telemetry] Error during shutdown:", error);
+                logger.error("[Telemetry] Error during shutdown:", error);
             }
         }
     }

package/dist/types/generate-types.d.ts

@@ -53,6 +53,7 @@ export interface GenerateResult {
         toolName: string;
         args: Record<string, any>;
     }>;
+    toolResults?: any[];
     toolsUsed?: string[];
     toolExecutions?: Array<{
         name: string;

package/dist/types/mcp-types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * MCP Types for In-Memory Server Support
+ * Enables Lighthouse and other integrations to register tools directly
+ */
+/**
+ * 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]: any;
+    };
+}
+/**
+ * In-memory tool information
+ */
+export interface InMemoryToolInfo {
+    /**
+     * Tool description
+     */
+    description: string;
+    /**
+     * Tool execution function
+     */
+    execute: (params: any) => Promise<InMemoryToolResult> | InMemoryToolResult;
+    /**
+     * Input parameter schema (Zod or JSON Schema)
+     */
+    inputSchema?: any;
+    /**
+     * Whether the tool is implemented (default: true)
+     */
+    isImplemented?: boolean;
+    /**
+     * Optional metadata
+     */
+    metadata?: Record<string, any>;
+}
+/**
+ * Result from in-memory tool execution
+ */
+export interface InMemoryToolResult {
+    /**
+     * Whether execution was successful
+     */
+    success: boolean;
+    /**
+     * Result data if successful
+     */
+    data?: any;
+    /**
+     * Error message if failed
+     */
+    error?: string;
+    /**
+     * Optional metadata about execution
+     */
+    metadata?: {
+        executionTime?: number;
+        toolName?: string;
+        serverId?: string;
+        [key: string]: any;
+    };
+}
+/**
+ * Unified MCP Registry interface
+ */
+export interface UnifiedMCPRegistry {
+    /**
+     * Register an in-memory server
+     */
+    registerInMemoryServer(serverId: string, config: InMemoryMCPServerConfig): Promise<void>;
+    /**
+     * Get all available tools
+     */
+    getAllTools(): Promise<Array<{
+        name: string;
+        serverId: string;
+        description: string;
+        isExternal: boolean;
+    }>>;
+    /**
+     * Execute a tool
+     */
+    executeTool(toolName: string, params: any, context: any): Promise<any>;
+    /**
+     * Check if connected to a server
+     */
+    isConnected(serverId: string): boolean;
+}

package/dist/types/mcp-types.js

@@ -0,0 +1,5 @@
+/**
+ * MCP Types for In-Memory Server Support
+ * Enables Lighthouse and other integrations to register tools directly
+ */
+export {};

package/dist/types/stream-types.d.ts

@@ -1,6 +1,25 @@
 import type { ZodType, ZodTypeDef } from "zod";
 import type { Tool, Schema } from "ai";
 import type { AIProviderName, AnalyticsData, EvaluationData } from "../core/types.js";
+/**
+ * Interface for tool execution calls
+ */
+export interface ToolCall {
+    toolName: string;
+    parameters: Record<string, any>;
+    id?: string;
+}
+/**
+ * Interface for tool execution results
+ */
+export interface ToolResult {
+    toolName: string;
+    status: "success" | "failure";
+    output?: any;
+    error?: string;
+    id?: string;
+    executionTime?: number;
+}
 /**
  * Stream function options interface - Primary method for streaming content
  * Future-ready for multi-modal capabilities while maintaining text focus
@@ -26,6 +45,7 @@ export interface StreamOptions {
     tools?: Record<string, Tool>;
     timeout?: number | string;
     disableTools?: boolean;
+    maxSteps?: number;
     enableEvaluation?: boolean;
     enableAnalytics?: boolean;
     context?: Record<string, any>;
@@ -46,30 +66,22 @@ export interface StreamResult {
     }>;
     provider?: string;
     model?: string;
+    usage?: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+    };
+    finishReason?: string;
+    toolCalls?: ToolCall[];
+    toolResults?: ToolResult[];
     metadata?: {
         streamId?: string;
         startTime?: number;
         totalChunks?: number;
         estimatedDuration?: number;
+        responseTime?: number;
+        fallback?: boolean;
     };
-    toolCalls?: Array<{
-        toolCallId: string;
-        toolName: string;
-        args: Record<string, any>;
-    }>;
-    toolsUsed?: string[];
-    toolExecutions?: Array<{
-        name: string;
-        input: Record<string, any>;
-        output: any;
-        duration: number;
-    }>;
-    enhancedWithTools?: boolean;
-    availableTools?: Array<{
-        name: string;
-        description: string;
-        parameters: Record<string, any>;
-    }>;
     analytics?: AnalyticsData;
     evaluation?: EvaluationData;
 }

package/dist/types/universal-provider-options.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Universal Provider Options Interface (Phase 1: Factory Pattern)
+ * Based on TypeScript factory pattern best practices for AI provider abstraction
+ */
+/**
+ * Base configuration interface for all AI providers
+ * Uses Parameter Object Pattern for flexible, extensible configuration
+ */
+export interface UniversalProviderOptions {
+    prompt?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    enableAnalytics?: boolean;
+    enableEvaluation?: boolean;
+    context?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    extensionOptions?: Record<string, unknown>;
+}
+/**
+ * Generic provider options (without providerType)
+ */
+export type GenericProviderOptions = Omit<UniversalProviderOptions, "providerType">;
+/**
+ * Provider-specific configuration extensions
+ * Discriminated union pattern for type-safe provider configs
+ */
+export interface OpenAIProviderOptions extends UniversalProviderOptions {
+    providerType: "openai";
+    organization?: string;
+    seed?: number;
+    topP?: number;
+}
+export interface GoogleAIProviderOptions extends UniversalProviderOptions {
+    providerType: "google-ai";
+    topK?: number;
+    candidateCount?: number;
+    stopSequences?: string[];
+}
+export interface AnthropicProviderOptions extends UniversalProviderOptions {
+    providerType: "anthropic";
+    topK?: number;
+    stopSequences?: string[];
+}
+export interface BedrockProviderOptions extends UniversalProviderOptions {
+    providerType: "bedrock";
+    inferenceProfileArn?: string;
+    region?: string;
+}
+/**
+ * Discriminated union for type-safe provider configuration
+ * Enables compile-time type checking for provider-specific options
+ */
+export type ProviderSpecificOptions = OpenAIProviderOptions | GoogleAIProviderOptions | AnthropicProviderOptions | BedrockProviderOptions;
+/**
+ * Factory configuration interface
+ * Supports both universal and provider-specific parameters
+ */
+export interface ProviderFactoryConfig {
+    providerName: string;
+    modelName?: string;
+    options?: UniversalProviderOptions | ProviderSpecificOptions;
+    enableMCP?: boolean;
+}
+/**
+ * Parameter normalization utilities
+ * Converts between different parameter formats for backward compatibility
+ */
+export declare class ParameterNormalizer {
+    /**
+     * Normalize legacy parameter formats to universal format
+     */
+    static normalizeToUniversal(optionsOrPrompt: UniversalProviderOptions | string): UniversalProviderOptions;
+    /**
+     * Retrieve the provider type if it exists, otherwise return null
+     */
+    private static getProviderType;
+    /**
+     * Extract provider-specific parameters safely
+     */
+    static extractProviderOptions<T extends ProviderSpecificOptions>(options: UniversalProviderOptions | ProviderSpecificOptions, providerType: T["providerType"]): T | GenericProviderOptions;
+    /**
+     * Merge default values with user-provided options
+     */
+    static mergeWithDefaults(options: UniversalProviderOptions, defaults: Partial<UniversalProviderOptions>): UniversalProviderOptions;
+}

package/dist/types/universal-provider-options.js

@@ -0,0 +1,53 @@
+/**
+ * Universal Provider Options Interface (Phase 1: Factory Pattern)
+ * Based on TypeScript factory pattern best practices for AI provider abstraction
+ */
+/**
+ * Parameter normalization utilities
+ * Converts between different parameter formats for backward compatibility
+ */
+export class ParameterNormalizer {
+    /**
+     * Normalize legacy parameter formats to universal format
+     */
+    static normalizeToUniversal(optionsOrPrompt) {
+        if (typeof optionsOrPrompt === "string") {
+            return { prompt: optionsOrPrompt };
+        }
+        return optionsOrPrompt;
+    }
+    /**
+     * Retrieve the provider type if it exists, otherwise return null
+     */
+    static getProviderType(options) {
+        return "providerType" in options ? options.providerType : null;
+    }
+    /**
+     * Extract provider-specific parameters safely
+     */
+    static extractProviderOptions(options, providerType) {
+        const currentProviderType = ParameterNormalizer.getProviderType(options);
+        if (currentProviderType === providerType) {
+            return options;
+        }
+        // Handle case where options has providerType but doesn't match
+        if (currentProviderType !== null) {
+            const { providerType: _providerType, ...genericOptions } = options;
+            return genericOptions;
+        }
+        // Options don't have providerType, return as generic
+        return options;
+    }
+    /**
+     * Merge default values with user-provided options
+     */
+    static mergeWithDefaults(options, defaults) {
+        return {
+            ...defaults,
+            ...options,
+            // Merge nested objects
+            context: { ...defaults.context, ...options.context },
+            metadata: { ...defaults.metadata, ...options.metadata },
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "5.1.0",
+  "version": "5.3.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",
@@ -124,10 +124,13 @@
   "dependencies": {
     "@ai-sdk/amazon-bedrock": "^1.0.0",
     "@ai-sdk/anthropic": "^1.2.12",
+    "@ai-sdk/azure": "^1.3.24",
     "@ai-sdk/google": "^1.2.19",
     "@ai-sdk/google-vertex": "^2.2.0",
     "@ai-sdk/mistral": "^1.0.0",
     "@ai-sdk/openai": "^1.0.0",
+    "@ai-sdk/provider": "^1.1.3",
+    "@ai-sdk/provider-utils": "^2.2.8",
     "@google/generative-ai": "^0.24.1",
     "@huggingface/inference": "^2.8.0",
     "@modelcontextprotocol/sdk": "^1.13.0",
@@ -145,15 +148,13 @@
     "@opentelemetry/sdk-metrics": "^1.30.1",
     "@opentelemetry/sdk-node": "^0.54.2",
     "@opentelemetry/semantic-conventions": "^1.34.0",
-    "@types/ws": "^8.18.1",
     "ai": "^4.0.0",
     "chalk": "^5.3.0",
-    "cors": "^2.8.5",
     "dotenv": "^16.5.0",
-    "express": "^5.1.0",
     "inquirer": "^9.2.15",
+    "mathjs": "^14.5.3",
+    "ollama-ai-provider": "^1.2.0",
     "ora": "^7.0.1",
-    "playwright": "^1.52.0",
     "reconnecting-eventsource": "^1.6.4",
     "undici": "^6.6.2",
     "uuid": "^11.1.0",
@@ -179,14 +180,20 @@
     "@types/express": "^5.0.3",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
     "@types/yargs": "^17.0.33",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
+    "@vitest/coverage-v8": "^2.1.9",
+    "cors": "^2.8.5",
     "eslint": "^9.0.0",
+    "express": "^5.1.0",
+    "playwright": "^1.52.0",
     "prettier": "^3.0.0",
     "publint": "^0.3.2",
     "puppeteer": "^24.10.0",
     "semantic-release": "^24.0.0",
+    "shell-quote": "^1.8.3",
     "svelte": "^5.0.0",
     "svelte-check": "^4.0.0",
     "tslib": "^2.4.1",

package/dist/lib/providers/agent-enhanced-provider.d.ts

@@ -1,93 +0,0 @@
-/**
- * Agent-Enhanced Provider for NeuroLink CLI
- * Integrates direct tools with AI providers for true agent functionality
- */
-import type { GenerateResult } from "../types/generate-types.js";
-import type { AIProvider, TextGenerationOptions, EnhancedGenerateResult } from "../core/types.js";
-import type { StreamOptions, StreamResult } from "../types/stream-types.js";
-/**
- * Agent configuration options
- */
-interface AgentConfig {
-    provider: "openai" | "google-ai" | "anthropic";
-    model?: string;
-    toolCategory?: "basic" | "filesystem" | "utility" | "all";
-    maxSteps?: number;
-    enableTools?: boolean;
-    enableMCP?: boolean;
-    mcpInitTimeoutMs?: number;
-    toolExecutionTimeout?: number | string;
-    mcpDiscoveryOptions?: {
-        searchPaths?: string[];
-        configFiles?: string[];
-        autoDiscover?: boolean;
-    };
-}
-/**
- * Agent-Enhanced Provider Class
- * Provides AI generation with tool calling capabilities
- * Now includes MCP tool integration alongside direct tools
- */
-export declare class AgentEnhancedProvider implements AIProvider {
-    private config;
-    private model;
-    private resolvedModelName;
-    private mcpSystem;
-    private mcpInitialized;
-    private mcpInitializing;
-    private mcpInitFailed;
-    constructor(config: AgentConfig);
-    private createModel;
-    /**
-     * Initialize MCP registry with auto-discovery
-     */
-    private initializeMCP;
-    /**
-     * Get combined tools: direct tools + MCP tools
-     */
-    private getCombinedTools;
-    /**
-     * PRIMARY METHOD: Stream content using AI (recommended for new code)
-     * Future-ready for multi-modal capabilities with current text focus
-     */
-    stream(optionsOrPrompt: StreamOptions | string, analysisSchema?: any): Promise<StreamResult>;
-    generate(optionsOrPrompt: TextGenerationOptions | string): Promise<GenerateResult>;
-    /**
-     * Determine if we should force tool usage based on prompt patterns
-     */
-    private shouldForceToolUsage;
-    getCapabilities(): string[];
-    getProviderName(): string;
-    getModelName(): string;
-    /**
-     * Test agent functionality
-     */
-    testAgentCapabilities(): Promise<{
-        success: boolean;
-        results: any[];
-    }>;
-    /**
-     * Create agent-enhanced provider factory
-     */
-    static createAgent(config: AgentConfig): AgentEnhancedProvider;
-    /**
-     * Create multiple agent providers for comparison
-     */
-    static createMultiProviderAgents(): Record<string, AgentEnhancedProvider>;
-    /**
-     * Alias for generate() - CLI-SDK consistency
-     */
-    /**
-     * Short alias for generate() - CLI-SDK consistency
-     */
-    gen(optionsOrPrompt: TextGenerationOptions | string, analysisSchema?: any): Promise<EnhancedGenerateResult | null>;
-}
-/**
- * Helper function to create agent provider
- */
-export declare function createAgentProvider(provider: "openai" | "google-ai" | "anthropic", options?: Partial<AgentConfig>): AgentEnhancedProvider;
-/**
- * Test all available agent providers
- */
-export declare function testAllAgentProviders(): Promise<void>;
-export {};