@juspay/neurolink 6.1.0 → 6.2.1

package/dist/lib/factories/compatibility-factory.js

@@ -1,71 +0,0 @@
-/**
- * Compatibility conversion factory for seamless migration
- * between generateText and generate functions
- */
-export class CompatibilityConversionFactory {
-    /**
-     * Convert TextGenerationOptions to GenerateOptions
-     */
-    static convertTextToGenerate(options) {
-        const { prompt, ...rest } = options;
-        return {
-            input: { text: prompt || "" },
-            output: { format: "text" },
-            provider: rest.provider,
-            model: rest.model,
-            temperature: rest.temperature,
-            maxTokens: rest.maxTokens,
-            systemPrompt: rest.systemPrompt,
-            schema: rest.schema,
-            tools: rest.tools,
-            timeout: rest.timeout,
-            enableEvaluation: rest.enableEvaluation,
-            enableAnalytics: rest.enableAnalytics,
-            context: rest.context,
-            evaluationDomain: rest.evaluationDomain,
-            toolUsageContext: rest.toolUsageContext,
-            conversationHistory: rest.conversationHistory,
-        };
-    }
-    /**
-     * Convert GenerateResult to legacy TextGenerationResult format
-     */
-    static convertGenerateToText(result) {
-        return {
-            content: result.content,
-            provider: result.provider,
-            model: result.model,
-            usage: result.usage,
-            responseTime: result.responseTime,
-            toolsUsed: Array.isArray(result.toolsUsed)
-                ? result.toolsUsed.length
-                : result.toolsUsed,
-            toolExecutions: result.toolExecutions,
-            enhancedWithTools: result.enhancedWithTools,
-            availableTools: result.availableTools,
-            analytics: result.analytics,
-            evaluation: result.evaluation,
-        };
-    }
-    /**
-     * Convert GenerateOptions to TextGenerationOptions
-     */
-    static convertGenerateToText_Options(options) {
-        return {
-            prompt: options.input.text,
-            model: options.model,
-            temperature: options.temperature,
-            maxTokens: options.maxTokens,
-            systemPrompt: options.systemPrompt,
-            schema: options.schema,
-            tools: options.tools,
-            timeout: options.timeout,
-            enableEvaluation: options.enableEvaluation,
-            enableAnalytics: options.enableAnalytics,
-            context: options.context,
-            evaluationDomain: options.evaluationDomain,
-            toolUsageContext: options.toolUsageContext,
-            conversationHistory: options.conversationHistory,
-        };
-    }
-}

package/dist/lib/factories/provider-generate-factory.d.ts

@@ -1,20 +0,0 @@
-import type { EnhancedProvider } from "../types/generate-types.js";
-import type { AIProvider } from "../core/types.js";
-/**
- * Factory for enhancing providers with generate() capability using Proxy pattern
- * Maintains 100% backward compatibility while adding new generate method
- */
-export declare class ProviderGenerateFactory {
-    /**
-     * Enhance any provider with generate() method using TypeScript Proxy
-     */
-    static enhanceProvider<T extends AIProvider>(provider: T): T & EnhancedProvider;
-    /**
-     * Create the generate() method that internally uses generateText for performance parity
-     */
-    private static createGenerateMethod;
-    /**
-     * Enhance all providers from a registry
-     */
-    static enhanceAllProviders(providers: Map<string, AIProvider>): Map<string, AIProvider & EnhancedProvider>;
-}

package/dist/lib/factories/provider-generate-factory.js

