@juspay/neurolink 1.5.1 → 1.5.2

package/dist/lib/utils/providerUtils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Get the best available provider based on preferences and availability
+ * @param requestedProvider - Optional preferred provider name
+ * @returns The best provider name to use
+ */
+export declare function getBestProvider(requestedProvider?: string): string;
+/**
+ * Get available provider names
+ * @returns Array of available provider names
+ */
+export declare function getAvailableProviders(): string[];
+/**
+ * Validate provider name
+ * @param provider - Provider name to validate
+ * @returns True if provider name is valid
+ */
+export declare function isValidProvider(provider: string): boolean;

package/dist/lib/utils/providerUtils.js

@@ -0,0 +1,73 @@
+/**
+ * Utility functions for AI provider management
+ */
+import { logger } from './logger.js';
+/**
+ * Get the best available provider based on preferences and availability
+ * @param requestedProvider - Optional preferred provider name
+ * @returns The best provider name to use
+ */
+export function getBestProvider(requestedProvider) {
+    // If a specific provider is requested, return it
+    if (requestedProvider) {
+        return requestedProvider;
+    }
+    // Default fallback order based on environment variables - OpenAI first since it's most reliable
+    const providers = ['openai', 'vertex', 'bedrock', 'anthropic', 'azure', 'google-ai'];
+    // Check which providers have their required environment variables
+    for (const provider of providers) {
+        if (isProviderConfigured(provider)) {
+            logger.debug(`[getBestProvider] Selected provider: ${provider}`);
+            return provider;
+        }
+    }
+    // Default to bedrock if nothing is configured
+    logger.warn('[getBestProvider] No providers configured, defaulting to bedrock');
+    return 'bedrock';
+}
+/**
+ * Check if a provider has the minimum required configuration
+ * @param provider - Provider name to check
+ * @returns True if the provider appears to be configured
+ */
+function isProviderConfigured(provider) {
+    switch (provider.toLowerCase()) {
+        case 'bedrock':
+        case 'amazon':
+        case 'aws':
+            return !!(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY);
+        case 'vertex':
+        case 'google':
+        case 'gemini':
+            return !!(process.env.GOOGLE_VERTEX_PROJECT || process.env.GOOGLE_APPLICATION_CREDENTIALS);
+        case 'openai':
+        case 'gpt':
+            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;
+        case 'google-ai':
+        case 'google-studio':
+            return !!(process.env.GOOGLE_AI_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY);
+        default:
+            return false;
+    }
+}
+/**
+ * Get available provider names
+ * @returns Array of available provider names
+ */
+export function getAvailableProviders() {
+    return ['bedrock', 'vertex', 'openai', 'anthropic', 'azure', 'google-ai'];
+}
+/**
+ * Validate provider name
+ * @param provider - Provider name to validate
+ * @returns True if provider name is valid
+ */
+export function isValidProvider(provider) {
+    return getAvailableProviders().includes(provider.toLowerCase());
+}

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

