@juspay/neurolink 1.5.3 → 1.9.0

package/dist/lib/mcp/registry.js

@@ -3,7 +3,8 @@
  * Central registry for managing MCP servers and tools with execution capabilities
  * Supports tool discovery, registration, and orchestrated execution
  */
-import { ContextManager, ContextValidator } from './context-manager.js';
+import { ContextManager, ContextValidator } from "./context-manager.js";
+import { registryLogger, mcpLogger } from "./logging.js";
 /**
  * Central MCP Tool Registry
  * Manages all MCP servers and their tools with advanced execution capabilities
@@ -26,9 +27,10 @@ export class MCPToolRegistry {
      * @throws Error if server ID already exists
      */
     async registerServer(server) {
-        // Check for duplicate server ID
+        // Check for duplicate server ID - if already registered, skip silently
         if (this.servers.has(server.id)) {
-            throw new Error(`Server with ID '${server.id}' is already registered`);
+            mcpLogger.debug(`Server with ID '${server.id}' is already registered, skipping registration`);
+            return;
         }
         // Register the server
         this.servers.set(server.id, server);
@@ -36,7 +38,7 @@ export class MCPToolRegistry {
         for (const [toolName, tool] of Object.entries(server.tools)) {
             await this.registerToolFromServer(server, toolName, tool);
         }
-        console.log(`[MCPRegistry] Registered server '${server.id}' with ${Object.keys(server.tools).length} tools`);
+        registryLogger.debug(`Registered server '${server.id}' with ${Object.keys(server.tools).length} tools`);
     }
     /**
      * Register a single tool from a server
@@ -55,7 +57,7 @@ export class MCPToolRegistry {
             serverCategory: server.category,
             qualifiedName,
             simpleName,
-            registeredAt: Date.now()
+            registeredAt: Date.now(),
         };
         // Register with both qualified and simple names
         this.tools.set(qualifiedName, registration);
@@ -64,7 +66,7 @@ export class MCPToolRegistry {
             this.tools.set(simpleName, registration);
         }
         else {
-            console.warn(`[MCPRegistry] Tool name conflict: '${simpleName}' already exists, use qualified name '${qualifiedName}'`);
+            registryLogger.warn(`Tool name conflict: '${simpleName}' already exists, use qualified name '${qualifiedName}'`);
         }
     }
     /**
@@ -78,7 +80,7 @@ export class MCPToolRegistry {
      */
     async executeTool(toolName, params, context, options = {}) {
         const startTime = Date.now();
-        const { validateInput = true, validatePermissions = true, trackMetrics = true, timeoutMs = 30000 } = options;
+        const { validateInput = true, validatePermissions = true, trackMetrics = true, timeoutMs = 30000, } = options;
         try {
             // Find the tool
             const registration = this.tools.get(toolName);
@@ -90,11 +92,12 @@ export class MCPToolRegistry {
             if (validatePermissions) {
                 const contextValidation = ContextValidator.validateContext(context);
                 if (!contextValidation.isValid) {
-                    throw new Error(`Context validation failed: ${contextValidation.errors.join(', ')}`);
+                    throw new Error(`Context validation failed: ${contextValidation.errors.join(", ")}`);
                 }
                 // Check tool permissions
-                if (tool.permissions && !ContextValidator.hasPermissions(context, tool.permissions)) {
-                    throw new Error(`Insufficient permissions for tool '${toolName}'. Required: ${tool.permissions.join(', ')}`);
+                if (tool.permissions &&
+                    !ContextValidator.hasPermissions(context, tool.permissions)) {
+                    throw new Error(`Insufficient permissions for tool '${toolName}'. Required: ${tool.permissions.join(", ")}`);
                 }
             }
             // Validate input parameters if schema provided
@@ -123,8 +126,8 @@ export class MCPToolRegistry {
                     serverTitle,
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    executionTime
-                }
+                    executionTime,
+                },
             };
             // Track metrics
             if (trackMetrics) {
@@ -137,10 +140,10 @@ export class MCPToolRegistry {
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
-                    console.warn(`[MCPRegistry] Output validation warning for tool '${toolName}': ${errorMessage}`);
+                    registryLogger.warn(`Output validation warning for tool '${toolName}': ${errorMessage}`);
                 }
             }
-            console.log(`[MCPRegistry] Executed tool '${toolName}' in ${executionTime}ms - ${result.success ? 'SUCCESS' : 'FAILED'}`);
+            registryLogger.debug(`Executed tool '${toolName}' in ${executionTime}ms - ${result.success ? "SUCCESS" : "FAILED"}`);
             return enhancedResult;
         }
         catch (error) {
@@ -157,10 +160,10 @@ export class MCPToolRegistry {
                     toolName,
                     sessionId: context.sessionId,
                     timestamp: Date.now(),
-                    executionTime
-                }
+                    executionTime,
+                },
             };
-            console.error(`[MCPRegistry] Tool execution failed '${toolName}': ${errorMessage}`);
+            registryLogger.error(`Tool execution failed '${toolName}': ${errorMessage}`);
             return errorResult;
         }
     }
