@juspay/neurolink 1.5.3 → 1.9.0

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

@@ -3,67 +3,81 @@
  * 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';
-import { logger } from '../../../utils/logger.js';
-import { analyzeAIUsageTool, benchmarkProviderPerformanceTool, optimizePromptParametersTool } from './ai-analysis-tools.js';
-import { generateTestCasesTool, refactorCodeTool, generateDocumentationTool, debugAIOutputTool } from './ai-workflow-tools.js';
+import { z } from "zod";
+import { createMCPServer } from "../../factory.js";
+import { AIProviderFactory } from "../../../core/factory.js";
+import { getBestProvider, getAvailableProviders, } from "../../../utils/providerUtils.js";
+import { logger } from "../../../utils/logger.js";
+import { analyzeAIUsageTool, benchmarkProviderPerformanceTool, optimizePromptParametersTool, } from "./ai-analysis-tools.js";
+import { generateTestCasesTool, refactorCodeTool, generateDocumentationTool, debugAIOutputTool, } from "./ai-workflow-tools.js";
 /**
  * AI Core Server - Central hub for AI provider tools
  * Provides text generation, provider selection, AI analysis, and development workflow tools
  */
 export const aiCoreServer = createMCPServer({
-    id: 'neurolink-ai-core',
-    title: 'NeuroLink AI Core',
-    description: 'Core AI provider tools with automatic fallback, analysis capabilities, and development workflow enhancement',
-    category: 'ai-providers',
-    version: '1.2.0',
+    id: "neurolink-ai-core",
+    title: "NeuroLink AI Core",
+    description: "Core AI provider tools with automatic fallback, analysis capabilities, and development workflow enhancement",
+    category: "ai-providers",
+    version: "1.2.0",
     capabilities: [
-        'text-generation',
-        'provider-selection',
-        'automatic-fallback',
-        'usage-tracking',
-        'multi-provider-support',
-        'ai-analysis',
-        'test-generation',
-        'code-refactoring',
-        'documentation-generation',
-        'ai-debugging'
-    ]
+        "text-generation",
+        "provider-selection",
+        "automatic-fallback",
+        "usage-tracking",
+        "multi-provider-support",
+        "ai-analysis",
+        "test-generation",
+        "code-refactoring",
+        "documentation-generation",
+        "ai-debugging",
+    ],
 });
 /**
  * Text Generation Input Schema
  */
 const TextGenerationSchema = z.object({
-    prompt: z.string().min(1, 'Prompt is required'),
-    provider: z.enum(['openai', 'bedrock', 'vertex', 'anthropic', 'google-ai']).optional(),
+    prompt: z.string().min(1, "Prompt is required"),
+    provider: z
+        .enum([
+        "openai",
+        "bedrock",
+        "vertex",
+        "anthropic",
+        "google-ai",
+        "azure",
+        "huggingface",
+        "ollama",
+        "mistral",
+    ])
+        .optional(),
     model: z.string().optional(),
     temperature: z.number().min(0).max(2).optional(),
     maxTokens: z.number().positive().optional(),
-    systemPrompt: z.string().optional()
+    systemPrompt: z.string().optional(),
 });
 /**
  * Provider Selection Input Schema
  */
 const ProviderSelectionSchema = z.object({
     preferred: z.string().optional(),
-    requirements: z.object({
+    requirements: z
+        .object({
         multimodal: z.boolean().optional(),
         streaming: z.boolean().optional(),
         maxTokens: z.number().optional(),
-        costEfficient: z.boolean().optional()
-    }).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',
+    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) => {
@@ -72,17 +86,17 @@ aiCoreServer.registerTool({
             logger.debug(`[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);
+            const provider = await 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
+                systemPrompt: params.systemPrompt,
             });
             if (!result) {
-                throw new Error('AI provider returned null result');
+                throw new Error("AI provider returned null result");
             }
             const executionTime = Date.now() - startTime;
             logger.debug(`[AI-Core] Text generation successful in ${executionTime}ms using ${selectedProvider}`);
@@ -90,23 +104,23 @@ aiCoreServer.registerTool({
                 success: true,
                 data: {
                     text: result.text,
-                    model: params.model || 'default',
+                    model: params.model || "default",
                     provider: selectedProvider,
-                    generatedAt: new Date().toISOString()
+                    generatedAt: new Date().toISOString(),
                 },
                 usage: {
                     tokens: result.usage?.totalTokens,
                     provider: selectedProvider,
-                    model: params.model || 'default',
-                    executionTime
+                    model: params.model || "default",
+                    executionTime,
                 },
                 metadata: {
-                    toolName: 'generate-text',
-                    serverId: 'neurolink-ai-core',
+                    toolName: "generate-text",
+                    serverId: "neurolink-ai-core",
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    executionTime
-                }
+                    executionTime,
+                },
             };
         }
         catch (error) {
@@ -117,24 +131,24 @@ aiCoreServer.registerTool({
                 success: false,
                 error: errorMessage,
                 metadata: {
-                    toolName: 'generate-text',
-                    serverId: 'neurolink-ai-core',
+                    toolName: "generate-text",
+                    serverId: "neurolink-ai-core",
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    executionTime
-                }
+                    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',
+    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) => {
@@ -144,12 +158,26 @@ aiCoreServer.registerTool({
             // Use existing provider selection logic
             const availableProviders = getAvailableProviders();
             const selectedProvider = getBestProvider(params.preferred);
-            // Get provider capabilities (mock for now, can be enhanced)
+            // Get provider capabilities
             const getProviderCapabilities = (provider) => ({
-                multimodal: provider === 'openai' || provider === 'vertex',
-                streaming: provider === 'openai' || provider === 'anthropic',
-                maxTokens: provider === 'anthropic' ? 100000 : 4000,
-                costEfficient: provider === 'openai' || provider === 'vertex'
+                multimodal: provider === "openai" ||
+                    provider === "vertex" ||
+                    provider === "google-ai",
+                streaming: provider === "openai" ||
+                    provider === "anthropic" ||
+                    provider === "azure" ||
+                    provider === "mistral",
+                maxTokens: provider === "anthropic"
+                    ? 100000
+                    : provider === "huggingface"
+                        ? 2048
+                        : 4000,
+                costEfficient: provider === "google-ai" ||
+                    provider === "vertex" ||
+                    provider === "huggingface" ||
+                    provider === "ollama",
+                localExecution: provider === "ollama",
+                openSource: provider === "huggingface" || provider === "ollama",
             });
             const capabilities = getProviderCapabilities(selectedProvider);
             const executionTime = Date.now() - startTime;
@@ -162,19 +190,19 @@ aiCoreServer.registerTool({
                     capabilities,
                     reason: params.preferred
                         ? `Preferred provider ${params.preferred} selected`
-                        : 'Best available provider selected',
-                    selectedAt: new Date().toISOString()
+                        : "Best available provider selected",
+                    selectedAt: new Date().toISOString(),
                 },
                 usage: {
-                    executionTime
+                    executionTime,
                 },
                 metadata: {
-                    toolName: 'select-provider',
-                    serverId: 'neurolink-ai-core',
+                    toolName: "select-provider",
+                    serverId: "neurolink-ai-core",
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    executionTime
-                }
+                    executionTime,
+                },
             };
         }
         catch (error) {
@@ -185,58 +213,73 @@ aiCoreServer.registerTool({
                 success: false,
                 error: errorMessage,
                 metadata: {
-                    toolName: 'select-provider',
-                    serverId: 'neurolink-ai-core',
+                    toolName: "select-provider",
+                    serverId: "neurolink-ai-core",
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    executionTime
-                }
+                    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',
+    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)
+        includeCapabilities: z.boolean().default(true),
     }),
     isImplemented: true,
     execute: async (params, context) => {
         const startTime = Date.now();
         try {
-            logger.debug(`[AI-Core] Checking provider status for: ${params.provider || 'all providers'}`);
+            logger.debug(`[AI-Core] Checking provider status for: ${params.provider || "all providers"}`);
             const availableProviders = getAvailableProviders();
             const providerStatuses = [];
-            const providersToCheck = params.provider ? [params.provider] : availableProviders;
+            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()
+                        status: isAvailable ? "available" : "unavailable",
+                        capabilities: params.includeCapabilities
+                            ? {
+                                textGeneration: true,
+                                multimodal: provider === "openai" ||
+                                    provider === "vertex" ||
+                                    provider === "google-ai",
+                                streaming: provider === "openai" ||
+                                    provider === "anthropic" ||
+                                    provider === "azure" ||
+                                    provider === "mistral",
+                                maxTokens: provider === "anthropic"
+                                    ? 100000
+                                    : provider === "huggingface"
+                                        ? 2048
+                                        : 4000,
+                                localExecution: provider === "ollama",
+                                openSource: provider === "huggingface" || provider === "ollama",
+                            }
+                            : undefined,
+                        lastChecked: new Date().toISOString(),
                     });
                 }
                 catch (error) {
                     providerStatuses.push({
                         provider,
-                        status: 'error',
+                        status: "error",
                         error: error instanceof Error ? error.message : String(error),
-                        lastChecked: new Date().toISOString()
+                        lastChecked: new Date().toISOString(),
                     });
                 }
             }
@@ -248,22 +291,23 @@ aiCoreServer.registerTool({
                     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
+                        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()
+                    checkedAt: new Date().toISOString(),
                 },
                 usage: {
-                    executionTime
+                    executionTime,
                 },
                 metadata: {
-                    toolName: 'check-provider-status',
-                    serverId: 'neurolink-ai-core',
+                    toolName: "check-provider-status",
+                    serverId: "neurolink-ai-core",
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    executionTime
-                }
+                    executionTime,
+                },
             };
         }
         catch (error) {
@@ -274,15 +318,15 @@ aiCoreServer.registerTool({
                 success: false,
                 error: errorMessage,
                 metadata: {
-                    toolName: 'check-provider-status',
-                    serverId: 'neurolink-ai-core',
+                    toolName: "check-provider-status",
+                    serverId: "neurolink-ai-core",
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    executionTime
-                }
+                    executionTime,
+                },
             };
         }
-    }
+    },
 });
 /**
  * Register AI Analysis Tools
@@ -300,4 +344,4 @@ aiCoreServer.registerTool(refactorCodeTool);
 aiCoreServer.registerTool(generateDocumentationTool);
 aiCoreServer.registerTool(debugAIOutputTool);
 // Log successful server creation
-logger.debug('[AI-Core] NeuroLink AI Core Server v1.2.0 created with 10 tools:', Object.keys(aiCoreServer.tools));
+logger.debug("[AI-Core] NeuroLink AI Core Server v1.2.0 created with 10 tools:", Object.keys(aiCoreServer.tools));

package/dist/mcp/servers/ai-providers/ai-workflow-tools.d.ts

@@ -2,8 +2,8 @@
  * AI Development Workflow Tools
  * Phase 1.2 Implementation - 4 specialized tools for AI development lifecycle
  */
-import { z } from 'zod';
-import type { NeuroLinkMCPTool } from '../../factory.js';
+import { z } from "zod";
+import type { NeuroLinkMCPTool } from "../../factory.js";
 /**
  * Generate test cases for code functions
  */
@@ -22,7 +22,7 @@ export declare const generateDocumentationTool: NeuroLinkMCPTool;
 export declare const debugAIOutputTool: NeuroLinkMCPTool;
 export declare const aiWorkflowTools: NeuroLinkMCPTool[];
 export declare const workflowToolSchemas: {
-    'generate-test-cases': z.ZodObject<{
+    "generate-test-cases": z.ZodObject<{
         codeFunction: z.ZodString;
         testTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<["unit", "integration", "edge-cases", "performance", "security"]>, "many">>;
         framework: z.ZodDefault<z.ZodEnum<["jest", "mocha", "vitest", "pytest", "unittest", "rspec"]>>;
@@ -41,7 +41,7 @@ export declare const workflowToolSchemas: {
         coverageTarget?: number | undefined;
         includeAsyncTests?: boolean | undefined;
     }>;
-    'refactor-code': z.ZodObject<{
+    "refactor-code": z.ZodObject<{
         code: z.ZodString;
         language: z.ZodDefault<z.ZodString>;
         objectives: z.ZodDefault<z.ZodArray<z.ZodEnum<["readability", "performance", "maintainability", "testability", "modularity", "dry-principle", "solid-principles"]>, "many">>;
@@ -60,7 +60,7 @@ export declare const workflowToolSchemas: {
         preserveFunctionality?: boolean | undefined;
         styleGuide?: string | undefined;
     }>;
-    'generate-documentation': z.ZodObject<{
+    "generate-documentation": z.ZodObject<{
         code: z.ZodString;
         language: z.ZodDefault<z.ZodString>;
         documentationType: z.ZodDefault<z.ZodEnum<["jsdoc", "markdown", "sphinx", "doxygen", "readme"]>>;
@@ -79,7 +79,7 @@ export declare const workflowToolSchemas: {
         includeExamples?: boolean | undefined;
         detailLevel?: "minimal" | "standard" | "comprehensive" | undefined;
     }>;
-    'debug-ai-output': z.ZodObject<{
+    "debug-ai-output": z.ZodObject<{
         aiOutput: z.ZodString;
         expectedBehavior: z.ZodString;
         context: z.ZodOptional<z.ZodString>;