@juspay/neurolink 5.1.0 → 5.3.0

package/dist/lib/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/lib/telemetry/telemetry-service.js

@@ -4,6 +4,7 @@ import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentation
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { Resource } from "@opentelemetry/resources";
 import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
+import { logger } from "../utils/logger.js";
 export class TelemetryService {
     static instance;
     sdk;
@@ -25,7 +26,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() {
@@ -56,10 +57,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;
         }
     }
@@ -95,10 +96,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;
         }
     }
@@ -249,10 +250,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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/dist/mcp/client.d.ts

@@ -33,6 +33,7 @@ export declare class NeuroLinkMCPClient extends EventEmitter {
      * Get all registered tools
      */
     getTools(): Record<string, {
+        name: string;
         description?: string;
         inputSchema?: unknown;
     }>;

package/dist/mcp/client.js

@@ -130,6 +130,7 @@ export class NeuroLinkMCPClient extends EventEmitter {
         const tools = {};
         for (const [name, tool] of this.tools) {
             tools[name] = {
+                name: name, // Include the tool name as a property
                 description: tool.description,
                 inputSchema: tool.inputSchema,
             };

package/dist/mcp/config.js

@@ -3,15 +3,36 @@
  * Central registry for all MCP servers following Lighthouse patterns
  * Handles built-in servers only - auto-discovery handled by unified registry
  */
-import { aiCoreServer } from "./servers/ai-providers/ai-core-server.js";
 import { utilityServer } from "./servers/utilities/utility-server.js";
 import { logger } from "../utils/logger.js";
+/**
+ * Lazy-loaded AI Core Server to avoid circular dependencies
+ */
+let aiCoreServerCache = null;
+async function getAICoreServer() {
+    if (!aiCoreServerCache) {
+        const { aiCoreServer } = await import("./servers/ai-providers/ai-core-server.js");
+        aiCoreServerCache = aiCoreServer;
+    }
+    return aiCoreServerCache;
+}
+/**
+ * Lazy-loaded Direct Tools Server to avoid circular dependencies
+ */
+let directToolsServerCache = null;
+async function getDirectToolsServer() {
+    if (!directToolsServerCache) {
+        const { directToolsServer } = await import("./servers/agent/direct-tools-server.js");
+        directToolsServerCache = directToolsServer;
+    }
+    return directToolsServerCache;
+}
 /**
  * Built-in MCP servers (kept for backward compatibility)
  * Add new servers here as they are created
  */
 export const allServers = [
-    aiCoreServer,
+    // aiCoreServer will be added dynamically in getServers()
     utilityServer,
     // Add more servers as they are created
 ];
@@ -25,8 +46,12 @@ export const mcpConfig = {
      */
     getServers: async () => {
         const activeServers = [];
+        // Get all servers including dynamically loaded ones
+        const aiCoreServer = await getAICoreServer();
+        const directToolsServer = await getDirectToolsServer();
+        const servers = [aiCoreServer, directToolsServer, ...allServers];
         // Include built-in servers with filtering
-        for (const server of allServers) {
+        for (const server of servers) {
             const implementedTools = {};
             let hasImplementedTools = false;
             for (const toolName in server.tools) {

package/dist/mcp/context-manager.d.ts

@@ -29,6 +29,7 @@ export interface ContextRequest {
 export declare class ContextManager {
     private sessionCounter;
     private activeContexts;
+    private static cachedLogger;
     /**
      * Create a new execution context with rich information
      *

package/dist/mcp/context-manager.js

@@ -10,6 +10,7 @@
 export class ContextManager {
     sessionCounter = 0;
     activeContexts = new Map();
+    static cachedLogger = null;
     /**
      * Create a new execution context with rich information
      *
@@ -64,6 +65,7 @@ export class ContextManager {
             },
             path: {
                 join: (...paths) => {
+                    // Use dynamic require for synchronous path operations
                     const path = require("path");
                     return path.join(...paths);
                 },
@@ -85,11 +87,13 @@ export class ContextManager {
                 },
             },
             grantedPermissions: request.permissions || [],
-            log: (level, message, data) => {
-                // Use logger if available, otherwise console
+            log: async (level, message, data) => {
+                // Use cached logger if available, otherwise import and cache
                 try {
-                    const { logger } = require("../utils/logger.js");
-                    logger[level](message, data);
+                    if (!ContextManager.cachedLogger) {
+                        ContextManager.cachedLogger = await import("../utils/logger.js").then(({ logger }) => logger);
+                    }
+                    ContextManager.cachedLogger[level](message, data);
                 }
                 catch {
                     console[level === "debug" ? "log" : level](message, data);

package/dist/mcp/function-calling.d.ts

@@ -14,6 +14,7 @@ export declare function mcpToolToAISDKTool(tool: NeuroLinkMCPTool, serverId: str
  */
 export declare function getAvailableFunctionTools(): Promise<{
     tools: Tool[];
+    toolsObject: Record<string, Tool>;
     toolMap: Map<string, {
         serverId: string;
         toolName: string;
@@ -49,3 +50,15 @@ export declare function getFunctionToolsForCategory(category?: string, maxTools?
  * Check if function calling is available
  */
 export declare function isFunctionCallingAvailable(): Promise<boolean>;
+/**
+ * Utility function to create a named tool object for debugging
+ */
+export declare function createNamedTool(name: string, toolDef: any): any & {
+    name: string;
+};
+/**
+ * Get tools with proper name properties for debugging
+ */
+export declare function getToolsWithNames(): Promise<Record<string, any & {
+    name: string;
+}>>;