@juspay/neurolink 5.0.0 → 5.2.0

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

@@ -0,0 +1,95 @@
+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
+ */
+export interface StreamOptions {
+    input: {
+        text: string;
+    };
+    output?: {
+        format?: "text" | "structured" | "json";
+        streaming?: {
+            chunkSize?: number;
+            bufferSize?: number;
+            enableProgress?: boolean;
+        };
+    };
+    provider?: AIProviderName | string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    schema?: ZodType<unknown, ZodTypeDef, unknown> | Schema<unknown>;
+    tools?: Record<string, Tool>;
+    timeout?: number | string;
+    disableTools?: boolean;
+    maxSteps?: number;
+    enableEvaluation?: boolean;
+    enableAnalytics?: boolean;
+    context?: Record<string, any>;
+    evaluationDomain?: string;
+    toolUsageContext?: string;
+    conversationHistory?: Array<{
+        role: string;
+        content: string;
+    }>;
+}
+/**
+ * Stream function result interface - Primary output format for streaming
+ * Future-ready for multi-modal outputs while maintaining text focus
+ */
+export interface StreamResult {
+    stream: AsyncIterable<{
+        content: string;
+    }>;
+    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;
+    };
+    analytics?: AnalyticsData;
+    evaluation?: EvaluationData;
+}
+/**
+ * Enhanced provider interface with stream method
+ */
+export interface EnhancedStreamProvider {
+    stream(options: StreamOptions): Promise<StreamResult>;
+    getName(): string;
+    isAvailable(): Promise<boolean>;
+}

package/dist/lib/types/stream-types.js

@@ -0,0 +1 @@
+export {};

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/lib/utils/providerUtils-fixed.js

