@juspay/neurolink 1.2.4 → 1.3.0

package/dist/mcp/servers/ai-providers/ai-core-server.js

@@ -0,0 +1,280 @@
+/**
+ * NeuroLink AI Core Server
+ * Wraps existing AI provider functionality as MCP tools for orchestration
+ * Integrates AIProviderFactory with Factory-First MCP architecture
+ */
+import { z } from 'zod';
+import { createMCPServer } from '../../factory.js';
+import { AIProviderFactory } from '../../../core/factory.js';
+import { getBestProvider, getAvailableProviders } from '../../../utils/providerUtils.js';
+/**
+ * AI Core Server - Central hub for AI provider tools
+ * Provides text generation, provider selection, and AI capabilities
+ */
+export const aiCoreServer = createMCPServer({
+    id: 'neurolink-ai-core',
+    title: 'NeuroLink AI Core',
+    description: 'Core AI provider tools with automatic fallback and orchestration',
+    category: 'ai-providers',
+    version: '1.0.0',
+    capabilities: [
+        'text-generation',
+        'provider-selection',
+        'automatic-fallback',
+        'usage-tracking',
+        'multi-provider-support'
+    ]
+});
+/**
+ * Text Generation Input Schema
+ */
+const TextGenerationSchema = z.object({
+    prompt: z.string().min(1, 'Prompt is required'),
+    provider: z.enum(['openai', 'bedrock', 'vertex', 'anthropic']).optional(),
+    model: z.string().optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    maxTokens: z.number().positive().optional(),
+    systemPrompt: z.string().optional()
+});
+/**
+ * Provider Selection Input Schema
+ */
+const ProviderSelectionSchema = z.object({
+    preferred: z.string().optional(),
+    requirements: z.object({
+        multimodal: z.boolean().optional(),
+        streaming: z.boolean().optional(),
+        maxTokens: z.number().optional(),
+        costEfficient: z.boolean().optional()
+    }).optional()
+});
+/**
+ * Register Text Generation Tool
+ * Core tool that leverages existing AIProviderFactory for text generation
+ */
+aiCoreServer.registerTool({
+    name: 'generate-text',
+    description: 'Generate text using AI providers with automatic fallback and provider selection',
+    category: 'text-generation',
+    inputSchema: TextGenerationSchema,
+    isImplemented: true,
+    execute: async (params, context) => {
+        const startTime = Date.now();
+        try {
+            console.log(`[AI-Core] Starting text generation: "${params.prompt.substring(0, 50)}..."`);
+            // Use existing AIProviderFactory with best provider selection
+            const selectedProvider = params.provider || getBestProvider(params.provider);
+            const provider = AIProviderFactory.createBestProvider(selectedProvider);
+            // Generate text using existing NeuroLink patterns
+            const result = await provider.generateText({
+                prompt: params.prompt,
+                model: params.model,
+                temperature: params.temperature,
+                maxTokens: params.maxTokens,
+                systemPrompt: params.systemPrompt
+            });
+            if (!result) {
+                throw new Error('AI provider returned null result');
+            }
+            const executionTime = Date.now() - startTime;
+            console.log(`[AI-Core] Text generation successful in ${executionTime}ms using ${selectedProvider}`);
+            return {
+                success: true,
+                data: {
+                    text: result.text,
+                    model: params.model || 'default',
+                    provider: selectedProvider,
+                    generatedAt: new Date().toISOString()
+                },
+                usage: {
+                    tokens: result.usage?.totalTokens,
+                    provider: selectedProvider,
+                    model: params.model || 'default',
+                    executionTime
+                },
+                metadata: {
+                    toolName: 'generate-text',
+                    serverId: 'neurolink-ai-core',
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime
+                }
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`[AI-Core] Text generation failed: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+                metadata: {
+                    toolName: 'generate-text',
+                    serverId: 'neurolink-ai-core',
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime
+                }
+            };
+        }
+    }
+});
+/**
+ * Register Provider Selection Tool
+ * Intelligent provider selection based on requirements and availability
+ */
+aiCoreServer.registerTool({
+    name: 'select-provider',
+    description: 'Select the best available AI provider based on requirements and availability',
+    category: 'provider-management',
+    inputSchema: ProviderSelectionSchema,
+    isImplemented: true,
+    execute: async (params, context) => {
+        const startTime = Date.now();
+        try {
+            console.log(`[AI-Core] Selecting provider with requirements:`, params.requirements);
+            // Use existing provider selection logic
+            const availableProviders = getAvailableProviders();
+            const selectedProvider = getBestProvider(params.preferred);
+            // Get provider capabilities (mock for now, can be enhanced)
+            const getProviderCapabilities = (provider) => ({
+                multimodal: provider === 'openai' || provider === 'vertex',
+                streaming: provider === 'openai' || provider === 'anthropic',
+                maxTokens: provider === 'anthropic' ? 100000 : 4000,
+                costEfficient: provider === 'openai' || provider === 'vertex'
+            });
+            const capabilities = getProviderCapabilities(selectedProvider);
+            const executionTime = Date.now() - startTime;
+            console.log(`[AI-Core] Selected provider: ${selectedProvider} in ${executionTime}ms`);
+            return {
+                success: true,
+                data: {
+                    provider: selectedProvider,
+                    available: availableProviders,
+                    capabilities,
+                    reason: params.preferred
+                        ? `Preferred provider ${params.preferred} selected`
+                        : 'Best available provider selected',
+                    selectedAt: new Date().toISOString()
+                },
+                usage: {
+                    executionTime
+                },
+                metadata: {
+                    toolName: 'select-provider',
+                    serverId: 'neurolink-ai-core',
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime
+                }
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`[AI-Core] Provider selection failed: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+                metadata: {
+                    toolName: 'select-provider',
+                    serverId: 'neurolink-ai-core',
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime
+                }
+            };
+        }
+    }
+});
+/**
+ * Register Provider Status Tool
+ * Check health and availability of AI providers
+ */
+aiCoreServer.registerTool({
+    name: 'check-provider-status',
+    description: 'Check the health and availability status of AI providers',
+    category: 'provider-management',
+    inputSchema: z.object({
+        provider: z.string().optional(),
+        includeCapabilities: z.boolean().default(true)
+    }),
+    isImplemented: true,
+    execute: async (params, context) => {
+        const startTime = Date.now();
+        try {
+            console.log(`[AI-Core] Checking provider status for: ${params.provider || 'all providers'}`);
+            const availableProviders = getAvailableProviders();
+            const providerStatuses = [];
+            const providersToCheck = params.provider ? [params.provider] : availableProviders;
+            for (const provider of providersToCheck) {
+                try {
+                    // Quick health check (can be enhanced with actual API calls)
+                    const isAvailable = availableProviders.includes(provider);
+                    providerStatuses.push({
+                        provider,
+                        status: isAvailable ? 'available' : 'unavailable',
+                        capabilities: params.includeCapabilities ? {
+                            textGeneration: true,
+                            multimodal: provider === 'openai' || provider === 'vertex',
+                            streaming: provider === 'openai' || provider === 'anthropic',
+                            maxTokens: provider === 'anthropic' ? 100000 : 4000
+                        } : undefined,
+                        lastChecked: new Date().toISOString()
+                    });
+                }
+                catch (error) {
+                    providerStatuses.push({
+                        provider,
+                        status: 'error',
+                        error: error instanceof Error ? error.message : String(error),
+                        lastChecked: new Date().toISOString()
+                    });
+                }
+            }
+            const executionTime = Date.now() - startTime;
+            console.log(`[AI-Core] Provider status check completed in ${executionTime}ms`);
+            return {
+                success: true,
+                data: {
+                    providers: providerStatuses,
+                    summary: {
+                        total: providerStatuses.length,
+                        available: providerStatuses.filter(p => p.status === 'available').length,
+                        unavailable: providerStatuses.filter(p => p.status === 'unavailable').length,
+                        errors: providerStatuses.filter(p => p.status === 'error').length
+                    },
+                    checkedAt: new Date().toISOString()
+                },
+                usage: {
+                    executionTime
+                },
+                metadata: {
+                    toolName: 'check-provider-status',
+                    serverId: 'neurolink-ai-core',
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime
+                }
+            };
+        }
+        catch (error) {
+            const executionTime = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`[AI-Core] Provider status check failed: ${errorMessage}`);
+            return {
+                success: false,
+                error: errorMessage,
+                metadata: {
+                    toolName: 'check-provider-status',
+                    serverId: 'neurolink-ai-core',
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime
+                }
+            };
+        }
+    }
+});
+// Log successful server creation
+console.log('[AI-Core] NeuroLink AI Core Server created with tools:', Object.keys(aiCoreServer.tools));

