@bernierllc/ai-provider-anthropic 1.0.0

package/__tests__/error-handling.test.ts

@@ -0,0 +1,208 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code only within the scope of the project it was delivered for.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import Anthropic from '@anthropic-ai/sdk';
+import { handleAnthropicError, isRetryableError, getRetryDelay } from '../src/utils/error-handling';
+
+describe('Error Handling', () => {
+  describe('handleAnthropicError', () => {
+    it('should handle Anthropic APIError', () => {
+      const apiError = Object.assign(
+        new Error('API Error'),
+        {
+          status: 500,
+          headers: {}
+        }
+      );
+      Object.setPrototypeOf(apiError, Anthropic.APIError.prototype);
+
+      const result = handleAnthropicError(apiError);
+
+      expect(result.message).toContain('Anthropic API Error');
+      expect(result.message).toContain('500');
+      expect(result.name).toBe('AnthropicAPIError');
+    });
+
+    it('should handle Anthropic AuthenticationError', () => {
+      const authError = new Anthropic.AuthenticationError(
+        401,
+        { error: { message: 'Invalid API key' }, type: 'error' },
+        'Invalid API key',
+        {}
+      );
+
+      const result = handleAnthropicError(authError);
+
+      // AuthenticationError extends APIError, so it's caught by APIError handler
+      expect(result.message).toContain('Anthropic API Error');
+      expect(result.message).toContain('401');
+      expect(result.name).toBe('AnthropicAPIError');
+    });
+
+    it('should handle Anthropic RateLimitError', () => {
+      const rateLimitError = new Anthropic.RateLimitError(
+        429,
+        { error: { message: 'Rate limit exceeded' }, type: 'error' },
+        'Rate limit exceeded',
+        {}
+      );
+
+      const result = handleAnthropicError(rateLimitError);
+
+      // RateLimitError extends APIError, so it's caught by APIError handler
+      expect(result.message).toContain('Anthropic API Error');
+      expect(result.message).toContain('429');
+      expect(result.name).toBe('AnthropicAPIError');
+    });
+
+    it('should handle generic Error', () => {
+      const error = new Error('Generic error');
+
+      const result = handleAnthropicError(error);
+
+      expect(result).toBe(error);
+    });
+
+    it('should handle unknown error types', () => {
+      const result = handleAnthropicError('string error');
+
+      expect(result.message).toContain('Unknown Anthropic error');
+      expect(result.message).toContain('string error');
+    });
+
+    it('should handle null error', () => {
+      const result = handleAnthropicError(null);
+
+      expect(result.message).toContain('Unknown Anthropic error');
+    });
+  });
+
+  describe('isRetryableError', () => {
+    it('should identify 5xx errors as retryable', () => {
+      const error = Object.assign(
+        new Error('Server error'),
+        {
+          status: 500,
+          headers: {}
+        }
+      );
+      Object.setPrototypeOf(error, Anthropic.APIError.prototype);
+
+      expect(isRetryableError(error)).toBe(true);
+    });
+
+    it('should identify 429 as retryable', () => {
+      const error = Object.assign(
+        new Error('Rate limit'),
+        {
+          status: 429,
+          headers: {}
+        }
+      );
+      Object.setPrototypeOf(error, Anthropic.APIError.prototype);
+
+      expect(isRetryableError(error)).toBe(true);
+    });
+
+    it('should identify RateLimitError as retryable', () => {
+      const error = new Anthropic.RateLimitError(
+        429,
+        { error: { message: 'Rate limit' }, type: 'error' },
+        'Rate limit',
+        {}
+      );
+
+      expect(isRetryableError(error)).toBe(true);
+    });
+
+    it('should not retry 4xx errors (except 429)', () => {
+      const error = Object.assign(
+        new Error('Bad request'),
+        {
+          status: 400,
+          headers: {}
+        }
+      );
+      Object.setPrototypeOf(error, Anthropic.APIError.prototype);
+
+      expect(isRetryableError(error)).toBe(false);
+    });
+
+    it('should not retry non-API errors', () => {
+      const error = new Error('Generic error');
+
+      expect(isRetryableError(error)).toBe(false);
+    });
+
+    it('should not retry unknown errors', () => {
+      expect(isRetryableError('string error')).toBe(false);
+      expect(isRetryableError(null)).toBe(false);
+    });
+  });
+
+  describe('getRetryDelay', () => {
+    it('should return 1000ms for RateLimitError', () => {
+      const error = new Anthropic.RateLimitError(
+        429,
+        { error: { message: 'Rate limit' }, type: 'error' },
+        'Rate limit',
+        {}
+      );
+
+      const delay = getRetryDelay(error);
+
+      expect(delay).toBe(1000);
+    });
+
+    it('should return undefined for non-rate-limit errors', () => {
+      const error = Object.assign(
+        new Error('Server error'),
+        {
+          status: 500,
+          headers: {}
+        }
+      );
+      Object.setPrototypeOf(error, Anthropic.APIError.prototype);
+
+      const delay = getRetryDelay(error);
+
+      expect(delay).toBeUndefined();
+    });
+
+    it('should return undefined for generic errors', () => {
+      const error = new Error('Generic error');
+
+      const delay = getRetryDelay(error);
+
+      expect(delay).toBeUndefined();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle APIError with no status', () => {
+      const error = new Error('API Error');
+      Object.setPrototypeOf(error, Anthropic.APIError.prototype);
+
+      const result = handleAnthropicError(error);
+      expect(result.message).toContain('unknown');
+    });
+
+    it('should handle 503 as retryable', () => {
+      const error = Object.assign(
+        new Error('Service unavailable'),
+        {
+          status: 503,
+          headers: {}
+        }
+      );
+      Object.setPrototypeOf(error, Anthropic.APIError.prototype);
+
+      expect(isRetryableError(error)).toBe(true);
+    });
+  });
+});