@@ -7,6 +7,7 @@ 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';
 /**
@@ -68,7 +69,7 @@ aiCoreServer.registerTool({
     execute: async (params, context) => {
         const startTime = Date.now();
         try {
-            console.log(`[AI-Core] Starting text generation: "${params.prompt.substring(0, 50)}..."`);
+            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);
@@ -84,7 +85,7 @@ aiCoreServer.registerTool({
                 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}`);
+            logger.debug(`[AI-Core] Text generation successful in ${executionTime}ms using ${selectedProvider}`);
             return {
                 success: true,
                 data: {
@@ -111,7 +112,7 @@ aiCoreServer.registerTool({
         catch (error) {
             const executionTime = Date.now() - startTime;
             const errorMessage = error instanceof Error ? error.message : String(error);
-            console.error(`[AI-Core] Text generation failed: ${errorMessage}`);
+            logger.debug(`[AI-Core] Text generation failed: ${errorMessage}`);
             return {
                 success: false,
                 error: errorMessage,
@@ -139,7 +140,7 @@ aiCoreServer.registerTool({
     execute: async (params, context) => {
         const startTime = Date.now();
         try {
-            console.log(`[AI-Core] Selecting provider with requirements:`, params.requirements);
+            logger.debug(`[AI-Core] Selecting provider with requirements:`, params.requirements);
             // Use existing provider selection logic
             const availableProviders = getAvailableProviders();
             const selectedProvider = getBestProvider(params.preferred);
@@ -152,7 +153,7 @@ aiCoreServer.registerTool({
             });
             const capabilities = getProviderCapabilities(selectedProvider);
             const executionTime = Date.now() - startTime;
-            console.log(`[AI-Core] Selected provider: ${selectedProvider} in ${executionTime}ms`);
+            logger.debug(`[AI-Core] Selected provider: ${selectedProvider} in ${executionTime}ms`);
             return {
                 success: true,
                 data: {
@@ -179,7 +180,7 @@ aiCoreServer.registerTool({
         catch (error) {
             const executionTime = Date.now() - startTime;
             const errorMessage = error instanceof Error ? error.message : String(error);
-            console.error(`[AI-Core] Provider selection failed: ${errorMessage}`);
+            logger.debug(`[AI-Core] Provider selection failed: ${errorMessage}`);
             return {
                 success: false,
                 error: errorMessage,
@@ -210,7 +211,7 @@ aiCoreServer.registerTool({
     execute: async (params, context) => {
         const startTime = Date.now();
         try {
-            console.log(`[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;
@@ -240,7 +241,7 @@ aiCoreServer.registerTool({
                 }
             }
             const executionTime = Date.now() - startTime;
-            console.log(`[AI-Core] Provider status check completed in ${executionTime}ms`);
+            logger.debug(`[AI-Core] Provider status check completed in ${executionTime}ms`);
             return {
                 success: true,
                 data: {
@@ -268,7 +269,7 @@ aiCoreServer.registerTool({
         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}`);
+            logger.debug(`[AI-Core] Provider status check failed: ${errorMessage}`);
             return {
                 success: false,
                 error: errorMessage,
@@ -299,4 +300,4 @@ aiCoreServer.registerTool(refactorCodeTool);
 aiCoreServer.registerTool(generateDocumentationTool);
 aiCoreServer.registerTool(debugAIOutputTool);
 // Log successful server creation
-console.log('[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/neurolink.js

@@ -6,6 +6,7 @@
  */
 import { AIProviderFactory, createBestAIProvider } from './index.js';
 import { getBestProvider } from './utils/providerUtils.js';