@@ -1,93 +0,0 @@
-import { CompatibilityConversionFactory } from "./compatibility-factory.js";
-/**
- * Factory for enhancing providers with generate() capability using Proxy pattern
- * Maintains 100% backward compatibility while adding new generate method
- */
-export class ProviderGenerateFactory {
-    /**
-     * Enhance any provider with generate() method using TypeScript Proxy
-     */
-    static enhanceProvider(provider) {
-        return new Proxy(provider, {
-            get(target, prop, receiver) {
-                if (prop === "generate") {
-                    return ProviderGenerateFactory.createGenerateMethod(target);
-                }
-                return Reflect.get(target, prop, receiver);
-            },
-            has(target, prop) {
-                if (prop === "generate") {
-                    return true;
-                }
-                return Reflect.has(target, prop);
-            },
-        });
-    }
-    /**
-     * Create the generate() method that internally uses generateText for performance parity
-     */
-    static createGenerateMethod(provider) {
-        return async (options) => {
-            // Validate input
-            if (!options.input?.text) {
-                throw new Error("Generate options must include input.text");
-            }
-            // Convert GenerateOptions to TextGenerationOptions
-            const textOptions = CompatibilityConversionFactory.convertGenerateToText_Options(options);
-            try {
-                // Use existing generate method for identical performance
-                const textResult = await provider.generate(textOptions);
-                if (!textResult) {
-                    throw new Error("Generate method returned null result");
-                }
-                // Convert back to GenerateResult format with type safety
-                const generateResult = {
-                    content: textResult.content || "",
-                    outputs: { text: textResult.content || "" },
-                    provider: textResult.provider,
-                    model: textResult.model,
-                    usage: textResult.usage
-                        ? {
-                            inputTokens: textResult.usage.inputTokens || 0,
-                            outputTokens: textResult.usage.outputTokens || 0,
-                            totalTokens: textResult.usage.totalTokens || 0,
-                        }
-                        : undefined,
-                    responseTime: textResult.responseTime,
-                    toolsUsed: textResult.toolsUsed,
-                    toolExecutions: textResult.toolExecutions?.map((te) => {
-                        const toolExecution = te;
-                        return {
-                            name: toolExecution.toolName || toolExecution.name || "",
-                            input: toolExecution.input || {},
-                            output: toolExecution.output || toolExecution.result,
-                            duration: toolExecution.executionTime || toolExecution.duration || 0,
-                        };
-                    }),
-                    enhancedWithTools: textResult.enhancedWithTools,
-                    availableTools: textResult.availableTools?.map((at) => ({
-                        name: at.name || "",
-                        description: at.description || "",
-                        parameters: at.parameters || {},
-                    })),
-                    analytics: textResult.analytics,
-                    evaluation: textResult.evaluation,
-                };
-                return generateResult;
-            }
-            catch (error) {
-                throw new Error(`Generate method failed: ${error}`);
-            }
-        };
-    }
-    /**
-     * Enhance all providers from a registry
-     */
-    static enhanceAllProviders(providers) {
-        const enhancedProviders = new Map();
-        for (const [name, provider] of providers) {
-            enhancedProviders.set(name, this.enhanceProvider(provider));
-        }
-        return enhancedProviders;
-    }
-}

package/dist/lib/mcp/adapters/plugin-bridge.d.ts

@@ -1,40 +0,0 @@
-/**
- * Plugin Bridge Adapter
- * Provides compatibility layer for existing MCP integrations
- */
-import type { ExecutionContext } from "../contracts/mcp-contract.js";
-import type { JsonValue, UnknownRecord, Unknown } from "../../types/common.js";
-/**
- * Bridge interface for legacy MCP compatibility
- */
-export interface LegacyMCPBridge {
-    writeFile: (filePath: string, content: string) => Promise<void>;
-    readFile: (filePath: string) => Promise<string>;
-    listFiles: (dirPath: string) => Promise<string[]>;
-}
-/**
- * Create a bridge for legacy MCP integrations
- */
-export declare function createLegacyBridge(context: ExecutionContext): LegacyMCPBridge;
-/**
- * Enhanced execution context with bridge compatibility
- */
-export declare function enhanceExecutionContext(context: ExecutionContext): ExecutionContext;
-/**
- * Utility function to adapt legacy MCP calls
- */
-export declare function adaptLegacyMCPCall(context: ExecutionContext, operation: string, ...args: JsonValue[]): Promise<Unknown>;
-/**
- * Quick plugin factory for simple plugin creation
- */
-export declare class QuickPluginFactory {
-    static create(name: string, config: UnknownRecord): Promise<{
-        name: string;
-        config: UnknownRecord;
-        initialized: boolean;
-    }>;
-}
-/**
- * Execute plugin with enhanced context
- */
-export declare function executePlugin(plugin: UnknownRecord, context: ExecutionContext, operation: string, ...args: JsonValue[]): Promise<Unknown>;