package/__tests__/message-conversion.test.ts

@@ -0,0 +1,161 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code only within the scope of the project it was delivered for.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { convertMessagesToAnthropicFormat, validateMessages } from '../src/utils/message-conversion';
+import { Message } from '@bernierllc/ai-provider-core';
+
+describe('Message Conversion', () => {
+  describe('convertMessagesToAnthropicFormat', () => {
+    it('should extract system messages separately', () => {
+      const messages: Message[] = [
+        { role: 'system', content: 'You are a helpful assistant.' },
+        { role: 'user', content: 'Hello!' }
+      ];
+
+      const result = convertMessagesToAnthropicFormat(messages);
+
+      expect(result.system).toBe('You are a helpful assistant.');
+      expect(result.messages).toHaveLength(1);
+      expect(result.messages[0].role).toBe('user');
+      expect(result.messages[0].content).toBe('Hello!');
+    });
+
+    it('should handle multiple system messages', () => {
+      const messages: Message[] = [
+        { role: 'system', content: 'First instruction.' },
+        { role: 'system', content: 'Second instruction.' },
+        { role: 'user', content: 'Hello!' }
+      ];
+
+      const result = convertMessagesToAnthropicFormat(messages);
+
+      expect(result.system).toBe('First instruction.\n\nSecond instruction.');
+      expect(result.messages).toHaveLength(1);
+    });
+
+    it('should return undefined system when no system messages', () => {
+      const messages: Message[] = [
+        { role: 'user', content: 'Hello!' },
+        { role: 'assistant', content: 'Hi there!' }
+      ];
+
+      const result = convertMessagesToAnthropicFormat(messages);
+
+      expect(result.system).toBeUndefined();
+      expect(result.messages).toHaveLength(2);
+    });
+
+    it('should convert assistant and user roles correctly', () => {
+      const messages: Message[] = [
+        { role: 'user', content: 'Question?' },
+        { role: 'assistant', content: 'Answer!' }
+      ];
+
+      const result = convertMessagesToAnthropicFormat(messages);
+
+      expect(result.messages[0].role).toBe('user');
+      expect(result.messages[1].role).toBe('assistant');
+    });
+
+    it('should convert function role to user role', () => {
+      const messages: Message[] = [
+        { role: 'function', content: 'Function result' }
+      ];
+
+      const result = convertMessagesToAnthropicFormat(messages);
+
+      expect(result.messages[0].role).toBe('user');
+      expect(result.messages[0].content).toBe('Function result');
+    });
+
+    it('should handle empty messages array', () => {
+      const messages: Message[] = [];
+
+      const result = convertMessagesToAnthropicFormat(messages);
+
+      expect(result.system).toBeUndefined();
+      expect(result.messages).toHaveLength(0);
+    });
+  });
+
+  describe('validateMessages', () => {
+    it('should validate correct messages', () => {
+      const messages: Message[] = [
+        { role: 'user', content: 'Hello!' }
+      ];
+
+      const result = validateMessages(messages);
+
+      expect(result.isValid).toBe(true);
+    });
+
+    it('should reject empty messages array', () => {
+      const messages: Message[] = [];
+
+      const result = validateMessages(messages);
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('cannot be empty');
+    });
+
+    it('should reject messages without role', () => {
+      const messages = [
+        { content: 'Hello!' }
+      ] as unknown as Message[];
+
+      const result = validateMessages(messages);
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('role and content');
+    });
+
+    it('should reject messages without content', () => {
+      const messages = [
+        { role: 'user' }
+      ] as unknown as Message[];
+
+      const result = validateMessages(messages);
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('role and content');
+    });
+
+    it('should reject messages with invalid role', () => {
+      const messages = [
+        { role: 'invalid', content: 'Hello!' }
+      ] as unknown as Message[];
+
+      const result = validateMessages(messages);
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('Invalid message role');
+    });
+
+    it('should require at least one non-system message', () => {
+      const messages: Message[] = [
+        { role: 'system', content: 'System instruction' }
+      ];
+
+      const result = validateMessages(messages);
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('non-system message');
+    });
+
+    it('should allow system message with user message', () => {
+      const messages: Message[] = [
+        { role: 'system', content: 'System instruction' },
+        { role: 'user', content: 'Hello!' }
+      ];
+
+      const result = validateMessages(messages);
+
+      expect(result.isValid).toBe(true);
+    });
+  });
+});

