@juspay/neurolink 1.5.3 → 1.9.0

package/dist/lib/providers/openAI.js

@@ -1,57 +1,65 @@
-import { openai } from '@ai-sdk/openai';
-import { streamText, generateText, Output } from 'ai';
-import { logger } from '../utils/logger.js';
+import { openai } from "@ai-sdk/openai";
+import { streamText, generateText, Output, } from "ai";
+import { logger } from "../utils/logger.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
-    systemPrompt: 'You are a helpful AI assistant.'
+    systemPrompt: "You are a helpful AI assistant.",
 };
 // Configuration helpers
 const getOpenAIApiKey = () => {
     const apiKey = process.env.OPENAI_API_KEY;
     if (!apiKey) {
-        throw new Error('OPENAI_API_KEY environment variable is not set');
+        throw new Error("OPENAI_API_KEY environment variable is not set");
     }
     return apiKey;
 };
 const getOpenAIModel = () => {
-    return process.env.OPENAI_MODEL || 'gpt-4o';
+    return process.env.OPENAI_MODEL || "gpt-4o";
 };
 // OpenAI class with enhanced error handling
 export class OpenAI {
     modelName;
     model;
     constructor(modelName) {
-        const functionTag = 'OpenAI.constructor';
+        const functionTag = "OpenAI.constructor";
         this.modelName = modelName || getOpenAIModel();
         try {
-            logger.debug(`[${functionTag}] Function called`, { modelName: this.modelName });
+            logger.debug(`[${functionTag}] Function called`, {
+                modelName: this.modelName,
+            });
             // Set OpenAI API key as environment variable
             process.env.OPENAI_API_KEY = getOpenAIApiKey();
             this.model = openai(this.modelName);
             logger.debug(`[${functionTag}] Function result`, {
                 modelName: this.modelName,
-                success: true
+                success: true,
             });
         }
         catch (err) {
             logger.debug(`[${functionTag}] Exception`, {
-                message: 'Error in initializing OpenAI',
+                message: "Error in initializing OpenAI",
                 modelName: this.modelName,
-                err: String(err)
+                err: String(err),
             });
             throw err;
         }
     }
+    /**
+     * Get the underlying model for function calling
+     */
+    getModel() {
+        return this.model;
+    }
     async streamText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'OpenAI.streamText';
-        const provider = 'openai';
+        const functionTag = "OpenAI.streamText";
+        const provider = "openai";
         let chunkCount = 0;
         try {
             // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === 'string'
+            const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema } = options;
+            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream text started`, {
@@ -59,7 +67,7 @@ export class OpenAI {
                 modelName: this.modelName,
                 promptLength: prompt.length,
                 temperature,
-                maxTokens
+                maxTokens,
             });
             const streamOptions = {
                 model: this.model,
@@ -77,7 +85,7 @@ export class OpenAI {
                         error: errorMessage,
                         stack: errorStack,
                         promptLength: prompt.length,
-                        chunkCount
+                        chunkCount,
                     });
                 },
                 onFinish: (event) => {
@@ -88,7 +96,7 @@ export class OpenAI {
                         usage: event.usage,
                         totalChunks: chunkCount,
                         promptLength: prompt.length,
-                        responseLength: event.text?.length || 0
+                        responseLength: event.text?.length || 0,
                     });
                 },
                 onChunk: (event) => {
@@ -98,12 +106,14 @@ export class OpenAI {
                         modelName: this.modelName,
                         chunkNumber: chunkCount,
                         chunkLength: event.chunk.text?.length || 0,
-                        chunkType: event.chunk.type
+                        chunkType: event.chunk.type,
                     });
-                }
+                },
             };
             if (finalSchema) {
-                streamOptions.experimental_output = Output.object({ schema: finalSchema });
+                streamOptions.experimental_output = Output.object({
+                    schema: finalSchema,
+                });
             }
             const result = streamText(streamOptions);
             return result;
@@ -112,21 +122,21 @@ export class OpenAI {
             logger.debug(`[${functionTag}] Exception`, {
                 provider,
                 modelName: this.modelName,
-                message: 'Error in streaming text',
-                err: String(err)
+                message: "Error in streaming text",
+                err: String(err),
             });
             throw err; // Re-throw error to trigger fallback
         }
     }
     async generateText(optionsOrPrompt, analysisSchema) {
-        const functionTag = 'OpenAI.generateText';
-        const provider = 'openai';
+        const functionTag = "OpenAI.generateText";
+        const provider = "openai";
         try {
             // Parse parameters - support both string and options object
-            const options = typeof optionsOrPrompt === 'string'
+            const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema } = options;
+            const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Generate text started`, {
@@ -134,17 +144,19 @@ export class OpenAI {
                 modelName: this.modelName,
                 promptLength: prompt.length,
                 temperature,
-                maxTokens
+                maxTokens,
             });
             const generateOptions = {
                 model: this.model,
                 prompt: prompt,
                 system: systemPrompt,
                 temperature,
-                maxTokens
+                maxTokens,
             };
             if (finalSchema) {
-                generateOptions.experimental_output = Output.object({ schema: finalSchema });
+                generateOptions.experimental_output = Output.object({
+                    schema: finalSchema,
+                });
             }
             const result = await generateText(generateOptions);
             logger.debug(`[${functionTag}] Generate text completed`, {
@@ -152,7 +164,7 @@ export class OpenAI {
                 modelName: this.modelName,
                 usage: result.usage,
                 finishReason: result.finishReason,
-                responseLength: result.text?.length || 0
+                responseLength: result.text?.length || 0,
             });
             return result;
         }
@@ -160,8 +172,8 @@ export class OpenAI {
             logger.debug(`[${functionTag}] Exception`, {
                 provider,
                 modelName: this.modelName,
-                message: 'Error in generating text',
-                err: String(err)
+                message: "Error in generating text",
+                err: String(err),
             });
             throw err; // Re-throw error to trigger fallback
         }

package/dist/lib/utils/logger.js

@@ -5,7 +5,7 @@
  */
 export const logger = {
     debug: (...args) => {
-        if (process.env.NEUROLINK_DEBUG === 'true') {
+        if (process.env.NEUROLINK_DEBUG === "true") {
             console.log(...args);
         }
     },
@@ -21,5 +21,5 @@ export const logger = {
     },
     always: (...args) => {
         console.log(...args);
-    }
+    },
 };

package/dist/lib/utils/providerUtils.js

@@ -1,7 +1,7 @@
 /**
  * Utility functions for AI provider management
  */
-import { logger } from './logger.js';
+import { logger } from "./logger.js";
 /**
  * Get the best available provider based on preferences and availability
  * @param requestedProvider - Optional preferred provider name
@@ -12,8 +12,19 @@ export function getBestProvider(requestedProvider) {
     if (requestedProvider) {
         return requestedProvider;
     }
-    // Default fallback order based on environment variables - OpenAI first since it's most reliable
-    const providers = ['openai', 'vertex', 'bedrock', 'anthropic', 'azure', 'google-ai'];
+    // Default fallback order - Google AI (Gemini) first as primary provider
+    // Ollama last since it requires local setup
+    const providers = [
+        "google-ai",
+        "anthropic",
+        "openai",
+        "mistral",
+        "vertex",
+        "azure",
+        "huggingface",
+        "bedrock",
+        "ollama",
+    ];
     // Check which providers have their required environment variables
     for (const provider of providers) {
         if (isProviderConfigured(provider)) {
@@ -22,8 +33,8 @@ export function getBestProvider(requestedProvider) {
         }
     }
     // Default to bedrock if nothing is configured
-    logger.warn('[getBestProvider] No providers configured, defaulting to bedrock');
-    return 'bedrock';
+    logger.warn("[getBestProvider] No providers configured, defaulting to bedrock");
+    return "bedrock";
 }
 /**
  * Check if a provider has the minimum required configuration
@@ -32,26 +43,42 @@ export function getBestProvider(requestedProvider) {
  */
 function isProviderConfigured(provider) {
     switch (provider.toLowerCase()) {
-        case 'bedrock':
-        case 'amazon':
-        case 'aws':
+        case "bedrock":
+        case "amazon":
+        case "aws":
             return !!(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY);
-        case 'vertex':
-        case 'google':
-        case 'gemini':
-            return !!(process.env.GOOGLE_VERTEX_PROJECT || process.env.GOOGLE_APPLICATION_CREDENTIALS);
-        case 'openai':
-        case 'gpt':
+        case "vertex":
+        case "google":
+        case "gemini":
+            return !!(process.env.GOOGLE_VERTEX_PROJECT ||
+                process.env.GOOGLE_APPLICATION_CREDENTIALS);
+        case "openai":
+        case "gpt":
             return !!process.env.OPENAI_API_KEY;
-        case 'anthropic':
-        case 'claude':
+        case "anthropic":
+        case "claude":
             return !!process.env.ANTHROPIC_API_KEY;
-        case 'azure':
-        case 'azure-openai':
+        case "azure":
+        case "azure-openai":
             return !!process.env.AZURE_OPENAI_API_KEY;
-        case 'google-ai':
-        case 'google-studio':
-            return !!(process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY);
+        case "google-ai":
+        case "google-studio":
+            return !!(process.env.GOOGLE_AI_API_KEY ||
+                process.env.GOOGLE_GENERATIVE_AI_API_KEY);
+        case "huggingface":
+        case "hugging-face":
+        case "hf":
+            return !!(process.env.HUGGINGFACE_API_KEY || process.env.HF_TOKEN);
+        case "ollama":
+        case "local":
+        case "local-ollama":
+            // For Ollama, we check if the service is potentially available
+            // This is a basic check - actual connectivity will be verified during usage
+            return true; // Ollama doesn't require environment variables, just local service
+        case "mistral":
+        case "mistral-ai":
+        case "mistralai":
+            return !!process.env.MISTRAL_API_KEY;
         default:
             return false;
     }
@@ -61,7 +88,17 @@ function isProviderConfigured(provider) {
  * @returns Array of available provider names
  */
 export function getAvailableProviders() {
-    return ['bedrock', 'vertex', 'openai', 'anthropic', 'azure', 'google-ai'];
+    return [
+        "bedrock",
+        "vertex",
+        "openai",
+        "anthropic",
+        "azure",
+        "google-ai",
+        "huggingface",
+        "ollama",
+        "mistral",
+    ];
 }
 /**
  * Validate provider name

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

@@ -0,0 +1,120 @@
+/**
+ * NeuroLink MCP Auto-Discovery System
+ * Automatically discovers MCP servers from common configuration locations across different tools
+ * Supports VS Code, Cursor, Claude Desktop, Windsurf, Roo Code, and generic configurations
+ */
+import { MCPToolRegistry } from "./registry.js";
+/**
+ * Discovered MCP server configuration
+ */
+export interface DiscoveredMCPServer {
+    id: string;
+    title: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    source: DiscoverySource;
+    configPath: string;
+    rawConfig: any;
+}
+/**
+ * Discovery source information
+ */
+export interface DiscoverySource {
+    tool: string;
+    type: "global" | "workspace" | "project";
+    priority: number;
+    description: string;
+}
+/**
+ * Discovery configuration options
+ */
+export interface DiscoveryOptions {
+    searchWorkspace?: boolean;
+    searchGlobal?: boolean;
+    searchCommonPaths?: boolean;
+    followSymlinks?: boolean;
+    maxDepth?: number;
+    includeInactive?: boolean;
+    preferredTools?: string[];
+}
+/**
+ * Discovery result
+ */
+export interface DiscoveryResult {
+    discovered: DiscoveredMCPServer[];
+    sources: DiscoverySource[];
+    errors: string[];
+    stats: {
+        configFilesFound: number;
+        serversDiscovered: number;
+        duplicatesRemoved: number;
+        executionTime: number;
+    };
+}
+/**
+ * MCP Auto-Discovery Engine
+ */
+export declare class MCPAutoDiscovery {
+    private parsers;
+    /**
+     * Discover MCP servers from all common locations
+     *
+     * @param options Discovery configuration options
+     * @returns Discovery result with found servers
+     */
+    discoverServers(options?: DiscoveryOptions): Promise<DiscoveryResult>;
+    /**
+     * Auto-register discovered servers with a registry
+     *
+     * @param registry Target MCP registry
+     * @param options Discovery options
+     * @returns Registration results
+     */
+    autoRegisterServers(registry: MCPToolRegistry, options?: DiscoveryOptions): Promise<{
+        registered: string[];
+        failed: string[];
+        errors: string[];
+    }>;
+    /**
+     * Get standard search paths for MCP configurations
+     */
+    private getSearchPaths;
+    /**
+     * Search a specific path for MCP configurations
+     */
+    private searchPath;
+    /**
+     * Parse JSON with resilience to common syntax issues
+     */
+    private parseJsonResilient;
+    /**
+     * Remove duplicate servers and apply prioritization
+     */
+    private deduplicateServers;
+    /**
+     * Map tool names to valid MCP server categories
+     */
+    private mapToolToCategory;
+    /**
+     * Convert discovered server to NeuroLink MCP server format
+     */
+    private convertToMCPServer;
+}
+/**
+ * Default auto-discovery instance
+ */
+export declare const defaultAutoDiscovery: MCPAutoDiscovery;
+/**
+ * Utility function to discover servers with default instance
+ */
+export declare function discoverMCPServers(options?: DiscoveryOptions): Promise<DiscoveryResult>;
+/**
+ * Utility function to auto-register discovered servers
+ */
+export declare function autoRegisterMCPServers(registry: MCPToolRegistry, options?: DiscoveryOptions): Promise<{
+    registered: string[];
+    failed: string[];
+    errors: string[];
+}>;