@bernierllc/ai-provider-anthropic 1.0.0

package/__tests__/AnthropicProvider.test.ts

@@ -0,0 +1,655 @@
+/*
+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 { AnthropicProvider } from '../src/AnthropicProvider';
+import Anthropic from '@anthropic-ai/sdk';
+
+// Mock the Anthropic SDK
+jest.mock('@anthropic-ai/sdk');
+
+describe('AnthropicProvider', () => {
+  let provider: AnthropicProvider;
+  let mockCreate: jest.Mock;
+  let mockStream: jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Create mock functions
+    mockCreate = jest.fn();
+    mockStream = jest.fn();
+
+    // Mock the Anthropic constructor
+    (Anthropic as jest.MockedClass<typeof Anthropic>).mockImplementation(() => {
+      return {
+        messages: {
+          create: mockCreate,
+          stream: mockStream
+        }
+      } as unknown as Anthropic;
+    });
+
+    provider = new AnthropicProvider({
+      providerName: 'anthropic',
+      apiKey: 'test-api-key',
+      defaultModel: 'claude-3-opus-20240229'
+    });
+  });
+
+  describe('constructor', () => {
+    it('should create provider with config', () => {
+      expect(provider).toBeDefined();
+      expect(provider.getProviderName()).toBe('anthropic');
+    });
+
+    it('should initialize Anthropic client', () => {
+      expect(Anthropic).toHaveBeenCalledWith({
+        apiKey: 'test-api-key',
+        baseURL: undefined,
+        timeout: 60000,
+        maxRetries: 3
+      });
+    });
+
+    it('should use custom timeout and retries', () => {
+      new AnthropicProvider({
+        providerName: 'anthropic',
+        apiKey: 'test-key',
+        timeout: 30000,
+        maxRetries: 5
+      });
+
+      expect(Anthropic).toHaveBeenCalledWith(
+        expect.objectContaining({
+          timeout: 30000,
+          maxRetries: 5
+        })
+      );
+    });
+  });
+
+  describe('complete', () => {
+    it('should generate text completion successfully', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-opus-20240229',
+        content: [
+          { type: 'text', text: 'Hello! How can I help you?' }
+        ],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: {
+          input_tokens: 10,
+          output_tokens: 20
+        }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      const result = await provider.complete({
+        messages: [
+          { role: 'user', content: 'Hello!' }
+        ]
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.content).toBe('Hello! How can I help you?');
+      expect(result.usage).toEqual({
+        promptTokens: 10,
+        completionTokens: 20,
+        totalTokens: 30
+      });
+      expect(result.finishReason).toBe('stop');
+    });
+
+    it('should handle system messages correctly', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-opus-20240229',
+        content: [{ type: 'text', text: 'Response' }],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: { input_tokens: 10, output_tokens: 5 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      await provider.complete({
+        messages: [
+          { role: 'system', content: 'You are helpful.' },
+          { role: 'user', content: 'Hello!' }
+        ]
+      });
+
+      expect(mockCreate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          system: 'You are helpful.',
+          messages: [{ role: 'user', content: 'Hello!' }]
+        })
+      );
+    });
+
+    it('should use custom parameters', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-sonnet-20240229',
+        content: [{ type: 'text', text: 'Response' }],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: { input_tokens: 10, output_tokens: 5 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      await provider.complete({
+        messages: [{ role: 'user', content: 'Test' }],
+        model: 'claude-3-sonnet-20240229',
+        maxTokens: 1000,
+        temperature: 0.7,
+        topP: 0.9,
+        stop: ['STOP']
+      });
+
+      expect(mockCreate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          model: 'claude-3-sonnet-20240229',
+          max_tokens: 1000,
+          temperature: 0.7,
+          top_p: 0.9,
+          stop_sequences: ['STOP']
+        })
+      );
+    });
+
+    it('should handle max_tokens stop reason', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-opus-20240229',
+        content: [{ type: 'text', text: 'Response' }],
+        stop_reason: 'max_tokens',
+        stop_sequence: null,
+        usage: { input_tokens: 10, output_tokens: 100 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      const result = await provider.complete({
+        messages: [{ role: 'user', content: 'Test' }]
+      });
+
+      expect(result.finishReason).toBe('length');
+    });
+
+    it('should return error on API failure', async () => {
+      const apiError = Object.assign(
+        new Error('Server error'),
+        {
+          status: 500,
+          headers: {}
+        }
+      );
+      // Make it look like an Anthropic.APIError
+      Object.setPrototypeOf(apiError, Anthropic.APIError.prototype);
+
+      mockCreate.mockRejectedValue(apiError);
+
+      const result = await provider.complete({
+        messages: [{ role: 'user', content: 'Test' }]
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Anthropic API Error');
+    });
+
+    it('should return error for empty messages', async () => {
+      const result = await provider.complete({
+        messages: []
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('cannot be empty');
+    });
+
+    it('should handle multiple content blocks', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-opus-20240229',
+        content: [
+          { type: 'text', text: 'First part. ' },
+          { type: 'text', text: 'Second part.' }
+        ],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: { input_tokens: 10, output_tokens: 20 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      const result = await provider.complete({
+        messages: [{ role: 'user', content: 'Test' }]
+      });
+
+      expect(result.content).toBe('First part. Second part.');
+    });
+  });
+
+  describe('streamComplete', () => {
+    it('should stream completion chunks', async () => {
+      const mockEvents = [
+        { type: 'content_block_delta', delta: { type: 'text_delta', text: 'Hello ' } },
+        { type: 'content_block_delta', delta: { type: 'text_delta', text: 'world!' } },
+        { type: 'message_delta', usage: { input_tokens: 10, output_tokens: 20 } },
+        { type: 'message_stop' }
+      ];
+
+      const mockStreamObj = {
+        [Symbol.asyncIterator]: async function* () {
+          for (const event of mockEvents) {
+            yield event;
+          }
+        }
+      };
+
+      mockStream.mockReturnValue(mockStreamObj as never);
+
+      const chunks: string[] = [];
+      for await (const chunk of provider.streamComplete({
+        messages: [{ role: 'user', content: 'Test' }]
+      })) {
+        if (chunk.delta) {
+          chunks.push(chunk.delta);
+        }
+        if (chunk.finishReason) {
+          expect(chunk.finishReason).toBe('stop');
+          expect(chunk.usage?.totalTokens).toBe(30);
+        }
+      }
+
+      expect(chunks.join('')).toBe('Hello world!');
+    });
+
+    it('should throw error for invalid messages', async () => {
+      await expect(async () => {
+        for await (const _ of provider.streamComplete({ messages: [] })) {
+          // Should not reach here
+        }
+      }).rejects.toThrow('cannot be empty');
+    });
+
+    it('should handle streaming errors', async () => {
+      const error = new Anthropic.APIError(
+        429,
+        { error: { message: 'Rate limit' }, type: 'error' },
+        'Rate limit',
+        {}
+      );
+
+      const errorStream = {
+        [Symbol.asyncIterator]: async function* () {
+          throw error;
+        }
+      };
+
+      mockStream.mockReturnValue(errorStream as never);
+
+      await expect(async () => {
+        for await (const _ of provider.streamComplete({
+          messages: [{ role: 'user', content: 'Test' }]
+        })) {
+          // Should not reach here
+        }
+      }).rejects.toThrow();
+    });
+  });
+
+  describe('generateEmbeddings', () => {
+    it('should return error indicating not supported', async () => {
+      const result = await provider.generateEmbeddings({
+        input: 'Test text'
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('does not provide an embeddings API');
+      expect(result.error).toContain('OpenAI');
+    });
+  });
+
+  describe('moderate', () => {
+    it('should return success with no flags', async () => {
+      const result = await provider.moderate('Test content');
+
+      expect(result.success).toBe(true);
+      expect(result.flagged).toBe(false);
+      expect(result.categories).toEqual({});
+      expect(result.categoryScores).toEqual({});
+    });
+  });
+
+  describe('getAvailableModels', () => {
+    it('should return all Claude models', async () => {
+      const models = await provider.getAvailableModels();
+
+      expect(models).toHaveLength(3);
+      expect(models.map(m => m.name)).toContain('Claude 3 Opus');
+      expect(models.map(m => m.name)).toContain('Claude 3 Sonnet');
+      expect(models.map(m => m.name)).toContain('Claude 3 Haiku');
+    });
+  });
+
+  describe('checkHealth', () => {
+    it('should return healthy status on success', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-haiku-20240307',
+        content: [{ type: 'text', text: 'Hi' }],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: { input_tokens: 5, output_tokens: 5 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      const health = await provider.checkHealth();
+
+      expect(health.status).toBe('healthy');
+      expect(health.latency).toBeGreaterThanOrEqual(0);
+      expect(health.lastChecked).toBeInstanceOf(Date);
+    });
+
+    it('should return unavailable on failure', async () => {
+      mockCreate.mockRejectedValue(new Error('Network error'));
+
+      const health = await provider.checkHealth();
+
+      expect(health.status).toBe('unavailable');
+      expect(health.details?.error).toContain('Network error');
+    });
+  });
+
+  describe('analyzeImage', () => {
+    it('should analyze image from buffer', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-opus-20240229',
+        content: [{ type: 'text', text: 'Image analysis result' }],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: { input_tokens: 100, output_tokens: 50 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      const imageBuffer = Buffer.from('fake-image-data');
+      const result = await provider.analyzeImage(imageBuffer, 'Describe this image');
+
+      expect(result.success).toBe(true);
+      expect(result.content).toBe('Image analysis result');
+    });
+
+    it('should analyze image from base64 string', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-opus-20240229',
+        content: [{ type: 'text', text: 'Image description' }],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: { input_tokens: 100, output_tokens: 50 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      const result = await provider.analyzeImage('base64data', 'What is this?');
+
+      expect(result.success).toBe(true);
+      expect(mockCreate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          messages: expect.arrayContaining([
+            expect.objectContaining({
+              content: expect.arrayContaining([
+                expect.objectContaining({
+                  type: 'image',
+                  source: expect.objectContaining({
+                    type: 'base64',
+                    data: 'base64data'
+                  })
+                }),
+                expect.objectContaining({
+                  type: 'text',
+                  text: 'What is this?'
+                })
+              ])
+            })
+          ])
+        })
+      );
+    });
+
+    it('should use custom model and parameters', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-sonnet-20240229',
+        content: [{ type: 'text', text: 'Analysis' }],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: { input_tokens: 100, output_tokens: 50 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      await provider.analyzeImage(
+        'imagedata',
+        'Analyze',
+        'claude-3-sonnet-20240229',
+        2000,
+        0.5
+      );
+
+      expect(mockCreate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          model: 'claude-3-sonnet-20240229',
+          max_tokens: 2000,
+          temperature: 0.5
+        })
+      );
+    });
+  });
+
+  describe('extendedContextCompletion', () => {
+    it('should handle extended context requests', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-opus-20240229',
+        content: [{ type: 'text', text: 'Summary of long document' }],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: { input_tokens: 50000, output_tokens: 500 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      const result = await provider.extendedContextCompletion({
+        messages: [{ role: 'user', content: 'Long document...' }],
+        enableExtendedContext: true
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.usage?.promptTokens).toBe(50000);
+    });
+  });
+
+  describe('estimateCost', () => {
+    it('should estimate cost for Opus', () => {
+      const cost = provider.estimateCost({
+        messages: [{ role: 'user', content: 'Hello world!' }],
+        model: 'claude-3-opus-20240229',
+        maxTokens: 100
+      });
+
+      expect(cost.estimatedCostUSD).toBeGreaterThan(0);
+      expect(cost.currency).toBe('USD');
+      expect(cost.inputTokens).toBeGreaterThan(0);
+      expect(cost.outputTokens).toBe(100);
+    });
+
+    it('should use default model if not specified', () => {
+      const cost = provider.estimateCost({
+        messages: [{ role: 'user', content: 'Test' }],
+        maxTokens: 100
+      });
+
+      expect(cost.estimatedCostUSD).toBeGreaterThan(0);
+    });
+
+    it('should calculate different costs for different models', () => {
+      const opusCost = provider.estimateCost({
+        messages: [{ role: 'user', content: 'Test' }],
+        model: 'claude-3-opus-20240229',
+        maxTokens: 100
+      });
+
+      const haikuCost = provider.estimateCost({
+        messages: [{ role: 'user', content: 'Test' }],
+        model: 'claude-3-haiku-20240307',
+        maxTokens: 100
+      });
+
+      // Opus should be more expensive
+      expect(opusCost.estimatedCostUSD).toBeGreaterThan(haikuCost.estimatedCostUSD);
+    });
+  });
+
+  describe('isAvailable', () => {
+    it('should return true when healthy', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-haiku-20240307',
+        content: [{ type: 'text', text: 'Hi' }],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: { input_tokens: 5, output_tokens: 5 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      const available = await provider.isAvailable();
+      expect(available).toBe(true);
+    });
+
+    it('should return false when unavailable', async () => {
+      mockCreate.mockRejectedValue(new Error('Network error'));
+
+      const available = await provider.isAvailable();
+      expect(available).toBe(false);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle undefined stop reason', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-opus-20240229',
+        content: [{ type: 'text', text: 'Response' }],
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 10, output_tokens: 5 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      const result = await provider.complete({
+        messages: [{ role: 'user', content: 'Test' }]
+      });
+
+      expect(result.finishReason).toBe('stop');
+    });
+
+    it('should handle stop_sequence stop reason', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-opus-20240229',
+        content: [{ type: 'text', text: 'Response STOP' }],
+        stop_reason: 'stop_sequence',
+        stop_sequence: 'STOP',
+        usage: { input_tokens: 10, output_tokens: 10 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      const result = await provider.complete({
+        messages: [{ role: 'user', content: 'Test' }],
+        stop: ['STOP']
+      });
+
+      expect(result.finishReason).toBe('stop');
+      expect(result.metadata?.stopSequence).toBe('STOP');
+    });
+
+    it('should filter out non-text content blocks', async () => {
+      const mockResponse = {
+        id: 'msg_123',
+        type: 'message',
+        role: 'assistant',
+        model: 'claude-3-opus-20240229',
+        content: [
+          { type: 'text', text: 'Text content' },
+          { type: 'other', data: 'should be ignored' }
+        ],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: { input_tokens: 10, output_tokens: 10 }
+      };
+
+      mockCreate.mockResolvedValue(mockResponse as unknown as Anthropic.Message);
+
+      const result = await provider.complete({
+        messages: [{ role: 'user', content: 'Test' }]
+      });
+
+      expect(result.content).toBe('Text content');
+    });
+
+    it('should handle analyzeImage error', async () => {
+      const error = new Error('Vision API error');
+      mockCreate.mockRejectedValue(error);
+
+      const result = await provider.analyzeImage(
+        'imagedata',
+        'Analyze this'
+      );
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Vision API error');
+    });
+  });
+});