package/__tests__/model-registry.test.ts

@@ -0,0 +1,150 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code only within the scope of the project it was delivered for.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { ClaudeModelRegistry } from '../src/models/model-registry';
+
+describe('ClaudeModelRegistry', () => {
+  describe('getAllModels', () => {
+    it('should return all Claude 3 models', () => {
+      const models = ClaudeModelRegistry.getAllModels();
+
+      expect(models).toHaveLength(3);
+      expect(models.map(m => m.name)).toEqual([
+        'Claude 3 Opus',
+        'Claude 3 Sonnet',
+        'Claude 3 Haiku'
+      ]);
+    });
+
+    it('should include model capabilities', () => {
+      const models = ClaudeModelRegistry.getAllModels();
+      const opus = models.find(m => m.id === 'claude-3-opus-20240229');
+
+      expect(opus?.capabilities).toContain('chat');
+      expect(opus?.capabilities).toContain('completion');
+      expect(opus?.capabilities).toContain('vision');
+      expect(opus?.capabilities).toContain('extended-context');
+      expect(opus?.capabilities).toContain('analysis');
+    });
+
+    it('should include pricing information', () => {
+      const models = ClaudeModelRegistry.getAllModels();
+
+      models.forEach(model => {
+        expect(model.pricing).toBeDefined();
+        expect(model.pricing?.inputPricePerToken).toBeGreaterThan(0);
+        expect(model.pricing?.outputPricePerToken).toBeGreaterThan(0);
+        expect(model.pricing?.currency).toBe('USD');
+      });
+    });
+
+    it('should have 200K context window for all models', () => {
+      const models = ClaudeModelRegistry.getAllModels();
+
+      models.forEach(model => {
+        expect(model.contextWindow).toBe(200000);
+      });
+    });
+
+    it('should have 4096 max output tokens for all models', () => {
+      const models = ClaudeModelRegistry.getAllModels();
+
+      models.forEach(model => {
+        expect(model.maxOutputTokens).toBe(4096);
+      });
+    });
+  });
+
+  describe('getModel', () => {
+    it('should return specific model by ID', () => {
+      const opus = ClaudeModelRegistry.getModel('claude-3-opus-20240229');
+
+      expect(opus).toBeDefined();
+      expect(opus?.name).toBe('Claude 3 Opus');
+    });
+
+    it('should return undefined for unknown model ID', () => {
+      const unknown = ClaudeModelRegistry.getModel('unknown-model');
+
+      expect(unknown).toBeUndefined();
+    });
+
+    it('should return correct model info', () => {
+      const sonnet = ClaudeModelRegistry.getModel('claude-3-sonnet-20240229');
+
+      expect(sonnet).toBeDefined();
+      expect(sonnet?.id).toBe('claude-3-sonnet-20240229');
+      expect(sonnet?.name).toBe('Claude 3 Sonnet');
+      expect(sonnet?.description).toContain('Balanced');
+    });
+  });
+
+  describe('isValidModel', () => {
+    it('should return true for valid model IDs', () => {
+      expect(ClaudeModelRegistry.isValidModel('claude-3-opus-20240229')).toBe(true);
+      expect(ClaudeModelRegistry.isValidModel('claude-3-sonnet-20240229')).toBe(true);
+      expect(ClaudeModelRegistry.isValidModel('claude-3-haiku-20240307')).toBe(true);
+    });
+
+    it('should return false for invalid model IDs', () => {
+      expect(ClaudeModelRegistry.isValidModel('unknown-model')).toBe(false);
+      expect(ClaudeModelRegistry.isValidModel('')).toBe(false);
+    });
+  });
+
+  describe('getModelPricing', () => {
+    it('should return correct pricing for Opus', () => {
+      const pricing = ClaudeModelRegistry.getModelPricing('claude-3-opus-20240229');
+
+      expect(pricing.inputPrice).toBe(15);
+      expect(pricing.outputPrice).toBe(75);
+    });
+
+    it('should return correct pricing for Sonnet', () => {
+      const pricing = ClaudeModelRegistry.getModelPricing('claude-3-sonnet-20240229');
+
+      expect(pricing.inputPrice).toBe(3);
+      expect(pricing.outputPrice).toBe(15);
+    });
+
+    it('should return correct pricing for Haiku', () => {
+      const pricing = ClaudeModelRegistry.getModelPricing('claude-3-haiku-20240307');
+
+      expect(pricing.inputPrice).toBe(0.25);
+      expect(pricing.outputPrice).toBe(1.25);
+    });
+
+    it('should return default pricing for unknown model', () => {
+      const pricing = ClaudeModelRegistry.getModelPricing('unknown-model');
+
+      expect(pricing.inputPrice).toBe(3); // Sonnet default
+      expect(pricing.outputPrice).toBe(15);
+    });
+  });
+
+  describe('pricing comparison', () => {
+    it('should have Opus as most expensive', () => {
+      const opus = ClaudeModelRegistry.getModelPricing('claude-3-opus-20240229');
+      const sonnet = ClaudeModelRegistry.getModelPricing('claude-3-sonnet-20240229');
+      const haiku = ClaudeModelRegistry.getModelPricing('claude-3-haiku-20240307');
+
+      expect(opus.inputPrice).toBeGreaterThan(sonnet.inputPrice);
+      expect(opus.inputPrice).toBeGreaterThan(haiku.inputPrice);
+      expect(opus.outputPrice).toBeGreaterThan(sonnet.outputPrice);
+      expect(opus.outputPrice).toBeGreaterThan(haiku.outputPrice);
+    });
+
+    it('should have Haiku as least expensive', () => {
+      const sonnet = ClaudeModelRegistry.getModelPricing('claude-3-sonnet-20240229');
+      const haiku = ClaudeModelRegistry.getModelPricing('claude-3-haiku-20240307');
+
+      expect(haiku.inputPrice).toBeLessThan(sonnet.inputPrice);
+      expect(haiku.outputPrice).toBeLessThan(sonnet.outputPrice);
+    });
+  });
+});

