@juspay/neurolink 1.2.3 → 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/neurolink.d.ts

@@ -7,7 +7,7 @@
 import type { AIProviderName } from './core/types.js';
 export interface TextGenerationOptions {
     prompt: string;
-    provider?: 'openai' | 'bedrock' | 'vertex' | 'auto';
+    provider?: 'openai' | 'bedrock' | 'vertex' | 'anthropic' | 'azure' | 'auto';
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;
@@ -15,7 +15,7 @@ export interface TextGenerationOptions {
 }
 export interface StreamTextOptions {
     prompt: string;
-    provider?: 'openai' | 'bedrock' | 'vertex' | 'auto';
+    provider?: 'openai' | 'bedrock' | 'vertex' | 'anthropic' | 'azure' | 'auto';
     temperature?: number;
     maxTokens?: number;
     systemPrompt?: string;

package/dist/neurolink.js

@@ -34,7 +34,7 @@ export class NeuroLink {
             }
             const responseTime = Date.now() - startTime;
             return {
-                content: result.text,
+                content: result.content || result.text || '',
                 provider: providerName,
                 usage: result.usage,
                 responseTime

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Anthropic AI Provider (Direct API)
+ *
+ * Direct integration with Anthropic's Claude models via their native API.
+ * Supports Claude 3.5 Sonnet, Claude 3.5 Haiku, and Claude 3 Opus.
+ */
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } from '../core/types.js';
+import { AIProviderName } from '../core/types.js';
+export declare class AnthropicProvider implements AIProvider {
+    readonly name: AIProviderName;
+    private apiKey;
+    private baseURL;
+    private defaultModel;
+    constructor();
+    private getApiKey;
+    private getModel;
+    private makeRequest;
+    generateText(optionsOrPrompt: TextGenerationOptions | string, schema?: any): Promise<any>;
+    streamText(optionsOrPrompt: StreamTextOptions | string, schema?: any): Promise<any>;
+    private createAsyncIterable;
+    generateTextStream(optionsOrPrompt: StreamTextOptions | string): AsyncGenerator<any, void, unknown>;
+    testConnection(): Promise<{
+        success: boolean;
+        error?: string;
+        responseTime?: number;
+    }>;
+    isConfigured(): boolean;
+    getRequiredConfig(): string[];
+    getOptionalConfig(): string[];
+    getModels(): string[];
+    supportsStreaming(): boolean;
+    supportsSchema(): boolean;
+    getCapabilities(): string[];
+}

package/dist/providers/anthropic.js

@@ -0,0 +1,307 @@
+/**
+ * Anthropic AI Provider (Direct API)
+ *
+ * Direct integration with Anthropic's Claude models via their native API.
+ * Supports Claude 3.5 Sonnet, Claude 3.5 Haiku, and Claude 3 Opus.
+ */
+import { AIProviderName } from '../core/types.js';
+export class AnthropicProvider {
+    name = AIProviderName.ANTHROPIC;
+    apiKey;
+    baseURL;
+    defaultModel;
+    constructor() {
+        this.apiKey = this.getApiKey();
+        this.baseURL = process.env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com';
+        this.defaultModel = process.env.ANTHROPIC_MODEL || 'claude-3-5-sonnet-20241022';
+        console.log(`[AnthropicProvider] Initialized with model: ${this.defaultModel}`);
+    }
+    getApiKey() {
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            throw new Error('ANTHROPIC_API_KEY environment variable is required');
+        }
+        return apiKey;
+    }
+    getModel() {
+        return this.defaultModel;
+    }
+    async makeRequest(endpoint, body, stream = false) {
+        const url = `${this.baseURL}/v1/${endpoint}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            'x-api-key': this.apiKey,
+            'anthropic-version': '2023-06-01',
+            'anthropic-dangerous-direct-browser-access': 'true' // Required for browser usage
+        };
+        console.log(`[AnthropicProvider.makeRequest] ${stream ? 'Streaming' : 'Non-streaming'} request to ${url}`);
+        console.log(`[AnthropicProvider.makeRequest] Model: ${body.model}, Max tokens: ${body.max_tokens}`);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error(`[AnthropicProvider.makeRequest] API error ${response.status}: ${errorText}`);
+            throw new Error(`Anthropic API error ${response.status}: ${errorText}`);
+        }
+        return response;
+    }
+    async generateText(optionsOrPrompt, schema) {
+        console.log('[AnthropicProvider.generateText] Starting text generation');
+        // Parse parameters with backward compatibility
+        const options = typeof optionsOrPrompt === 'string'
+            ? { prompt: optionsOrPrompt }
+            : optionsOrPrompt;
+        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = 'You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.' } = options;
+        console.log(`[AnthropicProvider.generateText] Prompt: "${prompt.substring(0, 100)}...", Temperature: ${temperature}, Max tokens: ${maxTokens}`);
+        const requestBody = {
+            model: this.getModel(),
+            max_tokens: maxTokens,
+            messages: [
+                {
+                    role: 'user',
+                    content: prompt
+                }
+            ],
+            temperature,
+            system: systemPrompt
+        };
+        try {
+            const response = await this.makeRequest('messages', requestBody);
+            const data = await response.json();
+            console.log(`[AnthropicProvider.generateText] Success. Generated ${data.usage.output_tokens} tokens`);
+            const content = data.content.map(block => block.text).join('');
+            return {
+                content,
+                provider: this.name,
+                model: data.model,
+                usage: {
+                    promptTokens: data.usage.input_tokens,
+                    completionTokens: data.usage.output_tokens,
+                    totalTokens: data.usage.input_tokens + data.usage.output_tokens
+                },
+                finishReason: data.stop_reason
+            };
+        }
+        catch (error) {
+            console.error('[AnthropicProvider.generateText] Error:', error);
+            throw error;
+        }
+    }
+    async streamText(optionsOrPrompt, schema) {
+        console.log('[AnthropicProvider.streamText] Starting text streaming');
+        // Parse parameters with backward compatibility
+        const options = typeof optionsOrPrompt === 'string'
+            ? { prompt: optionsOrPrompt }
+            : optionsOrPrompt;
+        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = 'You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.' } = options;
+        console.log(`[AnthropicProvider.streamText] Streaming prompt: "${prompt.substring(0, 100)}..."`);
+        const requestBody = {
+            model: this.getModel(),
+            max_tokens: maxTokens,
+            messages: [
+                {
+                    role: 'user',
+                    content: prompt
+                }
+            ],
+            temperature,
+            system: systemPrompt,
+            stream: true
+        };
+        try {
+            const response = await this.makeRequest('messages', requestBody, true);
+            if (!response.body) {
+                throw new Error('No response body received');
+            }
+            // Return a StreamTextResult-like object
+            return {
+                textStream: this.createAsyncIterable(response.body),
+                text: '',
+                usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+                finishReason: 'end_turn'
+            };
+        }
+        catch (error) {
+            console.error('[AnthropicProvider.streamText] Error:', error);
+            throw error;
+        }
+    }
+    async *createAsyncIterable(body) {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (line.trim() === '')
+                        continue;
+                    if (line.startsWith('data: ')) {
+                        const data = line.slice(6);
+                        if (data.trim() === '[DONE]')
+                            continue;
+                        try {
+                            const chunk = JSON.parse(data);
+                            // Extract text content from different chunk types
+                            if (chunk.type === 'content_block_delta' && chunk.delta?.text) {
+                                yield chunk.delta.text;
+                            }
+                        }
+                        catch (parseError) {
+                            console.warn('[AnthropicProvider.createAsyncIterable] Failed to parse chunk:', parseError);
+                            continue;
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async *generateTextStream(optionsOrPrompt) {
+        console.log('[AnthropicProvider.generateTextStream] Starting text streaming');
+        // Parse parameters with backward compatibility
+        const options = typeof optionsOrPrompt === 'string'
+            ? { prompt: optionsOrPrompt }
+            : optionsOrPrompt;
+        const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = 'You are Claude, an AI assistant created by Anthropic. You are helpful, harmless, and honest.' } = options;
+        console.log(`[AnthropicProvider.generateTextStream] Streaming prompt: "${prompt.substring(0, 100)}..."`);
+        const requestBody = {
+            model: this.getModel(),
+            max_tokens: maxTokens,
+            messages: [
+                {
+                    role: 'user',
+                    content: prompt
+                }
+            ],
+            temperature,
+            system: systemPrompt,
+            stream: true
+        };
+        try {
+            const response = await this.makeRequest('messages', requestBody, true);
+            if (!response.body) {
+                throw new Error('No response body received');
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (line.trim() === '')
+                            continue;
+                        if (line.startsWith('data: ')) {
+                            const data = line.slice(6);
+                            if (data.trim() === '[DONE]')
+                                continue;
+                            try {
+                                const chunk = JSON.parse(data);
+                                // Extract text content from different chunk types
+                                if (chunk.type === 'content_block_delta' && chunk.delta?.text) {
+                                    yield {
+                                        content: chunk.delta.text,
+                                        provider: this.name,
+                                        model: this.getModel()
+                                    };
+                                }
+                            }
+                            catch (parseError) {
+                                console.warn('[AnthropicProvider.generateTextStream] Failed to parse chunk:', parseError);
+                                continue;
+                            }
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            console.log('[AnthropicProvider.generateTextStream] Streaming completed');
+        }
+        catch (error) {
+            console.error('[AnthropicProvider.generateTextStream] Error:', error);
+            throw error;
+        }
+    }
+    async testConnection() {
+        console.log('[AnthropicProvider.testConnection] Testing connection to Anthropic API');
+        const startTime = Date.now();
+        try {
+            await this.generateText({
+                prompt: 'Hello',
+                maxTokens: 5
+            });
+            const responseTime = Date.now() - startTime;
+            console.log(`[AnthropicProvider.testConnection] Connection test successful (${responseTime}ms)`);
+            return {
+                success: true,
+                responseTime
+            };
+        }
+        catch (error) {
+            const responseTime = Date.now() - startTime;
+            console.error(`[AnthropicProvider.testConnection] Connection test failed (${responseTime}ms):`, error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+                responseTime
+            };
+        }
+    }
+    isConfigured() {
+        try {
+            this.getApiKey();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getRequiredConfig() {
+        return ['ANTHROPIC_API_KEY'];
+    }
+    getOptionalConfig() {
+        return ['ANTHROPIC_MODEL', 'ANTHROPIC_BASE_URL'];
+    }
+    getModels() {
+        return [
+            'claude-3-5-sonnet-20241022',
+            'claude-3-5-haiku-20241022',
+            'claude-3-opus-20240229',
+            'claude-3-sonnet-20240229',
+            'claude-3-haiku-20240307'
+        ];
+    }
+    supportsStreaming() {
+        return true;
+    }
+    supportsSchema() {
+        return false; // Anthropic doesn't have native JSON schema support like OpenAI
+    }
+    getCapabilities() {
+        return [
+            'text-generation',
+            'streaming',
+            'conversation',
+            'system-prompts',
+            'long-context' // Claude models support up to 200k tokens
+        ];
+    }
+}

package/dist/providers/azureOpenAI.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Azure OpenAI Provider
+ *
+ * Enterprise-grade OpenAI integration through Microsoft Azure.
+ * Supports all OpenAI models with enhanced security and compliance.
+ */
+import type { AIProvider, TextGenerationOptions, StreamTextOptions } from '../core/types.js';
+import { AIProviderName } from '../core/types.js';
+export declare class AzureOpenAIProvider implements AIProvider {
+    readonly name: AIProviderName;
+    private apiKey;
+    private endpoint;
+    private deploymentId;
+    private apiVersion;
+    constructor();
+    private getApiKey;
+    private getEndpoint;
+    private getDeploymentId;
+    private getApiUrl;
+    private makeRequest;
+    generateText(optionsOrPrompt: TextGenerationOptions | string, schema?: any): Promise<any>;
+    streamText(optionsOrPrompt: StreamTextOptions | string, schema?: any): Promise<any>;
+    private createAsyncIterable;
+    generateTextStream(optionsOrPrompt: StreamTextOptions | string): AsyncGenerator<any, void, unknown>;
+    testConnection(): Promise<{
+        success: boolean;
+        error?: string;
+        responseTime?: number;
+    }>;
+    isConfigured(): boolean;
+    getRequiredConfig(): string[];
+    getOptionalConfig(): string[];
+    getModels(): string[];
+    supportsStreaming(): boolean;
+    supportsSchema(): boolean;
+    getCapabilities(): string[];
+}