converse-mcp-server 2.3.1 → 2.4.1

package/src/providers/anthropic.js

@@ -26,8 +26,23 @@ const SUPPORTED_MODELS = {
     minThinkingTokens: 1024,
     maxThinkingTokens: 32000,
     timeout: 300000,
-    description: 'Claude Opus 4.1 - Highest level of intelligence and capability with extended thinking',
-    aliases: ['claude-opus-4-1', 'claude-4.1-opus', 'claude-4-1-opus', 'opus-4.1', 'opus-4-1', 'claude-4-opus', 'opus-4', 'opus', 'claude-opus', 'claude-opus-4', 'opus4', 'opus4.1', 'claude-opus-4.1']
+    description:
+      'Claude Opus 4.1 - Highest level of intelligence and capability with extended thinking',
+    aliases: [
+      'claude-opus-4-1',
+      'claude-4.1-opus',
+      'claude-4-1-opus',
+      'opus-4.1',
+      'opus-4-1',
+      'claude-4-opus',
+      'opus-4',
+      'opus',
+      'claude-opus',
+      'claude-opus-4',
+      'opus4',
+      'opus4.1',
+      'claude-opus-4.1',
+    ],
   },
   'claude-sonnet-4-5-20250929': {
     modelName: 'claude-sonnet-4-5-20250929',
@@ -43,8 +58,17 @@ const SUPPORTED_MODELS = {
     maxThinkingTokens: 64000,
     timeout: 300000,
     supports1MContext: true, // Beta 1M context support
-    description: 'Claude Sonnet 4.5 - Latest Sonnet with enhanced intelligence and optional 1M context',
-    aliases: ['claude-4.5-sonnet', 'sonnet-4.5', 'claude-sonnet-4.5', 'sonnet4.5', 'claude-sonnet-4-5', 'sonnet', 'claude-sonnet']
+    description:
+      'Claude Sonnet 4.5 - Latest Sonnet with enhanced intelligence and optional 1M context',
+    aliases: [
+      'claude-4.5-sonnet',
+      'sonnet-4.5',
+      'claude-sonnet-4.5',
+      'sonnet4.5',
+      'claude-sonnet-4-5',
+      'sonnet',
+      'claude-sonnet',
+    ],
   },
   'claude-sonnet-4-20250514': {
     modelName: 'claude-sonnet-4-20250514',
@@ -60,8 +84,9 @@ const SUPPORTED_MODELS = {
     maxThinkingTokens: 64000,
     timeout: 300000,
     supports1MContext: true, // Beta 1M context support
-    description: 'Claude Sonnet 4 - High intelligence and balanced performance with extended thinking',
-    aliases: ['claude-4-sonnet', 'sonnet-4', 'claude-sonnet-4', 'sonnet4']
+    description:
+      'Claude Sonnet 4 - High intelligence and balanced performance with extended thinking',
+    aliases: ['claude-4-sonnet', 'sonnet-4', 'claude-sonnet-4', 'sonnet4'],
   },
   'claude-3-7-sonnet-20250219': {
     modelName: 'claude-3-7-sonnet-20250219',
@@ -77,7 +102,13 @@ const SUPPORTED_MODELS = {
     maxThinkingTokens: 64000,
     timeout: 300000,
     description: 'Claude 3.7 Sonnet - Enhanced 3.x generation with thinking',
-    aliases: ['claude-3.7-sonnet', 'sonnet-3.7', 'claude-3-7-sonnet', 'claude 3.7 sonnet', 'sonnet 3.7']
+    aliases: [
+      'claude-3.7-sonnet',
+      'sonnet-3.7',
+      'claude-3-7-sonnet',
+      'claude 3.7 sonnet',
+      'sonnet 3.7',
+    ],
   },
   'claude-haiku-4-5-20251001': {
     modelName: 'claude-haiku-4-5-20251001',
@@ -92,8 +123,20 @@ const SUPPORTED_MODELS = {
     minThinkingTokens: 1024,
     maxThinkingTokens: 64000,
     timeout: 300000,
-    description: 'Claude Haiku 4.5 - Fast and intelligent model with extended thinking',
-    aliases: ['claude-haiku-4-5', 'claude-4.5-haiku', 'claude-4-5-haiku', 'haiku-4.5', 'haiku-4-5', 'claude-haiku-4.5', 'haiku4.5', 'claude-haiku-4', 'haiku', 'claude-haiku']
+    description:
+      'Claude Haiku 4.5 - Fast and intelligent model with extended thinking',
+    aliases: [
+      'claude-haiku-4-5',
+      'claude-4.5-haiku',
+      'claude-4-5-haiku',
+      'haiku-4.5',
+      'haiku-4-5',
+      'claude-haiku-4.5',
+      'haiku4.5',
+      'claude-haiku-4',
+      'haiku',
+      'claude-haiku',
+    ],
   },
   'claude-3-5-sonnet-20241022': {
     modelName: 'claude-3-5-sonnet-20241022',
@@ -107,7 +150,14 @@ const SUPPORTED_MODELS = {
     supportsThinking: false,
     timeout: 300000,
     description: 'Claude 3.5 Sonnet - Fast and intelligent model',
-    aliases: ['claude-3.5-sonnet', 'claude-3-5-sonnet-latest', 'claude-sonnet-3.5', 'sonnet-3.5', 'claude 3.5 sonnet', 'sonnet 3.5']
+    aliases: [
+      'claude-3.5-sonnet',
+      'claude-3-5-sonnet-latest',
+      'claude-sonnet-3.5',
+      'sonnet-3.5',
+      'claude 3.5 sonnet',
+      'sonnet 3.5',
+    ],
   },
   'claude-3-5-haiku-20241022': {
     modelName: 'claude-3-5-haiku-20241022',
@@ -121,29 +171,35 @@ const SUPPORTED_MODELS = {
     supportsThinking: false,
     timeout: 180000,
     description: 'Claude 3.5 Haiku - Fastest model, best for simple queries',
-    aliases: ['claude-3.5-haiku', 'claude-3-5-haiku-latest', 'haiku-3.5', 'claude 3.5 haiku', 'haiku 3.5']
-  }
+    aliases: [
+      'claude-3.5-haiku',
+      'claude-3-5-haiku-latest',
+      'haiku-3.5',
+      'claude 3.5 haiku',
+      'haiku 3.5',
+    ],
+  },
 };
 
 /**
  * Map Anthropic stop reasons to unified format
  */
 const STOP_REASON_MAP = {
-  'end_turn': StopReasons.STOP,
-  'max_tokens': StopReasons.LENGTH,
-  'stop_sequence': StopReasons.STOP,
-  'tool_use': StopReasons.TOOL_USE
+  end_turn: StopReasons.STOP,
+  max_tokens: StopReasons.LENGTH,
+  stop_sequence: StopReasons.STOP,
+  tool_use: StopReasons.TOOL_USE,
 };
 
 /**
  * Thinking budget percentages mapped to reasoning_effort
  */
 const THINKING_BUDGETS = {
-  minimal: 0.05,  // 5% of max thinking tokens
-  low: 0.15,      // 15% of max thinking tokens
-  medium: 0.33,   // 33% of max thinking tokens (default)
-  high: 0.67,     // 67% of max thinking tokens
-  max: 1.0        // 100% of max thinking tokens
+  minimal: 0.05, // 5% of max thinking tokens
+  low: 0.15, // 15% of max thinking tokens
+  medium: 0.33, // 33% of max thinking tokens (default)
+  high: 0.67, // 67% of max thinking tokens
+  max: 1.0, // 100% of max thinking tokens
 };
 
 /**
@@ -206,13 +262,16 @@ function validateApiKey(apiKey) {
  */
 function convertMessagesToAnthropic(messages, options = {}) {
   if (!Array.isArray(messages)) {
-    throw new AnthropicProviderError('Messages must be an array', ErrorCodes.INVALID_MESSAGES);
+    throw new AnthropicProviderError(
+      'Messages must be an array',
+      ErrorCodes.INVALID_MESSAGES,
+    );
   }
 
   const {
     enableSystemCache = true, // Always cache system messages by default
     cacheUserMessages = false,
-    cacheMessageThreshold = 5 // Cache messages after this many turns
+    cacheMessageThreshold = 5, // Cache messages after this many turns
   } = options;
   const systemContent = [];
   let systemText = '';
@@ -220,17 +279,26 @@ function convertMessagesToAnthropic(messages, options = {}) {
 
   for (const [index, msg] of messages.entries()) {
     if (!msg || typeof msg !== 'object') {
-      throw new AnthropicProviderError(`Message at index ${index} must be an object`, ErrorCodes.INVALID_MESSAGE);
+      throw new AnthropicProviderError(
+        `Message at index ${index} must be an object`,
+        ErrorCodes.INVALID_MESSAGE,
+      );
     }
 
     const { role, content } = msg;
 
     if (!role || !['system', 'user', 'assistant'].includes(role)) {
-      throw new AnthropicProviderError(`Invalid role "${role}" at message index ${index}`, ErrorCodes.INVALID_ROLE);
+      throw new AnthropicProviderError(
+        `Invalid role "${role}" at message index ${index}`,
+        ErrorCodes.INVALID_ROLE,
+      );
     }
 
     if (!content) {
-      throw new AnthropicProviderError(`Message content is required at index ${index}`, ErrorCodes.MISSING_CONTENT);
+      throw new AnthropicProviderError(
+        `Message content is required at index ${index}`,
+        ErrorCodes.MISSING_CONTENT,
+      );
     }
 
     if (role === 'system') {
@@ -245,7 +313,7 @@ function convertMessagesToAnthropic(messages, options = {}) {
           if (item.type === 'text') {
             anthropicContent.push({
               type: 'text',
-              text: item.text
+              text: item.text,
             });
           } else if (item.type === 'image' && item.source) {
             // Content is already in Anthropic format
@@ -254,22 +322,24 @@ function convertMessagesToAnthropic(messages, options = {}) {
               source: {
                 type: 'base64',
                 media_type: item.source.media_type,
-                data: item.source.data
-              }
+                data: item.source.data,
+              },
             });
-            debugLog(`[Anthropic] Processing image: ${item.source.media_type}, data length: ${item.source.data.length}`);
+            debugLog(
+              `[Anthropic] Processing image: ${item.source.media_type}, data length: ${item.source.data.length}`,
+            );
           }
         }
 
         anthropicMessages.push({
           role,
-          content: anthropicContent
+          content: anthropicContent,
         });
       } else {
         // Simple string content
         anthropicMessages.push({
           role,
-          content
+          content,
         });
       }
     }
@@ -277,7 +347,10 @@ function convertMessagesToAnthropic(messages, options = {}) {
 
   // Ensure first message is from user
   if (anthropicMessages.length > 0 && anthropicMessages[0].role !== 'user') {
-    throw new AnthropicProviderError('First message must be from user role', ErrorCodes.INVALID_MESSAGE);
+    throw new AnthropicProviderError(
+      'First message must be from user role',
+      ErrorCodes.INVALID_MESSAGE,
+    );
   }
 
   // Ensure messages alternate between user and assistant
@@ -288,7 +361,7 @@ function convertMessagesToAnthropic(messages, options = {}) {
     if (prevRole === currRole) {
       throw new AnthropicProviderError(
         `Messages must alternate between user and assistant. Found consecutive ${currRole} messages at index ${i}`,
-        ErrorCodes.INVALID_MESSAGE
+        ErrorCodes.INVALID_MESSAGE,
       );
     }
   }
@@ -298,15 +371,19 @@ function convertMessagesToAnthropic(messages, options = {}) {
   if (systemText) {
     if (enableSystemCache) {
       // Use array format with cache control for system prompt
-      systemResult = [{
-        type: 'text',
-        text: systemText,
-        cache_control: {
-          type: 'ephemeral',
-          ttl: '1h' // 1 hour cache duration
-        }
-      }];
-      debugLog(`[Anthropic] System prompt caching enabled (ephemeral with ttl-extender for 1 hour) - ${systemText.length} chars`);
+      systemResult = [
+        {
+          type: 'text',
+          text: systemText,
+          cache_control: {
+            type: 'ephemeral',
+            ttl: '1h', // 1 hour cache duration
+          },
+        },
+      ];
+      debugLog(
+        `[Anthropic] System prompt caching enabled (ephemeral with ttl-extender for 1 hour) - ${systemText.length} chars`,
+      );
     } else {
       // Use simple string format without caching
       systemResult = systemText;
@@ -343,7 +420,7 @@ async function getAnthropicSDK() {
       throw new AnthropicProviderError(
         'Failed to load Anthropic SDK. Please install @anthropic-ai/sdk',
         ErrorCodes.API_ERROR,
-        error
+        error,
       );
     }
   }
@@ -377,11 +454,17 @@ export const anthropicProvider = {
 
     // Validate API key
     if (!config?.apiKeys?.anthropic) {
-      throw new AnthropicProviderError('Anthropic API key not configured', ErrorCodes.MISSING_API_KEY);
+      throw new AnthropicProviderError(
+        'Anthropic API key not configured',
+        ErrorCodes.MISSING_API_KEY,
+      );
     }
 
     if (!validateApiKey(config.apiKeys.anthropic)) {
-      throw new AnthropicProviderError('Invalid Anthropic API key format', ErrorCodes.INVALID_API_KEY);
+      throw new AnthropicProviderError(
+        'Invalid Anthropic API key format',
+        ErrorCodes.INVALID_API_KEY,
+      );
     }
 
     // Get Anthropic SDK
@@ -395,21 +478,27 @@ export const anthropicProvider = {
     const anthropic = new Anthropic({
       apiKey: config.apiKeys.anthropic,
       // Increase timeout to 20 minutes for thinking models that may take longer
-      timeout: 20 * 60 * 1000
+      timeout: 20 * 60 * 1000,
     });
 
     // Build beta features array for the request
     // Use both prompt caching and extended cache duration for 1-hour caching
-    const betas = ['prompt-caching-2024-07-31', 'extended-cache-ttl-2025-04-11'];
+    const betas = [
+      'prompt-caching-2024-07-31',
+      'extended-cache-ttl-2025-04-11',
+    ];
 
     // Add 1M context beta feature if model supports it
     if (modelConfig.supports1MContext) {
       betas.push('context-1m-2025-08-07');
-      debugLog(`[Anthropic] Model ${resolvedModel} supports 1M context window with beta feature`);
+      debugLog(
+        `[Anthropic] Model ${resolvedModel} supports 1M context window with beta feature`,
+      );
     }
 
     // Convert messages to Anthropic format (system messages are always cached)
-    const { systemPrompt, messages: anthropicMessages } = convertMessagesToAnthropic(messages);
+    const { systemPrompt, messages: anthropicMessages } =
+      convertMessagesToAnthropic(messages);
 
     // Build request payload
     const requestPayload = {
@@ -417,7 +506,7 @@ export const anthropicProvider = {
       messages: anthropicMessages,
       stream,
       betas, // Include beta features
-      ...otherOptions
+      ...otherOptions,
     };
 
     // Add system prompt if present
@@ -427,7 +516,10 @@ export const anthropicProvider = {
 
     // Set max tokens - API requires this field
     if (maxTokens) {
-      requestPayload.max_tokens = Math.min(maxTokens, modelConfig.maxOutputTokens || 8192);
+      requestPayload.max_tokens = Math.min(
+        maxTokens,
+        modelConfig.maxOutputTokens || 8192,
+      );
     } else {
       // Use model's default max output tokens
       requestPayload.max_tokens = modelConfig.maxOutputTokens || 8192;
@@ -435,26 +527,39 @@ export const anthropicProvider = {
 
     // Add thinking configuration for models that support it
     if (modelConfig.supportsThinking && reasoning_effort) {
-      const thinkingBudget = calculateThinkingBudget(modelConfig, reasoning_effort);
-      debugLog(`[Anthropic] Model ${resolvedModel}: maxOutputTokens=${modelConfig.maxOutputTokens}, maxThinkingTokens=${modelConfig.maxThinkingTokens}, thinkingBudget=${thinkingBudget}`);
+      const thinkingBudget = calculateThinkingBudget(
+        modelConfig,
+        reasoning_effort,
+      );
+      debugLog(
+        `[Anthropic] Model ${resolvedModel}: maxOutputTokens=${modelConfig.maxOutputTokens}, maxThinkingTokens=${modelConfig.maxThinkingTokens}, thinkingBudget=${thinkingBudget}`,
+      );
 
       // For 4 series models, we trust the SDK defaults work with thinking
       // For other models, check against max_tokens if set
-      const maxTokensLimit = requestPayload.max_tokens ||
-        (resolvedModel.includes('claude-opus-4') ? 32000 :
-          (resolvedModel.includes('claude-sonnet-4-5') || resolvedModel.includes('claude-sonnet-4')) ? 64000 :
-            modelConfig.maxOutputTokens);
+      const maxTokensLimit =
+        requestPayload.max_tokens ||
+        (resolvedModel.includes('claude-opus-4')
+          ? 32000
+          : resolvedModel.includes('claude-sonnet-4-5') ||
+              resolvedModel.includes('claude-sonnet-4')
+            ? 64000
+            : modelConfig.maxOutputTokens);
 
       if (thinkingBudget > 0 && thinkingBudget < maxTokensLimit) {
         // According to Anthropic docs: thinking tokens count towards max_tokens limit
         // thinking.budget_tokens must be >= 1024 and < max_tokens
         requestPayload.thinking = {
           type: 'enabled',
-          budget_tokens: thinkingBudget
+          budget_tokens: thinkingBudget,
         };
-        debugLog(`[Anthropic] Thinking enabled with budget: ${thinkingBudget} tokens (${reasoning_effort} effort)`);
+        debugLog(
+          `[Anthropic] Thinking enabled with budget: ${thinkingBudget} tokens (${reasoning_effort} effort)`,
+        );
       } else {
-        debugLog(`[Anthropic] Thinking not enabled: budget ${thinkingBudget} must be < max_tokens limit ${maxTokensLimit}`);
+        debugLog(
+          `[Anthropic] Thinking not enabled: budget ${thinkingBudget} must be < max_tokens limit ${maxTokensLimit}`,
+        );
       }
     }
 
@@ -471,28 +576,49 @@ export const anthropicProvider = {
 
     // If streaming is requested and model doesn't support it, fall back to non-streaming
     if (stream && modelConfig.supportsStreaming === false) {
-      debugLog(`[Anthropic] Model ${resolvedModel} doesn't support streaming, falling back to non-streaming mode`);
+      debugLog(
+        `[Anthropic] Model ${resolvedModel} doesn't support streaming, falling back to non-streaming mode`,
+      );
       requestPayload.stream = false;
     }
 
     // Handle streaming requests
     if (stream && requestPayload.stream !== false) {
-      return this._createStreamingGenerator(anthropic, requestPayload, resolvedModel, modelConfig, reasoning_effort);
+      return this._createStreamingGenerator(
+        anthropic,
+        requestPayload,
+        resolvedModel,
+        modelConfig,
+        reasoning_effort,
+      );
     }
 
     try {
-      debugLog(`[Anthropic] Calling ${resolvedModel} with ${anthropicMessages.length} messages`);
-      debugLog('[Anthropic] Request payload:', JSON.stringify({
-        model: requestPayload.model,
-        max_tokens: requestPayload.max_tokens,
-        thinking: requestPayload.thinking,
-        temperature: requestPayload.temperature,
-        betas: requestPayload.betas,
-        message_count: requestPayload.messages?.length,
-        system_length: Array.isArray(requestPayload.system) ? requestPayload.system[0]?.text?.length : requestPayload.system?.length
-      }, null, 2));
+      debugLog(
+        `[Anthropic] Calling ${resolvedModel} with ${anthropicMessages.length} messages`,
+      );
+      debugLog(
+        '[Anthropic] Request payload:',
+        JSON.stringify(
+          {
+            model: requestPayload.model,
+            max_tokens: requestPayload.max_tokens,
+            thinking: requestPayload.thinking,
+            temperature: requestPayload.temperature,
+            betas: requestPayload.betas,
+            message_count: requestPayload.messages?.length,
+            system_length: Array.isArray(requestPayload.system)
+              ? requestPayload.system[0]?.text?.length
+              : requestPayload.system?.length,
+          },
+          null,
+          2,
+        ),
+      );
       if (systemPrompt) {
-        debugLog(`[Anthropic] System prompt length: ${systemPrompt.length} characters`);
+        debugLog(
+          `[Anthropic] System prompt length: ${systemPrompt.length} characters`,
+        );
       }
 
       const startTime = Date.now();
@@ -519,11 +645,15 @@ export const anthropicProvider = {
       }
 
       if (!content) {
-        throw new AnthropicProviderError('No content in response from Anthropic', ErrorCodes.NO_RESPONSE_CONTENT);
+        throw new AnthropicProviderError(
+          'No content in response from Anthropic',
+          ErrorCodes.NO_RESPONSE_CONTENT,
+        );
       }
 
       // Map stop reason
-      const stopReason = STOP_REASON_MAP[response.stop_reason] || StopReasons.OTHER;
+      const stopReason =
+        STOP_REASON_MAP[response.stop_reason] || StopReasons.OTHER;
 
       // Extract usage information
       const usage = response.usage || {};
@@ -538,18 +668,20 @@ export const anthropicProvider = {
           usage: {
             input_tokens: usage.input_tokens || 0,
             output_tokens: usage.output_tokens || 0,
-            total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0),
+            total_tokens:
+              (usage.input_tokens || 0) + (usage.output_tokens || 0),
             thinking_tokens: usage.thinking_input_tokens || 0,
             cache_creation_input_tokens: usage.cache_creation_input_tokens || 0,
-            cache_read_input_tokens: usage.cache_read_input_tokens || 0
+            cache_read_input_tokens: usage.cache_read_input_tokens || 0,
           },
           response_time_ms: responseTime,
           finish_reason: response.stop_reason,
           provider: 'anthropic',
-          reasoning_effort: modelConfig.supportsThinking ? reasoning_effort : null
-        }
+          reasoning_effort: modelConfig.supportsThinking
+            ? reasoning_effort
+            : null,
+        },
       };
-
     } catch (error) {
       debugError('[Anthropic] Error during API call:', error);
 
@@ -560,28 +692,55 @@ export const anthropicProvider = {
 
       // Handle specific Anthropic errors
       if (error.status === 401) {
-        throw new AnthropicProviderError('Invalid Anthropic API key', ErrorCodes.INVALID_API_KEY, error);
+        throw new AnthropicProviderError(
+          'Invalid Anthropic API key',
+          ErrorCodes.INVALID_API_KEY,
+          error,
+        );
       } else if (error.status === 429) {
-        throw new AnthropicProviderError('Anthropic rate limit exceeded', ErrorCodes.RATE_LIMIT_EXCEEDED, error);
+        throw new AnthropicProviderError(
+          'Anthropic rate limit exceeded',
+          ErrorCodes.RATE_LIMIT_EXCEEDED,
+          error,
+        );
       } else if (error.status === 403) {
-        throw new AnthropicProviderError('Anthropic API quota exceeded or forbidden', ErrorCodes.QUOTA_EXCEEDED, error);
+        throw new AnthropicProviderError(
+          'Anthropic API quota exceeded or forbidden',
+          ErrorCodes.QUOTA_EXCEEDED,
+          error,
+        );
       } else if (error.error?.type === 'invalid_request_error') {
-        throw new AnthropicProviderError(`Invalid request: ${error.error.message}`, ErrorCodes.INVALID_REQUEST, error);
+        throw new AnthropicProviderError(
+          `Invalid request: ${error.error.message}`,
+          ErrorCodes.INVALID_REQUEST,
+          error,
+        );
       } else if (error.error?.type === 'not_found_error') {
-        throw new AnthropicProviderError(`Model ${resolvedModel} not found`, ErrorCodes.MODEL_NOT_FOUND, error);
-      } else if (error.message?.includes('context length') || error.message?.includes('context_length') ||
-                 (error.message?.includes('token') && error.message?.includes('limit'))) {
+        throw new AnthropicProviderError(
+          `Model ${resolvedModel} not found`,
+          ErrorCodes.MODEL_NOT_FOUND,
+          error,
+        );
+      } else if (
+        error.message?.includes('context length') ||
+        error.message?.includes('context_length') ||
+        (error.message?.includes('token') && error.message?.includes('limit'))
+      ) {
         debugError('[Anthropic] Context length error - Full error:', error);
         debugError('[Anthropic] Error message:', error.message);
         debugError('[Anthropic] Error response:', error.response);
-        throw new AnthropicProviderError(`Context length exceeded for model: ${error.message}`, ErrorCodes.CONTEXT_LENGTH_EXCEEDED, error);
+        throw new AnthropicProviderError(
+          `Context length exceeded for model: ${error.message}`,
+          ErrorCodes.CONTEXT_LENGTH_EXCEEDED,
+          error,
+        );
       }
 
       // Generic error handling
       throw new AnthropicProviderError(
         `Anthropic API error: ${error.message || 'Unknown error'}`,
         ErrorCodes.API_ERROR,
-        error
+        error,
       );
     }
   },
@@ -596,8 +755,16 @@ export const anthropicProvider = {
    * @param {string} reasoning_effort - Reasoning effort level
    * @returns {AsyncGenerator} - Async generator yielding streaming events
    */
-  async *_createStreamingGenerator(anthropic, requestPayload, resolvedModel, modelConfig, reasoning_effort) {
-    debugLog(`[Anthropic] Starting streaming for ${resolvedModel} with ${requestPayload.messages?.length} messages`);
+  async *_createStreamingGenerator(
+    anthropic,
+    requestPayload,
+    resolvedModel,
+    modelConfig,
+    reasoning_effort,
+  ) {
+    debugLog(
+      `[Anthropic] Starting streaming for ${resolvedModel} with ${requestPayload.messages?.length} messages`,
+    );
 
     const startTime = Date.now();
     let totalContent = '';
@@ -612,7 +779,7 @@ export const anthropicProvider = {
         timestamp: new Date().toISOString(),
         model: resolvedModel,
         provider: 'anthropic',
-        thinking_mode: modelConfig.supportsThinking && !!reasoning_effort
+        thinking_mode: modelConfig.supportsThinking && !!reasoning_effort,
       };
 
       // Enable streaming in request payload
@@ -634,7 +801,9 @@ export const anthropicProvider = {
 
           case 'content_block_start':
             // Content block started (text, thinking, etc.)
-            debugLog(`[Anthropic] Content block started: ${event.content_block?.type}`);
+            debugLog(
+              `[Anthropic] Content block started: ${event.content_block?.type}`,
+            );
             break;
 
           case 'content_block_delta':
@@ -646,7 +815,7 @@ export const anthropicProvider = {
                 yield {
                   type: 'delta',
                   content,
-                  timestamp: new Date().toISOString()
+                  timestamp: new Date().toISOString(),
                 };
               }
             } else if (event.delta?.type === 'thinking_delta') {
@@ -655,14 +824,18 @@ export const anthropicProvider = {
               if (thinking) {
                 thinkingContent += thinking;
                 // Optionally yield thinking deltas for debugging
-                debugLog(`[Anthropic] Thinking delta: ${thinking.substring(0, 100)}...`);
+                debugLog(
+                  `[Anthropic] Thinking delta: ${thinking.substring(0, 100)}...`,
+                );
               }
             }
             break;
 
           case 'content_block_stop':
             // Content block completed
-            debugLog(`[Anthropic] Content block stopped at index ${event.index}`);
+            debugLog(
+              `[Anthropic] Content block stopped at index ${event.index}`,
+            );
             break;
 
           case 'message_delta':
@@ -689,11 +862,13 @@ export const anthropicProvider = {
             throw new AnthropicProviderError(
               `Streaming error: ${event.error?.message || 'Unknown streaming error'}`,
               ErrorCodes.API_ERROR,
-              event.error
+              event.error,
             );
 
           default:
-            debugLog(`[Anthropic] Unknown streaming event type: ${event.type}`);
+            debugLog(
+              `[Anthropic] Unknown streaming event type: ${event.type}`,
+            );
             break;
           }
         } catch (eventError) {
@@ -703,9 +878,9 @@ export const anthropicProvider = {
             error: {
               message: `Event processing error: ${eventError.message}`,
               code: 'EVENT_PROCESSING_ERROR',
-              recoverable: true
+              recoverable: true,
             },
-            timestamp: new Date().toISOString()
+            timestamp: new Date().toISOString(),
           };
         }
       }
@@ -720,12 +895,14 @@ export const anthropicProvider = {
           usage: {
             input_tokens: lastUsage.input_tokens || 0,
             output_tokens: lastUsage.output_tokens || 0,
-            total_tokens: (lastUsage.input_tokens || 0) + (lastUsage.output_tokens || 0),
+            total_tokens:
+              (lastUsage.input_tokens || 0) + (lastUsage.output_tokens || 0),
             thinking_tokens: lastUsage.thinking_input_tokens || 0,
-            cache_creation_input_tokens: lastUsage.cache_creation_input_tokens || 0,
-            cache_read_input_tokens: lastUsage.cache_read_input_tokens || 0
+            cache_creation_input_tokens:
+              lastUsage.cache_creation_input_tokens || 0,
+            cache_read_input_tokens: lastUsage.cache_read_input_tokens || 0,
           },
-          timestamp: new Date().toISOString()
+          timestamp: new Date().toISOString(),
         };
       }
 
@@ -739,20 +916,23 @@ export const anthropicProvider = {
           usage: {
             input_tokens: lastUsage?.input_tokens || 0,
             output_tokens: lastUsage?.output_tokens || 0,
-            total_tokens: (lastUsage?.input_tokens || 0) + (lastUsage?.output_tokens || 0),
+            total_tokens:
+              (lastUsage?.input_tokens || 0) + (lastUsage?.output_tokens || 0),
             thinking_tokens: lastUsage?.thinking_input_tokens || 0,
-            cache_creation_input_tokens: lastUsage?.cache_creation_input_tokens || 0,
-            cache_read_input_tokens: lastUsage?.cache_read_input_tokens || 0
+            cache_creation_input_tokens:
+              lastUsage?.cache_creation_input_tokens || 0,
+            cache_read_input_tokens: lastUsage?.cache_read_input_tokens || 0,
           },
           response_time_ms: responseTime,
           finish_reason: finishReason,
           provider: 'anthropic',
-          reasoning_effort: modelConfig.supportsThinking ? reasoning_effort : null,
-          thinking_content: thinkingContent || null
+          reasoning_effort: modelConfig.supportsThinking
+            ? reasoning_effort
+            : null,
+          thinking_content: thinkingContent || null,
         },
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       };
-
     } catch (error) {
       debugError('[Anthropic] Streaming error:', error);
 
@@ -781,8 +961,11 @@ export const anthropicProvider = {
       } else if (error.error?.type === 'not_found_error') {
         errorCode = 'MODEL_NOT_FOUND';
         errorMessage = `Model ${resolvedModel} not found`;
-      } else if (error.message?.includes('context length') || error.message?.includes('context_length') ||
-                 (error.message?.includes('token') && error.message?.includes('limit'))) {
+      } else if (
+        error.message?.includes('context length') ||
+        error.message?.includes('context_length') ||
+        (error.message?.includes('token') && error.message?.includes('limit'))
+      ) {
         errorCode = 'CONTEXT_LENGTH_EXCEEDED';
         errorMessage = `Context length exceeded for model: ${error.message}`;
       }
@@ -793,9 +976,9 @@ export const anthropicProvider = {
           message: errorMessage,
           code: errorCode,
           recoverable,
-          originalError: error
+          originalError: error,
         },
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       };
 
       // Re-throw the error to maintain existing error handling behavior
@@ -809,7 +992,9 @@ export const anthropicProvider = {
    * @returns {boolean} - True if configuration is valid
    */
   validateConfig(config) {
-    return !!(config?.apiKeys?.anthropic && validateApiKey(config.apiKeys.anthropic));
+    return !!(
+      config?.apiKeys?.anthropic && validateApiKey(config.apiKeys.anthropic)
+    );
   },
 
   /**
@@ -837,6 +1022,5 @@ export const anthropicProvider = {
   getModelConfig(modelName) {
     const resolved = resolveModelName(modelName);
     return SUPPORTED_MODELS[resolved] || null;
-  }
+  },
 };
-