package/dist/lib/mcp/adapters/plugin-bridge.js

@@ -1,89 +0,0 @@
-/**
- * Plugin Bridge Adapter
- * Provides compatibility layer for existing MCP integrations
- */
-import * as path from "path";
-/**
- * Create a bridge for legacy MCP integrations
- */
-export function createLegacyBridge(context) {
-    const basePath = process.cwd();
-    return {
-        async writeFile(filePath, content) {
-            const fullPath = path.resolve(basePath, filePath);
-            await context.secureFS.writeFile(fullPath, content);
-        },
-        async readFile(filePath) {
-            const fullPath = path.resolve(basePath, filePath);
-            const result = await context.secureFS.readFile(fullPath, "utf-8");
-            return typeof result === "string" ? result : result.toString();
-        },
-        async listFiles(dirPath) {
-            const fullPath = path.resolve(basePath, dirPath);
-            return await context.secureFS.readdir(fullPath);
-        },
-    };
-}
-/**
- * Enhanced execution context with bridge compatibility
- */
-export function enhanceExecutionContext(context) {
-    return {
-        ...context,
-        path: {
-            join: path.join,
-            resolve: path.resolve,
-            relative: path.relative,
-            dirname: path.dirname,
-            basename: path.basename,
-        },
-        plugin: createLegacyBridge(context),
-    };
-}
-/**
- * Utility function to adapt legacy MCP calls
- */
-export async function adaptLegacyMCPCall(context, operation, ...args) {
-    const bridge = createLegacyBridge(context);
-    switch (operation) {
-        case "writeFile": {
-            const filePath = typeof args[0] === "string" ? args[0] : String(args[0]);
-            const content = typeof args[1] === "string" ? args[1] : String(args[1]);
-            return bridge.writeFile(filePath, content);
-        }
-        case "readFile": {
-            const readPath = typeof args[0] === "string" ? args[0] : String(args[0]);
-            return bridge.readFile(readPath);
-        }
-        case "listFiles": {
-            const listPath = typeof args[0] === "string" ? args[0] : String(args[0]);
-            return bridge.listFiles(listPath);
-        }
-        default:
-            throw new Error(`Unsupported legacy operation: ${operation}`);
-    }
-}
-/**
- * Quick plugin factory for simple plugin creation
- */
-export class QuickPluginFactory {
-    static async create(name, config) {
-        // Simple factory implementation
-        return {
-            name,
-            config,
-            initialized: true,
-        };
-    }
-}
-/**
- * Execute plugin with enhanced context
- */
-export async function executePlugin(plugin, context, operation, ...args) {
-    const enhancedContext = enhanceExecutionContext(context);
-    if (typeof plugin.execute === "function") {
-        return plugin.execute(enhancedContext, { operation, args });
-    }
-    // Fallback to legacy adaptation
-    return adaptLegacyMCPCall(enhancedContext, operation, ...args);
-}

package/dist/lib/mcp/auto-discovery.d.ts