@@ -175,7 +178,8 @@ export class MCPToolRegistry {
         // Get unique tools (prefer qualified names over simple names)
         const uniqueTools = new Map();
         for (const [name, registration] of this.tools) {
-            if (name.includes('.')) { // Qualified name
+            if (name.includes(".")) {
+                // Qualified name
                 uniqueTools.set(registration.qualifiedName, registration);
             }
             else if (!uniqueTools.has(registration.qualifiedName)) {
@@ -183,9 +187,10 @@ export class MCPToolRegistry {
             }
         }
         for (const registration of uniqueTools.values()) {
-            const { tool, serverId, serverTitle, serverCategory, qualifiedName, simpleName } = registration;
+            const { tool, serverId, serverTitle, serverCategory, qualifiedName, simpleName, } = registration;
             // Apply filters
-            if (criteria.name && !simpleName.toLowerCase().includes(criteria.name.toLowerCase())) {
+            if (criteria.name &&
+                !simpleName.toLowerCase().includes(criteria.name.toLowerCase())) {
                 continue;
             }
             if (criteria.category && tool.category !== criteria.category) {
@@ -194,15 +199,17 @@ export class MCPToolRegistry {
             if (criteria.serverId && serverId !== criteria.serverId) {
                 continue;
             }
-            if (criteria.serverCategory && serverCategory !== criteria.serverCategory) {
+            if (criteria.serverCategory &&
+                serverCategory !== criteria.serverCategory) {
                 continue;
             }
-            if (criteria.implemented !== undefined && tool.isImplemented !== criteria.implemented) {
+            if (criteria.implemented !== undefined &&
+                tool.isImplemented !== criteria.implemented) {
                 continue;
             }
             if (criteria.permissions && criteria.permissions.length > 0) {
                 const toolPermissions = tool.permissions || [];
-                const hasAllPermissions = criteria.permissions.every(p => toolPermissions.includes(p));
+                const hasAllPermissions = criteria.permissions.every((p) => toolPermissions.includes(p));
                 if (!hasAllPermissions) {
                     continue;
                 }
@@ -216,7 +223,7 @@ export class MCPToolRegistry {
                 category: tool.category,
                 serverCategory,
                 permissions: tool.permissions,
-                isImplemented: tool.isImplemented
+                isImplemented: tool.isImplemented,
             });
         }
         return tools.sort((a, b) => a.qualifiedName.localeCompare(b.qualifiedName));
@@ -239,7 +246,7 @@ export class MCPToolRegistry {
         return {
             tool: registration.tool,
             server,
-            registration
+            registration,
         };
     }
     /**
@@ -252,22 +259,24 @@ export class MCPToolRegistry {
         const serversByCategory = {};
         // Count tools by category
         for (const registration of this.tools.values()) {
-            const category = registration.tool.category || 'uncategorized';
+            const category = registration.tool.category || "uncategorized";
             toolsByCategory[category] = (toolsByCategory[category] || 0) + 1;
         }
         // Count servers by category
         for (const server of this.servers.values()) {
-            const category = server.category || 'uncategorized';
+            const category = server.category || "uncategorized";
             serversByCategory[category] = (serversByCategory[category] || 0) + 1;
         }
         return {
             totalServers: this.servers.size,
-            totalTools: new Set(Array.from(this.tools.values()).map(r => r.qualifiedName)).size,
+            totalTools: new Set(Array.from(this.tools.values()).map((r) => r.qualifiedName)).size,
             toolsByCategory,
             serversByCategory,
             executionCount: this.executionCount,
-            averageExecutionTime: this.executionCount > 0 ? this.totalExecutionTime / this.executionCount : 0,
-            errorRate: this.executionCount > 0 ? this.errorCount / this.executionCount : 0
+            averageExecutionTime: this.executionCount > 0
+                ? this.totalExecutionTime / this.executionCount
+                : 0,
+            errorRate: this.executionCount > 0 ? this.errorCount / this.executionCount : 0,
         };
     }
     /**
@@ -293,7 +302,7 @@ export class MCPToolRegistry {
         }
         // Remove the server
         this.servers.delete(serverId);
-        console.log(`[MCPRegistry] Unregistered server '${serverId}' and ${toolsToRemove.length} tools`);
+        registryLogger.debug(`Unregistered server '${serverId}' and ${toolsToRemove.length} tools`);
         return true;
     }
     /**
@@ -305,7 +314,7 @@ export class MCPToolRegistry {
         this.executionCount = 0;
         this.totalExecutionTime = 0;
         this.errorCount = 0;
-        console.log('[MCPRegistry] Cleared all servers and tools');
+        registryLogger.debug("Cleared all servers and tools");
     }
     /**
      * Create timeout promise wrapper
@@ -320,7 +329,7 @@ export class MCPToolRegistry {
             promise,
             new Promise((_, reject) => {
                 setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs);
-            })
+            }),
         ]);
     }
     /**

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

@@ -3,7 +3,7 @@
  * AI-focused MCP tools for usage analysis, performance benchmarking, and parameter optimization
  * Tools: analyze-ai-usage, benchmark-provider-performance, optimize-prompt-parameters
  */
-import type { NeuroLinkMCPTool } from '../../factory.js';
+import type { NeuroLinkMCPTool } from "../../factory.js";
 /**
  * AI Usage Analysis Tool
  * Analyzes AI usage patterns, token consumption, and cost optimization opportunities

package/dist/lib/mcp/servers/ai-providers/ai-analysis-tools.js

@@ -3,46 +3,88 @@
  * AI-focused MCP tools for usage analysis, performance benchmarking, and parameter optimization
  * Tools: analyze-ai-usage, benchmark-provider-performance, optimize-prompt-parameters
  */
-import { z } from 'zod';
-import { AIProviderFactory } from '../../../core/factory.js';
-import { getBestProvider, getAvailableProviders } from '../../../utils/providerUtils.js';
+import { z } from "zod";
+import { AIProviderFactory } from "../../../core/factory.js";
+import { getBestProvider, getAvailableProviders, } from "../../../utils/providerUtils.js";
 /**
  * Input Schemas for AI Analysis Tools
  */
 const AnalyzeUsageSchema = z.object({
     sessionId: z.string().optional(),
-    timeRange: z.enum(['1h', '24h', '7d', '30d']).default('24h'),
-    provider: z.enum(['openai', 'bedrock', 'vertex', 'anthropic', 'google-ai']).optional(),
+    timeRange: z.enum(["1h", "24h", "7d", "30d"]).default("24h"),
+    provider: z
+        .enum([
+        "openai",
+        "bedrock",
+        "vertex",
+        "anthropic",
+        "google-ai",
+        "azure",
+        "huggingface",
+        "ollama",
+        "mistral",
+    ])
+        .optional(),
     includeTokenBreakdown: z.boolean().default(true),
-    includeCostEstimation: z.boolean().default(true)
+    includeCostEstimation: z.boolean().default(true),
 });
 const BenchmarkSchema = z.object({
-    providers: z.array(z.enum(['openai', 'bedrock', 'vertex', 'anthropic', 'google-ai'])).optional(),
+    providers: z
+        .array(z.enum([
+        "openai",
+        "bedrock",
+        "vertex",
+        "anthropic",
+        "google-ai",
+        "azure",
+        "huggingface",
+        "ollama",
+        "mistral",
+    ]))
+        .optional(),
     testPrompts: z.array(z.string()).optional(),
     iterations: z.number().min(1).max(5).default(2),
-    metrics: z.array(z.enum(['latency', 'quality', 'cost', 'tokens'])).default(['latency', 'quality']),
-    maxTokens: z.number().positive().default(100)
+    metrics: z
+        .array(z.enum(["latency", "quality", "cost", "tokens"]))
+        .default(["latency", "quality"]),
+    maxTokens: z.number().positive().default(100),
 });
 const OptimizeParametersSchema = z.object({
-    prompt: z.string().min(1, 'Prompt is required for optimization'),
-    provider: z.enum(['openai', 'bedrock', 'vertex', 'anthropic', 'google-ai']).optional(),
+    prompt: z.string().min(1, "Prompt is required for optimization"),
+    provider: z
+        .enum([
+        "openai",
+        "bedrock",
+        "vertex",
+        "anthropic",
+        "google-ai",
+        "azure",
+        "huggingface",
+        "ollama",
+        "mistral",
+    ])
+        .optional(),
     targetLength: z.number().positive().optional(),
-    style: z.enum(['creative', 'balanced', 'precise', 'factual']).default('balanced'),
-    optimizeFor: z.enum(['speed', 'quality', 'cost', 'tokens']).default('quality'),
-    iterations: z.number().min(1).max(3).default(2)
+    style: z
+        .enum(["creative", "balanced", "precise", "factual"])
+        .default("balanced"),
+    optimizeFor: z
+        .enum(["speed", "quality", "cost", "tokens"])
+        .default("quality"),
+    iterations: z.number().min(1).max(3).default(2),
 });
 /**
  * AI Usage Analysis Tool
  * Analyzes AI usage patterns, token consumption, and cost optimization opportunities
  */
 export const analyzeAIUsageTool = {
-    name: 'analyze-ai-usage',
-    description: 'Analyze AI usage patterns, token consumption, and cost optimization opportunities',
-    category: 'ai-analysis',
+    name: "analyze-ai-usage",
+    description: "Analyze AI usage patterns, token consumption, and cost optimization opportunities",
+    category: "ai-analysis",
     inputSchema: AnalyzeUsageSchema,
     isImplemented: true,
-    permissions: ['read', 'analytics'],
-    version: '1.2.0', // Updated version with real AI
+    permissions: ["read", "analytics"],
+    version: "1.2.0", // Updated version with real AI
     execute: async (params, context) => {
         const startTime = Date.now();
         try {
@@ -55,68 +97,105 @@ export const analyzeAIUsageTool = {
             const analysisPrompt = `
         Analyze hypothetical AI usage data for a project based on the following parameters.
         Time Range: ${params.timeRange}
-        Provider Focus: ${params.provider || 'all'}
+        Provider Focus: ${params.provider || "all"}
 
         Generate a realistic analysis including:
         1. A summary of usage statistics (totalRequests, totalTokens).
-        2. A breakdown of usage by provider (OpenAI, Bedrock, Vertex).
+        2. A breakdown of usage by provider (OpenAI, Bedrock, Vertex, Google AI, Anthropic, Azure, Hugging Face, Ollama, Mistral).
         3. Key insights and actionable recommendations for cost and performance optimization.
 
         Return the result as a valid JSON object with keys: "analysis", "insights".
         - "analysis" should contain: timeRange, totalRequests, totalTokens, and a "providers" object.
         - "insights" should contain: mostUsedProvider, avgCostPerToken, peakUsageHours, costOptimizationPotential, and an array of "recommendations".
       `;
-            const result = await provider.generateText({ prompt: analysisPrompt, maxTokens: 800, temperature: 0.5 });
+            const result = await provider.generateText({
+                prompt: analysisPrompt,
+                maxTokens: 800,
+                temperature: 0.5,
+            });
             if (!result || !result.text) {
-                throw new Error('AI provider returned no result for usage analysis.');
+                throw new Error("AI provider returned no result for usage analysis.");
             }
             const parsedData = JSON.parse(result.text);
             const executionTime = Date.now() - startTime;
             return {
                 success: true,
-                data: { ...parsedData, generatedAt: new Date().toISOString(), sessionId: context.sessionId },
-                usage: { ...result.usage, executionTime, provider: providerName, model: 'analysis-engine' },
-                metadata: { toolName: 'analyze-ai-usage', serverId: 'neurolink-ai-core', sessionId: context.sessionId, timestamp: Date.now(), executionTime }
+                data: {
+                    ...parsedData,
+                    generatedAt: new Date().toISOString(),
+                    sessionId: context.sessionId,
+                },
+                usage: {
+                    ...result.usage,
+                    executionTime,
+                    provider: providerName,
+                    model: "analysis-engine",
+                },
+                metadata: {
+                    toolName: "analyze-ai-usage",
+                    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);
-            return { success: false, error: errorMessage, metadata: { toolName: 'analyze-ai-usage', serverId: 'neurolink-ai-core', sessionId: context.sessionId, timestamp: Date.now(), executionTime } };
+            return {
+                success: false,
+                error: errorMessage,
+                metadata: {
+                    toolName: "analyze-ai-usage",
+                    serverId: "neurolink-ai-core",
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime,
+                },
+            };
         }
-    }
+    },
 };
 /**
  * Provider Performance Benchmarking Tool
  * Benchmarks AI provider performance across latency, quality, and cost metrics
  */
 export const benchmarkProviderPerformanceTool = {
-    name: 'benchmark-provider-performance',
-    description: 'Benchmark AI provider performance across latency, quality, and cost metrics',
-    category: 'ai-analysis',
+    name: "benchmark-provider-performance",
+    description: "Benchmark AI provider performance across latency, quality, and cost metrics",
+    category: "ai-analysis",
     inputSchema: BenchmarkSchema,
     isImplemented: true,
-    permissions: ['read', 'benchmark'],
-    version: '1.1.0', // Updated version with real AI
+    permissions: ["read", "benchmark"],
+    version: "1.1.0", // Updated version with real AI
     execute: async (params, context) => {
         const startTime = Date.now();
         try {
             const providersToTest = params.providers || getAvailableProviders();
-            const testPrompts = params.testPrompts || ['Explain quantum computing in simple terms'];
+            const testPrompts = params.testPrompts || [
+                "Explain quantum computing in simple terms",
+            ];
             const benchmarkResults = [];
             for (const providerName of providersToTest) {
                 const provider = await AIProviderFactory.createProvider(providerName);
                 if (!provider) {
-                    benchmarkResults.push({ provider: providerName, error: 'Failed to create provider.' });
+                    benchmarkResults.push({
+                        provider: providerName,
+                        error: "Failed to create provider.",
+                    });
                     continue;
                 }
                 let totalLatency = 0, totalTokens = 0, successfulTests = 0;
                 for (const prompt of testPrompts) {
                     for (let i = 0; i < params.iterations; i++) {
                         const testStartTime = Date.now();
-                        const result = await provider.generateText({ prompt, maxTokens: params.maxTokens });
+                        const result = await provider.generateText({
+                            prompt,
+                            maxTokens: params.maxTokens,
+                        });
                         if (result && result.usage) {
-                            totalLatency += (Date.now() - testStartTime);
+                            totalLatency += Date.now() - testStartTime;
                             totalTokens += result.usage.totalTokens || 0;
                             successfulTests++;
                         }
@@ -125,91 +204,151 @@ export const benchmarkProviderPerformanceTool = {
                 benchmarkResults.push({
                     provider: providerName,
                     metrics: {
-                        avgLatency: successfulTests > 0 ? Math.round(totalLatency / successfulTests) : 0,
+                        avgLatency: successfulTests > 0
+                            ? Math.round(totalLatency / successfulTests)
+                            : 0,
                         totalTokens: totalTokens,
-                        successRate: successfulTests / (testPrompts.length * params.iterations) * 100
-                    }
+                        successRate: (successfulTests / (testPrompts.length * params.iterations)) *
+                            100,
+                    },
                 });
             }
             const executionTime = Date.now() - startTime;
             return {
                 success: true,
-                data: { results: benchmarkResults, benchmarkedAt: new Date().toISOString() },
-                usage: { executionTime, provider: 'benchmark-engine', model: 'multi-provider' },
-                metadata: { toolName: 'benchmark-provider-performance', serverId: 'neurolink-ai-core', sessionId: context.sessionId, timestamp: Date.now(), executionTime }
+                data: {
+                    results: benchmarkResults,
+                    benchmarkedAt: new Date().toISOString(),
+                },
+                usage: {
+                    executionTime,
+                    provider: "benchmark-engine",
+                    model: "multi-provider",
+                },
+                metadata: {
+                    toolName: "benchmark-provider-performance",
+                    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);
-            return { success: false, error: errorMessage, metadata: { toolName: 'benchmark-provider-performance', serverId: 'neurolink-ai-core', sessionId: context.sessionId, timestamp: Date.now(), executionTime } };
+            return {
+                success: false,
+                error: errorMessage,
+                metadata: {
+                    toolName: "benchmark-provider-performance",
+                    serverId: "neurolink-ai-core",
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime,
+                },
+            };
         }
-    }
+    },
 };
 /**
  * Prompt Parameter Optimization Tool
  * Optimizes prompt parameters (temperature, max tokens) for better AI output quality and efficiency
  */
 export const optimizePromptParametersTool = {
-    name: 'optimize-prompt-parameters',
-    description: 'Optimize prompt parameters (temperature, max tokens) for better AI output quality and efficiency',
-    category: 'ai-optimization',
+    name: "optimize-prompt-parameters",
+    description: "Optimize prompt parameters (temperature, max tokens) for better AI output quality and efficiency",
+    category: "ai-optimization",
     inputSchema: OptimizeParametersSchema,
     isImplemented: true,
-    permissions: ['read', 'optimize'],
-    version: '1.1.0', // Updated version with real AI
+    permissions: ["read", "optimize"],
+    version: "1.1.0", // Updated version with real AI
     execute: async (params, context) => {
         const startTime = Date.now();
         try {
-            const providerName = params.provider || await getBestProvider();
+            const providerName = params.provider || (await getBestProvider());
             const provider = await AIProviderFactory.createProvider(providerName);
-            if (!provider)
+            if (!provider) {
                 throw new Error(`Failed to create provider: ${providerName}`);
+            }
             const optimizationResults = [];
             const temperatures = [0.2, 0.7, 1.0]; // Test a range of temperatures
             for (const temp of temperatures) {
-                const result = await provider.generateText({ prompt: params.prompt, temperature: temp, maxTokens: params.targetLength || 250 });
+                const result = await provider.generateText({
+                    prompt: params.prompt,
+                    temperature: temp,
+                    maxTokens: params.targetLength || 250,
+                });
                 if (result) {
                     optimizationResults.push({
                         parameters: { temperature: temp },
                         output: result.text,
-                        usage: result.usage
+                        usage: result.usage,
                     });
                 }
             }
             const analysisProvider = await AIProviderFactory.createProvider(await getBestProvider());
-            if (!analysisProvider)
-                throw new Error('Failed to create analysis provider.');
+            if (!analysisProvider) {
+                throw new Error("Failed to create analysis provider.");
+            }
             const analysisPrompt = `
         Analyze the following AI-generated responses for the prompt "${params.prompt}" based on the optimization goal of "${params.optimizeFor}".
 
         Responses:
-        ${optimizationResults.map((r, i) => `Response ${i + 1} (Temp: ${r.parameters.temperature}):\n${r.output}`).join('\n\n')}
+        ${optimizationResults.map((r, i) => `Response ${i + 1} (Temp: ${r.parameters.temperature}):\n${r.output}`).join("\n\n")}
 
         Determine which set of parameters is optimal and provide a recommendation.
         Return a valid JSON object with keys: "optimalParameters", "reasoning", "recommendations".
       `;
-            const analysisResult = await analysisProvider.generateText({ prompt: analysisPrompt, maxTokens: 500 });
-            if (!analysisResult || !analysisResult.text)
-                throw new Error('Optimization analysis failed.');
+            const analysisResult = await analysisProvider.generateText({
+                prompt: analysisPrompt,
+                maxTokens: 500,
+            });
+            if (!analysisResult || !analysisResult.text) {
+                throw new Error("Optimization analysis failed.");
+            }
             const parsedAnalysis = JSON.parse(analysisResult.text);
             const executionTime = Date.now() - startTime;
             return {
                 success: true,
                 data: {
-                    optimization: { originalPrompt: params.prompt, optimizeFor: params.optimizeFor, provider: providerName },
+                    optimization: {
+                        originalPrompt: params.prompt,
+                        optimizeFor: params.optimizeFor,
+                        provider: providerName,
+                    },
                     results: optimizationResults,
                     recommendations: parsedAnalysis,
-                    optimizedAt: new Date().toISOString()
+                    optimizedAt: new Date().toISOString(),
+                },
+                usage: {
+                    executionTime,
+                    provider: "optimization-engine",
+                    model: "multi-provider",
+                },
+                metadata: {
+                    toolName: "optimize-prompt-parameters",
+                    serverId: "neurolink-ai-core",
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime,
                 },
-                usage: { executionTime, provider: 'optimization-engine', model: 'multi-provider' },
-                metadata: { toolName: 'optimize-prompt-parameters', 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);
-            return { success: false, error: errorMessage, metadata: { toolName: 'optimize-prompt-parameters', serverId: 'neurolink-ai-core', sessionId: context.sessionId, timestamp: Date.now(), executionTime } };
+            return {
+                success: false,
+                error: errorMessage,
+                metadata: {
+                    toolName: "optimize-prompt-parameters",
+                    serverId: "neurolink-ai-core",
+                    sessionId: context.sessionId,
+                    timestamp: Date.now(),
+                    executionTime,
+                },
+            };
         }
-    }
+    },
 };