+import { logger } from './utils/logger.js';
 export class NeuroLink {
     /**
      * Generate text using the best available AI provider with automatic fallback
@@ -14,13 +15,13 @@ export class NeuroLink {
         const startTime = Date.now();
         const functionTag = 'NeuroLink.generateText';
         // Define fallback provider priority order
-        const providerPriority = ['openai', 'vertex', 'bedrock', 'google-ai'];
+        const providerPriority = ['openai', 'vertex', 'bedrock', 'anthropic', 'azure', 'google-ai'];
         const requestedProvider = options.provider === 'auto' ? undefined : options.provider;
         // If specific provider requested, try that first, then fallback to priority order
         const tryProviders = requestedProvider
             ? [requestedProvider, ...providerPriority.filter(p => p !== requestedProvider)]
             : providerPriority;
-        console.log(`[${functionTag}] Starting text generation with fallback`, {
+        logger.debug(`[${functionTag}] Starting text generation with fallback`, {
             requestedProvider: requestedProvider || 'auto',
             tryProviders,
             promptLength: options.prompt.length
@@ -28,7 +29,7 @@ export class NeuroLink {
         let lastError = null;
         for (const providerName of tryProviders) {
             try {
-                console.log(`[${functionTag}] Attempting provider`, { provider: providerName });
+                logger.debug(`[${functionTag}] Attempting provider`, { provider: providerName });
                 const provider = AIProviderFactory.createProvider(providerName);
                 const result = await provider.generateText({
                     prompt: options.prompt,
@@ -40,7 +41,7 @@ export class NeuroLink {
                     throw new Error('No response received from AI provider');
                 }
                 const responseTime = Date.now() - startTime;
-                console.log(`[${functionTag}] Provider succeeded`, {
+                logger.debug(`[${functionTag}] Provider succeeded`, {
                     provider: providerName,
                     responseTime,
                     usage: result.usage
@@ -55,7 +56,7 @@ export class NeuroLink {
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 lastError = error instanceof Error ? error : new Error(errorMessage);
-                console.warn(`[${functionTag}] Provider failed, trying next`, {
+                logger.debug(`[${functionTag}] Provider failed, trying next`, {
                     provider: providerName,
                     error: errorMessage,
                     remainingProviders: tryProviders.slice(tryProviders.indexOf(providerName) + 1)
@@ -65,7 +66,7 @@ export class NeuroLink {
             }
         }
         // All providers failed
-        console.error(`[${functionTag}] All providers failed`, {
+        logger.debug(`[${functionTag}] All providers failed`, {
             triedProviders: tryProviders,
             lastError: lastError?.message
         });
@@ -77,13 +78,13 @@ export class NeuroLink {
     async generateTextStream(options) {
         const functionTag = 'NeuroLink.generateTextStream';
         // Define fallback provider priority order
-        const providerPriority = ['openai', 'vertex', 'bedrock', 'google-ai'];
+        const providerPriority = ['openai', 'vertex', 'bedrock', 'anthropic', 'azure', 'google-ai'];
         const requestedProvider = options.provider === 'auto' ? undefined : options.provider;
         // If specific provider requested, try that first, then fallback to priority order
         const tryProviders = requestedProvider
             ? [requestedProvider, ...providerPriority.filter(p => p !== requestedProvider)]
             : providerPriority;
-        console.log(`[${functionTag}] Starting stream generation with fallback`, {
+        logger.debug(`[${functionTag}] Starting stream generation with fallback`, {
             requestedProvider: requestedProvider || 'auto',
             tryProviders,
             promptLength: options.prompt.length
@@ -91,7 +92,7 @@ export class NeuroLink {
         let lastError = null;
         for (const providerName of tryProviders) {
             try {
-                console.log(`[${functionTag}] Attempting provider`, { provider: providerName });
+                logger.debug(`[${functionTag}] Attempting provider`, { provider: providerName });
                 const provider = AIProviderFactory.createProvider(providerName);
                 const result = await provider.streamText({
                     prompt: options.prompt,
@@ -102,7 +103,7 @@ export class NeuroLink {
                 if (!result) {
                     throw new Error('No stream response received from AI provider');
                 }
-                console.log(`[${functionTag}] Provider succeeded`, { provider: providerName });
+                logger.debug(`[${functionTag}] Provider succeeded`, { provider: providerName });
                 // Convert the AI SDK stream to our expected format
                 async function* convertStream() {
                     if (result && result.textStream) {
@@ -116,7 +117,7 @@ export class NeuroLink {
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 lastError = error instanceof Error ? error : new Error(errorMessage);
-                console.warn(`[${functionTag}] Provider failed, trying next`, {
+                logger.debug(`[${functionTag}] Provider failed, trying next`, {
                     provider: providerName,
                     error: errorMessage,
                     remainingProviders: tryProviders.slice(tryProviders.indexOf(providerName) + 1)
@@ -126,7 +127,7 @@ export class NeuroLink {
             }
         }
         // All providers failed
-        console.error(`[${functionTag}] All providers failed`, {
+        logger.debug(`[${functionTag}] All providers failed`, {
             triedProviders: tryProviders,
             lastError: lastError?.message
         });

package/dist/providers/amazonBedrock.js

@@ -1,5 +1,6 @@
 import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
 import { streamText, generateText, Output } from 'ai';
+import { logger } from '../utils/logger.js';
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: 'You are a helpful AI assistant.'
@@ -42,7 +43,7 @@ export class AmazonBedrock {
         const functionTag = 'AmazonBedrock.constructor';
         this.modelName = modelName || getBedrockModelId();
         try {
-            console.log(`[${functionTag}] Function called`, {
+            logger.debug(`[${functionTag}] Function called`, {
                 modelName: this.modelName,
                 envBedrockModel: process.env.BEDROCK_MODEL,
                 envBedrockModelId: process.env.BEDROCK_MODEL_ID,
@@ -54,7 +55,7 @@ export class AmazonBedrock {
                 secretAccessKey: getAWSSecretAccessKey(),
                 region: getAWSRegion()
             };
-            console.log(`[${functionTag}] AWS config validation`, {
+            logger.debug(`[${functionTag}] AWS config validation`, {
                 hasAccessKeyId: !!awsConfig.accessKeyId,
                 hasSecretAccessKey: !!awsConfig.secretAccessKey,
                 region: awsConfig.region || 'MISSING',
@@ -66,49 +67,49 @@ export class AmazonBedrock {
                 const sessionToken = getAWSSessionToken();
                 if (sessionToken) {
                     awsConfig.sessionToken = sessionToken;
-                    console.log(`[${functionTag}] Session token added`, {
+                    logger.debug(`[${functionTag}] Session token added`, {
                         environment: 'dev'
                     });
                 }
                 else {
-                    console.warn(`[${functionTag}] Session token missing`, {
+                    logger.warn(`[${functionTag}] Session token missing`, {
                         environment: 'dev'
                     });
                 }
             }
-            console.log(`[${functionTag}] AWS config created`, {
+            logger.debug(`[${functionTag}] AWS config created`, {
                 region: awsConfig.region,
                 hasSessionToken: !!awsConfig.sessionToken
             });
-            console.log(`[${functionTag}] Bedrock provider creating`, {
+            logger.debug(`[${functionTag}] Bedrock provider creating`, {
                 modelName: this.modelName
             });
             // Create custom Bedrock provider instance with environment-based configuration
             this.bedrock = createAmazonBedrock(awsConfig);
-            console.log(`[${functionTag}] Bedrock provider initialized`, {
+            logger.debug(`[${functionTag}] Bedrock provider initialized`, {
                 modelName: this.modelName
             });
-            console.log(`[${functionTag}] Model instance creating`, {
+            logger.debug(`[${functionTag}] Model instance creating`, {
                 modelName: this.modelName
             });
             this.model = this.bedrock(this.modelName);
-            console.log(`[${functionTag}] Model instance created`, {
+            logger.debug(`[${functionTag}] Model instance created`, {
                 modelName: this.modelName
             });
-            console.log(`[${functionTag}] Function result`, {
+            logger.debug(`[${functionTag}] Function result`, {
                 modelName: this.modelName,
                 region: awsConfig.region,
                 hasSessionToken: !!awsConfig.sessionToken,
                 success: true
             });
-            console.log(`[${functionTag}] Initialization completed`, {
+            logger.debug(`[${functionTag}] Initialization completed`, {
                 modelName: this.modelName,
                 region: awsConfig.region,
                 hasSessionToken: !!awsConfig.sessionToken
             });
         }
         catch (err) {
-            console.error(`[${functionTag}] Initialization failed`, {
+            logger.error(`[${functionTag}] Initialization failed`, {
                 message: 'Error in initializing Amazon Bedrock',
                 modelName: this.modelName,
                 region: getAWSRegion(),
@@ -130,7 +131,7 @@ export class AmazonBedrock {
             const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
-            console.log(`[${functionTag}] Stream request started`, {
+            logger.debug(`[${functionTag}] Stream request started`, {
                 provider,
                 modelName: this.modelName,
                 promptLength: prompt.length,
@@ -147,7 +148,7 @@ export class AmazonBedrock {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     const errorStack = error instanceof Error ? error.stack : undefined;
-                    console.error(`[${functionTag}] Stream text error`, {
+                    logger.error(`[${functionTag}] Stream text error`, {
                         provider,
                         modelName: this.modelName,
                         region: getAWSRegion(),
@@ -158,7 +159,7 @@ export class AmazonBedrock {
                     });
                 },
                 onFinish: (event) => {
-                    console.log(`[${functionTag}] Stream text finished`, {
+                    logger.debug(`[${functionTag}] Stream text finished`, {
                         provider,
                         modelName: this.modelName,
                         region: getAWSRegion(),
@@ -171,7 +172,7 @@ export class AmazonBedrock {
                 },
                 onChunk: (event) => {
                     chunkCount++;
-                    console.debug(`[${functionTag}] Stream text chunk`, {
+                    logger.debug(`[${functionTag}] Stream text chunk`, {
                         provider,
                         modelName: this.modelName,
                         chunkNumber: chunkCount,
@@ -185,7 +186,7 @@ export class AmazonBedrock {
             }
             // Direct streamText call - let the real error bubble up
             const result = streamText(streamOptions);
-            console.log(`[${functionTag}] Stream text call successful`, {
+            logger.debug(`[${functionTag}] Stream text call successful`, {
                 provider,
                 modelName: this.modelName,
                 promptLength: prompt.length
@@ -193,7 +194,7 @@ export class AmazonBedrock {
             return result;
         }
         catch (err) {
-            console.error(`[${functionTag}] Exception`, {
+            logger.error(`[${functionTag}] Exception`, {
                 provider,
                 modelName: this.modelName,
                 region: getAWSRegion(),
@@ -214,7 +215,7 @@ export class AmazonBedrock {
             const { prompt, temperature = 0.7, maxTokens = 500, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
-            console.log(`[${functionTag}] Generate text started`, {
+            logger.debug(`[${functionTag}] Generate text started`, {
                 provider,
                 modelName: this.modelName,
                 region: getAWSRegion(),
@@ -233,7 +234,7 @@ export class AmazonBedrock {
                 generateOptions.experimental_output = Output.object({ schema: finalSchema });
             }
             const result = await generateText(generateOptions);
-            console.log(`[${functionTag}] Generate text completed`, {
+            logger.debug(`[${functionTag}] Generate text completed`, {
                 provider,
                 modelName: this.modelName,
                 usage: result.usage,
@@ -243,7 +244,7 @@ export class AmazonBedrock {
             return result;
         }
         catch (err) {
-            console.error(`[${functionTag}] Exception`, {
+            logger.error(`[${functionTag}] Exception`, {
                 provider,
                 modelName: this.modelName,
                 message: 'Error in generating text',

package/dist/providers/anthropic.js

@@ -5,6 +5,7 @@
  * Supports Claude 3.5 Sonnet, Claude 3.5 Haiku, and Claude 3 Opus.
  */
 import { AIProviderName } from '../core/types.js';
+import { logger } from '../utils/logger.js';
 export class AnthropicProvider {
     name = AIProviderName.ANTHROPIC;
     apiKey;
@@ -14,7 +15,7 @@ export class AnthropicProvider {
         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}`);
+        logger.debug(`[AnthropicProvider] Initialized with model: ${this.defaultModel}`);
     }
     getApiKey() {
         const apiKey = process.env.ANTHROPIC_API_KEY;
@@ -34,8 +35,8 @@ export class AnthropicProvider {
             '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}`);
+        logger.debug(`[AnthropicProvider.makeRequest] ${stream ? 'Streaming' : 'Non-streaming'} request to ${url}`);
+        logger.debug(`[AnthropicProvider.makeRequest] Model: ${body.model}, Max tokens: ${body.max_tokens}`);
         const response = await fetch(url, {
             method: 'POST',
             headers,
@@ -43,19 +44,19 @@ export class AnthropicProvider {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            console.error(`[AnthropicProvider.makeRequest] API error ${response.status}: ${errorText}`);
+            logger.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');
+        logger.debug('[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}`);
+        logger.debug(`[AnthropicProvider.generateText] Prompt: "${prompt.substring(0, 100)}...", Temperature: ${temperature}, Max tokens: ${maxTokens}`);
         const requestBody = {
             model: this.getModel(),
             max_tokens: maxTokens,
@@ -71,7 +72,7 @@ export class AnthropicProvider {
         try {
             const response = await this.makeRequest('messages', requestBody);
             const data = await response.json();
-            console.log(`[AnthropicProvider.generateText] Success. Generated ${data.usage.output_tokens} tokens`);
+            logger.debug(`[AnthropicProvider.generateText] Success. Generated ${data.usage.output_tokens} tokens`);
             const content = data.content.map(block => block.text).join('');
             return {
                 content,
@@ -86,18 +87,18 @@ export class AnthropicProvider {
             };
         }
         catch (error) {
-            console.error('[AnthropicProvider.generateText] Error:', error);
+            logger.error('[AnthropicProvider.generateText] Error:', error);
             throw error;
         }
     }
     async streamText(optionsOrPrompt, schema) {
-        console.log('[AnthropicProvider.streamText] Starting text streaming');
+        logger.debug('[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)}..."`);
+        logger.debug(`[AnthropicProvider.streamText] Streaming prompt: "${prompt.substring(0, 100)}..."`);
         const requestBody = {
             model: this.getModel(),
             max_tokens: maxTokens,
@@ -125,7 +126,7 @@ export class AnthropicProvider {
             };
         }
         catch (error) {
-            console.error('[AnthropicProvider.streamText] Error:', error);
+            logger.error('[AnthropicProvider.streamText] Error:', error);
             throw error;
         }
     }
@@ -156,7 +157,7 @@ export class AnthropicProvider {
                             }
                         }
                         catch (parseError) {
-                            console.warn('[AnthropicProvider.createAsyncIterable] Failed to parse chunk:', parseError);
+                            logger.warn('[AnthropicProvider.createAsyncIterable] Failed to parse chunk:', parseError);
                             continue;
                         }
                     }
@@ -168,13 +169,13 @@ export class AnthropicProvider {
         }
     }
     async *generateTextStream(optionsOrPrompt) {
-        console.log('[AnthropicProvider.generateTextStream] Starting text streaming');
+        logger.debug('[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)}..."`);
+        logger.debug(`[AnthropicProvider.generateTextStream] Streaming prompt: "${prompt.substring(0, 100)}..."`);
         const requestBody = {
             model: this.getModel(),
             max_tokens: maxTokens,
@@ -223,7 +224,7 @@ export class AnthropicProvider {
                                 }
                             }
                             catch (parseError) {
-                                console.warn('[AnthropicProvider.generateTextStream] Failed to parse chunk:', parseError);
+                                logger.warn('[AnthropicProvider.generateTextStream] Failed to parse chunk:', parseError);
                                 continue;
                             }
                         }
@@ -233,15 +234,15 @@ export class AnthropicProvider {
             finally {
                 reader.releaseLock();
             }
-            console.log('[AnthropicProvider.generateTextStream] Streaming completed');
+            logger.debug('[AnthropicProvider.generateTextStream] Streaming completed');
         }
         catch (error) {
-            console.error('[AnthropicProvider.generateTextStream] Error:', error);
+            logger.error('[AnthropicProvider.generateTextStream] Error:', error);
             throw error;
         }
     }
     async testConnection() {
-        console.log('[AnthropicProvider.testConnection] Testing connection to Anthropic API');
+        logger.debug('[AnthropicProvider.testConnection] Testing connection to Anthropic API');
         const startTime = Date.now();
         try {
             await this.generateText({
@@ -249,7 +250,7 @@ export class AnthropicProvider {
                 maxTokens: 5
             });
             const responseTime = Date.now() - startTime;
-            console.log(`[AnthropicProvider.testConnection] Connection test successful (${responseTime}ms)`);
+            logger.debug(`[AnthropicProvider.testConnection] Connection test successful (${responseTime}ms)`);
             return {
                 success: true,
                 responseTime
@@ -257,7 +258,7 @@ export class AnthropicProvider {
         }
         catch (error) {
             const responseTime = Date.now() - startTime;
-            console.error(`[AnthropicProvider.testConnection] Connection test failed (${responseTime}ms):`, error);
+            logger.error(`[AnthropicProvider.testConnection] Connection test failed (${responseTime}ms):`, error);
             return {
                 success: false,
                 error: error instanceof Error ? error.message : 'Unknown error',