@@ -1,62 +0,0 @@
-/**
- * Auto-Discovery Module for MCP Plugins
- * Handles automatic plugin discovery and registration
- */
-import type { DiscoveredMCP } from "./contracts/mcp-contract.js";
-/**
- * Auto-discovery configuration
- */
-interface AutoDiscoveryConfig {
-    searchPaths: string[];
-    manifestName: string;
-    maxDepth: number;
-}
-/**
- * Auto-discovery service for MCP plugins
- */
-export declare class AutoDiscovery {
-    private config;
-    constructor(config?: Partial<AutoDiscoveryConfig>);
-    /**
-     * Discover all available MCP plugins
-     */
-    discover(): Promise<DiscoveredMCP[]>;
-    /**
-     * Discover plugins in a specific path
-     */
-    private discoverInPath;
-    /**
-     * Load plugin from manifest
-     */
-    private loadPlugin;
-    /**
-     * Determine plugin source based on path
-     */
-    private determineSource;
-}
-/**
- * Default auto-discovery instance
- */
-export declare const autoDiscovery: AutoDiscovery;
-/**
- * Discovery options interface
- */
-export interface DiscoveryOptions {
-    searchPaths?: string[];
-    manifestName?: string;
-    maxDepth?: number;
-    includeDevPlugins?: boolean;
-}
-/**
- * Discover MCP servers using auto-discovery
- */
-export declare function discoverMCPServers(options?: DiscoveryOptions): Promise<DiscoveredMCP[]>;
-/**
- * Auto-register discovered MCP servers
- */
-export declare function autoRegisterMCPServers(options?: DiscoveryOptions): Promise<{
-    registered: number;
-    failed: number;
-    plugins: DiscoveredMCP[];
-}>;
-export {};

package/dist/lib/mcp/auto-discovery.js