package/dist/utils/providerUtils.js

@@ -12,7 +12,7 @@ export function getBestProvider(requestedProvider) {
         return requestedProvider;
     }
     // Default fallback order based on environment variables - OpenAI first since it's most reliable
-    const providers = ['openai', 'vertex', 'bedrock'];
+    const providers = ['openai', 'vertex', 'bedrock', 'anthropic', 'azure'];
     // Check which providers have their required environment variables
     for (const provider of providers) {
         if (isProviderConfigured(provider)) {
@@ -42,6 +42,12 @@ function isProviderConfigured(provider) {
         case 'openai':
         case 'gpt':
             return !!process.env.OPENAI_API_KEY;
+        case 'anthropic':
+        case 'claude':
+            return !!process.env.ANTHROPIC_API_KEY;
+        case 'azure':
+        case 'azure-openai':
+            return !!process.env.AZURE_OPENAI_API_KEY;
         default:
             return false;
     }
@@ -51,7 +57,7 @@ function isProviderConfigured(provider) {
  * @returns Array of available provider names
  */
 export function getAvailableProviders() {
-    return ['bedrock', 'vertex', 'openai'];
+    return ['bedrock', 'vertex', 'openai', 'anthropic', 'azure'];
 }
 /**
  * Validate provider name

package/package.json

@@ -1,13 +1,38 @@
 {
   "name": "@juspay/neurolink",
-  "version": "1.2.4",
-  "description": "AI toolkit with multi-provider support for OpenAI, Amazon Bedrock, and Google Vertex AI",
-  "author": "Juspay Technologies",
+  "version": "1.3.0",
+  "description": "Universal AI Development Platform with external MCP server integration, multi-provider support, and professional CLI. Connect to 65+ MCP servers for filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with OpenAI, Anthropic, Google Vertex AI, and AWS Bedrock.",
+  "author": {
+    "name": "Juspay Technologies",
+    "email": "support@juspay.in",
+    "url": "https://juspay.io"
+  },
   "license": "MIT",
+  "homepage": "https://github.com/juspay/neurolink#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/juspay/neurolink.git"
+  },
+  "bugs": {
+    "url": "https://github.com/juspay/neurolink/issues"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "https://github.com/sponsors/juspay"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=8.0.0",
+    "pnpm": ">=8.0.0"
+  },
   "files": [
     "dist",
     "!dist/**/*.test.*",
-    "!dist/**/*.spec.*"
+    "!dist/**/*.spec.*",
+    "!dist/**/*.map",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
   ],
   "sideEffects": [
     "**/*.css"
@@ -25,6 +50,12 @@
       "svelte": "./dist/index.js",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json",
+    "./cli": {
+      "types": "./dist/cli/index.d.ts",
+      "import": "./dist/cli/index.js",
+      "default": "./dist/cli/index.js"
     }
   },
   "peerDependencies": {
@@ -34,6 +65,17 @@
     "ai": "^4.0.0",
     "zod": "^3.22.0"
   },
+  "peerDependenciesMeta": {
+    "@ai-sdk/amazon-bedrock": {
+      "optional": true
+    },
+    "@ai-sdk/google-vertex": {
+      "optional": true
+    },
+    "@ai-sdk/openai": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "chalk": "^5.3.0",
     "dotenv": "^16.5.0",
@@ -65,6 +107,11 @@
   "keywords": [
     "ai",
     "llm",
+    "mcp",
+    "model-context-protocol",
+    "lighthouse",
+    "tool-orchestration",
+    "ai-platform",
     "openai",
     "anthropic",
     "google",
@@ -74,12 +121,35 @@
     "tools",
     "neurolink",
     "juspay",
-    "svelte"
+    "svelte",
+    "chatgpt",
+    "gpt-4",
+    "claude",
+    "gemini",
+    "ai-sdk",
+    "typescript",
+    "cli-tool",
+    "developer-tools",
+    "automation",
+    "machine-learning",
+    "artificial-intelligence",
+    "multi-provider",
+    "ai-agents",
+    "prompt-engineering",
+    "ai-workflow",
+    "universal-ai",
+    "ai-development",
+    "llm-integration"
+  ],
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
   ],
   "scripts": {
     "dev": "vite dev",
     "build": "vite build && pnpm run prepack",
-    "build:cli": "echo 'Building CLI...' && tsc src/cli/index.ts --outDir dist/cli --target es2022 --module esnext --moduleResolution bundler --allowImportingTsExtensions false --resolveJsonModule --esModuleInterop --allowSyntheticDefaultImports --strict --rootDir src/cli",
+    "build:cli": "echo 'Building CLI...' && tsc --project tsconfig.cli.json",
     "cli": "node dist/cli/index.js",
     "preview": "vite preview",
     "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",