@@ -85,7 +85,7 @@ async function isProviderAvailable(providerName) {
     }
     try {
         const provider = await AIProviderFactory.createProvider(providerName);
-        await provider.generateText({ prompt: "test", maxTokens: 1 });
+        await provider.generate({ prompt: "test", maxTokens: 1 });
         return true;
     }
     catch (error) {

package/dist/lib/utils/streaming-utils.d.ts

@@ -2,7 +2,7 @@
  * Phase 2: Enhanced Streaming Infrastructure
  * Streaming utilities for progress tracking and metadata enhancement
  */
-import type { StreamingProgressData, StreamingMetadata, ProgressCallback, EnhancedStreamTextOptions } from "../core/types.js";
+import type { StreamingProgressData, StreamingMetadata, ProgressCallback } from "../core/types.js";
 export interface UIProgressHandler {
     onProgress: (progress: StreamingProgressData) => void;
     onComplete: (metadata: StreamingMetadata) => void;
@@ -19,6 +19,18 @@ export interface StreamingStats {
 /**
  * Enhanced streaming utilities for progress tracking and metadata
  */
+export interface StreamingConfigOptions {
+    enableProgressTracking?: boolean;
+    progressCallback?: ProgressCallback;
+    includeStreamingMetadata?: boolean;
+    streamingBufferSize?: number;
+    enableStreamingHeaders?: boolean;
+}
+/**
+ * Legacy interface for backward compatibility
+ */
+export interface EnhancedStreamTextOptions extends StreamingConfigOptions {
+}
 export declare class StreamingEnhancer {
     /**
      * Add progress tracking to a readable stream
@@ -42,7 +54,7 @@ export declare class StreamingEnhancer {
     /**
      * Create enhanced streaming configuration
      */
-    static createStreamingConfig(options: EnhancedStreamTextOptions): {
+    static createStreamingConfig(options: StreamingConfigOptions | EnhancedStreamTextOptions): {
         progressTracking: boolean;
         callback?: ProgressCallback;
         metadata: boolean;

package/dist/lib/utils/streaming-utils.js

@@ -2,9 +2,6 @@
  * Phase 2: Enhanced Streaming Infrastructure
  * Streaming utilities for progress tracking and metadata enhancement
  */
-/**
- * Enhanced streaming utilities for progress tracking and metadata
- */
 export class StreamingEnhancer {
     /**
      * Add progress tracking to a readable stream

package/dist/mcp/client.js

@@ -49,11 +49,11 @@ export class NeuroLinkMCPClient extends EventEmitter {
                             return result;
                         }
                         // If it's in Lighthouse format with content array
-                        if (result.content &&
-                            Array.isArray(result.content) &&
-                            result.content[0]?.text) {
+                        if (result.text &&
+                            Array.isArray(result.text) &&
+                            result.text[0]?.text) {
                             try {
-                                const data = JSON.parse(result.content[0].text);
+                                const data = JSON.parse(result.text[0].text);
                                 return {
                                     success: !result.isError,
                                     data,
@@ -69,7 +69,7 @@ export class NeuroLinkMCPClient extends EventEmitter {
                                 // If JSON parsing fails, return the text as-is
                                 return {
                                     success: !result.isError,
-                                    data: { text: result.content[0].text },
+                                    data: { text: result.text[0].text },
                                     metadata: {
                                         toolName,
                                         serverId,

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/dynamic-orchestrator.js

@@ -199,11 +199,11 @@ export class DynamicOrchestrator extends MCPOrchestrator {
                 .replace("{previousResults}", previousResults || "None yet");
         try {
             // Use AI Core Server to get tool decision
-            const generateTextTool = aiCoreServer.tools["generate-text"];
-            if (!generateTextTool) {
-                throw new Error("generate-text tool not found");
+            const generateTool = aiCoreServer.tools["generate"];
+            if (!generateTool) {
+                throw new Error("generate tool not found");
             }
-            const aiResponse = await generateTextTool.execute({
+            const aiResponse = await generateTool.execute({
                 prompt: "Select the next tool to execute based on the context provided.",
                 systemPrompt,
                 provider: "google-ai", // Use fast model for decisions
@@ -279,11 +279,11 @@ ${executionSummary}
 Provide a clear, concise answer that addresses the user's request based on the tool results.`;
         try {
             // Use AI to generate final summary
-            const generateTextTool = aiCoreServer.tools["generate-text"];
-            if (!generateTextTool) {
-                throw new Error("generate-text tool not found");
+            const generateTool = aiCoreServer.tools["generate"];
+            if (!generateTool) {
+                throw new Error("generate tool not found");
             }
-            const aiResponse = await generateTextTool.execute({
+            const aiResponse = await generateTool.execute({
                 prompt: summaryPrompt,
                 provider: "google-ai",
                 model: "gemini-2.5-pro",

package/dist/mcp/external-client.js

@@ -139,7 +139,7 @@ export class ExternalMCPClient extends EventEmitter {
             // Transform MCP response to NeuroLink format
             const result = {
                 success: !response.isError,
-                data: response.content || response.result || response,
+                data: response.text || response.result || response,
                 metadata: {
                     toolName,
                     serverId: this.config.name,
@@ -150,7 +150,7 @@ export class ExternalMCPClient extends EventEmitter {
                 },
             };
             if (response.isError) {
-                result.error = response.content?.[0]?.text || "Tool execution failed";
+                result.error = response.text?.[0]?.text || "Tool execution failed";
             }
             logger.debug(`[External MCP] Tool ${toolName} executed in ${executionTime}ms`);
             return result;

package/dist/mcp/factory.d.ts

@@ -134,7 +134,7 @@ export interface MCPServerConfig {
  * });
  *
  * aiCoreServer.registerTool({
- *   name: 'generate-text',
+ *   name: 'generate',
  *   description: 'Generate text using AI providers',
  *   execute: async (params, context) => {
  *     // Tool implementation

package/dist/mcp/factory.js

@@ -50,7 +50,7 @@ const ServerConfigSchema = z.object({
  * });
  *
  * aiCoreServer.registerTool({
- *   name: 'generate-text',
+ *   name: 'generate',
  *   description: 'Generate text using AI providers',
  *   execute: async (params, context) => {
  *     // Tool implementation

package/dist/mcp/function-calling.js

@@ -58,7 +58,7 @@ export async function getAvailableFunctionTools() {
     const toolMap = new Map();
     try {
         // Add overall timeout for the entire function
-        const overallTimeoutMs = 5000; // 5 seconds max for everything
+        const overallTimeoutMs = process.env.NODE_ENV === "test" ? 30000 : 15000; // 30s for tests, 15s for production
         let overallTimeoutId;
         const overallTimeoutPromise = new Promise((_, reject) => {
             overallTimeoutId = setTimeout(() => {

package/dist/mcp/initialize-tools.d.ts

@@ -13,7 +13,7 @@ export declare const initializeMCPTools: (sessionId: string, client: NeuroLinkMC
  * Get all available tools across all servers
  * Useful for documentation and discovery
  */
-export declare function getAllAvailableTools(): Promise<Array<{
+export declare function getAllAvailableTools(inMemoryServers?: Map<string, any>): Promise<Array<{
     serverId: string;
     serverTitle: string;
     toolName: string;

package/dist/mcp/initialize-tools.js

@@ -140,8 +140,52 @@ export const initializeMCPTools = async (sessionId, client, context) => {
  * Get all available tools across all servers
  * Useful for documentation and discovery
  */
-export async function getAllAvailableTools() {
+export async function getAllAvailableTools(inMemoryServers) {
     const tools = [];
+    // Add in-memory server tools first
+    if (inMemoryServers) {
+        for (const [serverId, serverConfig] of inMemoryServers) {
+            const server = serverConfig.server;
+            if (server && server.tools) {
+                // Handle both Map and object formats
+                const toolEntries = server.tools instanceof Map
+                    ? Array.from(server.tools.entries())
+                    : Object.entries(server.tools || {});
+                for (const [toolName, toolInfo] of toolEntries) {
+                    const prefix = `${serverId}_`;
+                    const finalToolName = toolName.length > 64 - prefix.length
+                        ? toolName.substring(0, 64 - prefix.length)
+                        : toolName;
+                    const namespacedName = sanitizeToolName(`${prefix}${finalToolName}`);
+                    // Handle different tool info structures
+                    let description = `Tool from ${serverId}`;
+                    let isImplemented = true;
+                    if (toolInfo) {
+                        // Check if it's a tool info object with description
+                        if (typeof toolInfo.description === "string") {
+                            description = toolInfo.description;
+                        }
+                        else if (typeof toolInfo === "function") {
+                            // It's a raw function, no description available
+                            description = `${toolName} from ${serverId}`;
+                        }
+                        // Check implementation status
+                        if (typeof toolInfo.isImplemented === "boolean") {
+                            isImplemented = toolInfo.isImplemented;
+                        }
+                    }
+                    tools.push({
+                        serverId,
+                        serverTitle: server.title || serverId,
+                        toolName,
+                        namespacedName,
+                        description,
+                        isImplemented,
+                    });
+                }
+            }
+        }
+    }
     const servers = await mcpConfig.getServers();
     servers.forEach((server) => {
         Object.entries(server.tools).forEach(([toolName, tool]) => {