@@ -1,149 +0,0 @@
-/**
- * Auto-Discovery Module for MCP Plugins
- * Handles automatic plugin discovery and registration
- */
-import * as fs from "fs/promises";
-import * as path from "path";
-import { autoDiscoveryLogger } from "./logging.js";
-/**
- * Default auto-discovery configuration
- */
-const DEFAULT_CONFIG = {
-    searchPaths: ["./src/lib/mcp/plugins", "./neurolink-mcp", "./node_modules"],
-    manifestName: "neurolink-mcp.json",
-    maxDepth: 3,
-};
-/**
- * Auto-discovery service for MCP plugins
- */
-export class AutoDiscovery {
-    config;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Discover all available MCP plugins
-     */
-    async discover() {
-        const discovered = [];
-        for (const searchPath of this.config.searchPaths) {
-            try {
-                const plugins = await this.discoverInPath(searchPath);
-                discovered.push(...plugins);
-            }
-            catch (error) {
-                autoDiscoveryLogger.debug(`Failed to discover in ${searchPath}:`, error);
-            }
-        }
-        autoDiscoveryLogger.info(`Auto-discovery completed: ${discovered.length} plugins found`);
-        return discovered;
-    }
-    /**
-     * Discover plugins in a specific path
-     */
-    async discoverInPath(basePath, depth = 0) {
-        if (depth > this.config.maxDepth) {
-            return [];
-        }
-        const discovered = [];
-        try {
-            const items = await fs.readdir(basePath);
-            for (const item of items) {
-                const itemPath = path.join(basePath, item);
-                const stats = await fs.stat(itemPath);
-                if (stats.isDirectory()) {
-                    // Check for manifest in this directory
-                    const manifestPath = path.join(itemPath, this.config.manifestName);
-                    try {
-                        await fs.access(manifestPath);
-                        const plugin = await this.loadPlugin(manifestPath, itemPath);
-                        if (plugin) {
-                            discovered.push(plugin);
-                        }
-                    }
-                    catch {
-                        // No manifest, continue searching subdirectories
-                        const subPlugins = await this.discoverInPath(itemPath, depth + 1);
-                        discovered.push(...subPlugins);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            autoDiscoveryLogger.debug(`Failed to scan ${basePath}:`, error);
-        }
-        return discovered;
-    }
-    /**
-     * Load plugin from manifest
-     */
-    async loadPlugin(manifestPath, pluginPath) {
-        try {
-            const manifestContent = await fs.readFile(manifestPath, "utf-8");
-            const metadata = JSON.parse(manifestContent);
-            // Validate basic metadata
-            if (!metadata.name || !metadata.version || !metadata.main) {
-                autoDiscoveryLogger.warn(`Invalid manifest at ${manifestPath}`);
-                return null;
-            }
-            const entryPath = path.resolve(pluginPath, metadata.main);
-            return {
-                metadata,
-                entryPath,
-                source: this.determineSource(pluginPath),
-                constructor: undefined,
-            };
-        }
-        catch (error) {
-            autoDiscoveryLogger.error(`Failed to load plugin manifest at ${manifestPath}:`, error);
-            return null;
-        }
-    }
-    /**
-     * Determine plugin source based on path
-     */
-    determineSource(pluginPath) {
-        if (pluginPath.includes("node_modules")) {
-            return "installed";
-        }
-        if (pluginPath.includes("src/lib/mcp/plugins")) {
-            return "core";
-        }
-        return "project";
-    }
-}
-/**
- * Default auto-discovery instance
- */
-export const autoDiscovery = new AutoDiscovery();
-/**
- * Discover MCP servers using auto-discovery
- */
-export async function discoverMCPServers(options = {}) {
-    const discovery = new AutoDiscovery(options);
-    return discovery.discover();
-}
-/**
- * Auto-register discovered MCP servers
- */
-export async function autoRegisterMCPServers(options = {}) {
-    const discovered = await discoverMCPServers(options);
-    let registered = 0;
-    let failed = 0;
-    for (const plugin of discovered) {
-        try {
-            // Registration logic would go here
-            autoDiscoveryLogger.info(`Registered plugin: ${plugin.metadata.name}`);
-            registered++;
-        }
-        catch (error) {
-            autoDiscoveryLogger.error(`Failed to register ${plugin.metadata.name}:`, error);
-            failed++;
-        }
-    }
-    return {
-        registered,
-        failed,
-        plugins: discovered,
-    };
-}

package/dist/lib/mcp/client.d.ts

@@ -1,68 +0,0 @@
-/**
- * NeuroLink MCP Client
- * Following Lighthouse's pattern for MCP tool registration and execution
- */
-import { EventEmitter } from "events";
-import type { ToolResult, NeuroLinkExecutionContext } from "./factory.js";
-import type { Unknown } from "../types/common.js";
-/**
- * MCP Client Configuration
- */
-export interface MCPClientConfig {
-    sessionId: string;
-    userId?: string;
-    aiProvider?: string;
-    modelId?: string;
-    logLevel?: "debug" | "info" | "warn" | "error";
-}
-/**
- * NeuroLink MCP Client
- * Manages tool registration and execution following Lighthouse patterns
- */
-export declare class NeuroLinkMCPClient extends EventEmitter {
-    private tools;
-    private config;
-    private executionCount;
-    private isConnected;
-    constructor(config: MCPClientConfig);
-    /**
-     * Register a tool with the MCP client
-     * Following Lighthouse's pattern of namespacing tools with server ID
-     */
-    registerTool(toolName: string, execute: (name: string, params: Record<string, unknown>) => Promise<Unknown>, description?: string, inputSchema?: unknown): void;
-    /**
-     * Get all registered tools
-     */
-    getTools(): Record<string, {
-        name: string;
-        description?: string;
-        inputSchema?: unknown;
-    }>;
-    /**
-     * Execute a tool by name
-     */
-    executeTool(toolName: string, params: unknown, context?: Partial<NeuroLinkExecutionContext>): Promise<ToolResult>;
-    /**
-     * Check if connected to MCP
-     */
-    isConnectedToMCP(): boolean;
-    /**
-     * Disconnect from MCP
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Get client statistics
-     */
-    getStats(): {
-        sessionId: string;
-        toolCount: number;
-        executionCount: number;
-        isConnected: boolean;
-        uptime: number;
-    };
-    private startTime;
-}
-/**
- * Create a new MCP client instance
- */
-export declare function createMCPClient(config: MCPClientConfig): NeuroLinkMCPClient;