package/dist/AnthropicProvider.d.ts

@@ -0,0 +1,54 @@
+import { AIProvider, CompletionRequest, CompletionResponse, StreamChunk, EmbeddingRequest, EmbeddingResponse, ModerationResponse, ModelInfo, HealthStatus, CostEstimate } from '@bernierllc/ai-provider-core';
+import { AnthropicProviderConfig } from './types';
+/**
+ * Anthropic Provider Implementation
+ * Concrete implementation of the AI provider interface for Anthropic's Claude API
+ */
+export declare class AnthropicProvider extends AIProvider {
+    private client;
+    constructor(config: AnthropicProviderConfig);
+    /**
+     * Generate text completion using Anthropic Claude API
+     */
+    complete(request: CompletionRequest): Promise<CompletionResponse>;
+    /**
+     * Generate streaming text completion
+     */
+    streamComplete(request: CompletionRequest): AsyncGenerator<StreamChunk, void, unknown>;
+    /**
+     * Generate embeddings (Anthropic doesn't provide embeddings API)
+     * Returns error indicating feature not supported
+     */
+    generateEmbeddings(_request: EmbeddingRequest): Promise<EmbeddingResponse>;
+    /**
+     * Check content moderation (Anthropic doesn't provide moderation API)
+     * Returns success with no flags (Claude has built-in safety)
+     */
+    moderate(_content: string): Promise<ModerationResponse>;
+    /**
+     * Get available Anthropic models
+     */
+    getAvailableModels(): Promise<ModelInfo[]>;
+    /**
+     * Check Anthropic API health
+     */
+    checkHealth(): Promise<HealthStatus>;
+    /**
+     * Extended context completion (200K tokens for all Claude 3 models)
+     */
+    extendedContextCompletion(request: CompletionRequest & {
+        enableExtendedContext?: boolean;
+    }): Promise<CompletionResponse>;
+    /**
+     * Vision analysis (All Claude 3 models support vision)
+     */
+    analyzeImage(imageData: string | Buffer, prompt: string, model?: string, maxTokens?: number, temperature?: number): Promise<CompletionResponse>;
+    /**
+     * Estimate cost using Anthropic pricing
+     */
+    estimateCost(request: CompletionRequest): CostEstimate;
+    /**
+     * Map Anthropic stop reason to unified format
+     */
+    private mapStopReason;
+}