genai-lite 0.1.1 → 0.1.3

package/dist/llm/LLMService.test.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const LLMService_1 = require("./LLMService");
+describe('LLMService', () => {
+    let service;
+    let mockApiKeyProvider;
+    beforeEach(() => {
+        // Reset all mocks
+        jest.clearAllMocks();
+        // Create mock API key provider
+        mockApiKeyProvider = jest.fn(async (providerId) => `mock-key-for-${providerId}`);
+        // Create service instance
+        service = new LLMService_1.LLMService(mockApiKeyProvider);
+    });
+    describe('constructor and initialization', () => {
+        it('should initialize with the provided API key provider', () => {
+            expect(service).toBeDefined();
+            // The service should be ready to use
+        });
+        it('should lazy-load client adapters on first use', async () => {
+            mockApiKeyProvider.mockResolvedValueOnce('sk-test-key-12345678901234567890');
+            // First request should create the adapter
+            const request = {
+                providerId: 'openai',
+                modelId: 'gpt-4.1',
+                messages: [{ role: 'user', content: 'Hello' }]
+            };
+            await service.sendMessage(request);
+            // Verify API key provider was called
+            expect(mockApiKeyProvider).toHaveBeenCalledWith('openai');
+        });
+    });
+    describe('sendMessage', () => {
+        describe('request validation', () => {
+            it('should return validation error for unsupported provider', async () => {
+                const request = {
+                    providerId: 'unsupported-provider',
+                    modelId: 'some-model',
+                    messages: [{ role: 'user', content: 'Hello' }]
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('UNSUPPORTED_PROVIDER');
+                expect(errorResponse.error.message).toContain('Unsupported provider');
+            });
+            it('should return validation error for unsupported model', async () => {
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'unsupported-model',
+                    messages: [{ role: 'user', content: 'Hello' }]
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('UNSUPPORTED_MODEL');
+                expect(errorResponse.error.message).toContain('Unsupported model');
+            });
+            it('should return validation error for empty messages', async () => {
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: []
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('INVALID_REQUEST');
+                expect(errorResponse.error.message).toContain('Request must contain at least one message');
+            });
+            it('should return validation error for invalid message role', async () => {
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'invalid', content: 'Hello' }]
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('INVALID_MESSAGE_ROLE');
+                expect(errorResponse.error.message).toContain('Invalid message role');
+            });
+            it('should return validation error for empty message content', async () => {
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: '' }]
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('INVALID_MESSAGE');
+                expect(errorResponse.error.message).toContain('Message at index 0 must have both');
+            });
+        });
+        describe('API key handling', () => {
+            it('should return error when API key provider returns null', async () => {
+                mockApiKeyProvider.mockResolvedValueOnce(null);
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Hello' }]
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('API_KEY_ERROR');
+                expect(errorResponse.error.message).toContain('API key for provider');
+            });
+            it('should return error when API key provider throws', async () => {
+                mockApiKeyProvider.mockRejectedValueOnce(new Error('Key provider error'));
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Hello' }]
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('PROVIDER_ERROR');
+                expect(errorResponse.error.message).toContain('Key provider error');
+            });
+            it('should return error for invalid API key format', async () => {
+                mockApiKeyProvider.mockResolvedValueOnce('invalid-key');
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Hello' }]
+                };
+                const response = await service.sendMessage(request);
+                // OpenAI adapter expects keys starting with 'sk-'
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('INVALID_API_KEY');
+            });
+        });
+        describe('adapter routing', () => {
+            it('should route request to correct adapter based on provider', async () => {
+                mockApiKeyProvider.mockResolvedValueOnce('sk-test-key-12345678901234567890');
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Test routing' }]
+                };
+                const response = await service.sendMessage(request);
+                // This will fail with a network error since we're not mocking the actual API
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                // We should get a network error or similar since we're not mocking the HTTP request
+                expect(errorResponse.provider).toBe('openai');
+            });
+            it('should reuse existing adapter for same provider', async () => {
+                const request = {
+                    providerId: 'mock',
+                    modelId: 'mock-model',
+                    messages: [{ role: 'user', content: 'First request' }]
+                };
+                // First request
+                await service.sendMessage(request);
+                // Second request to same provider
+                request.messages = [{ role: 'user', content: 'Second request' }];
+                await service.sendMessage(request);
+                // API key provider should be called for each request with mock provider
+                expect(mockApiKeyProvider).toHaveBeenCalledTimes(0); // Mock provider doesn't need API keys
+            });
+        });
+        describe('settings management', () => {
+            it('should apply default settings when none provided', async () => {
+                mockApiKeyProvider.mockResolvedValueOnce('sk-test-key-12345678901234567890');
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Hello' }]
+                };
+                const response = await service.sendMessage(request);
+                // We'll get a network error but can still verify the request was attempted
+                expect(response.object).toBe('error');
+                expect(mockApiKeyProvider).toHaveBeenCalledWith('openai');
+            });
+            it('should merge user settings with defaults', async () => {
+                mockApiKeyProvider.mockResolvedValueOnce('sk-test-key-12345678901234567890');
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Hello' }],
+                    settings: {
+                        temperature: 0.9,
+                        maxTokens: 500
+                    }
+                };
+                const response = await service.sendMessage(request);
+                // We'll get a network error but the settings should still be validated
+                expect(response.object).toBe('error');
+            });
+            it('should validate temperature setting', async () => {
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Hello' }],
+                    settings: {
+                        temperature: 2.5 // Out of range
+                    }
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('INVALID_SETTINGS');
+                expect(errorResponse.error.message).toContain('temperature must be a number between');
+            });
+            it('should validate maxTokens setting', async () => {
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Hello' }],
+                    settings: {
+                        maxTokens: 0 // Invalid
+                    }
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('INVALID_SETTINGS');
+                expect(errorResponse.error.message).toContain('maxTokens must be an integer between');
+            });
+            it('should validate topP setting', async () => {
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Hello' }],
+                    settings: {
+                        topP: -0.1 // Out of range
+                    }
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('INVALID_SETTINGS');
+                expect(errorResponse.error.message).toContain('topP must be a number between 0 and 1');
+            });
+        });
+    });
+    describe('getProviders', () => {
+        it('should return all supported providers', async () => {
+            const providers = await service.getProviders();
+            expect(providers).toHaveLength(4);
+            expect(providers.find(p => p.id === 'openai')).toBeDefined();
+            expect(providers.find(p => p.id === 'anthropic')).toBeDefined();
+            expect(providers.find(p => p.id === 'gemini')).toBeDefined();
+            expect(providers.find(p => p.id === 'mistral')).toBeDefined();
+        });
+        it('should include provider metadata', async () => {
+            const providers = await service.getProviders();
+            const openai = providers.find(p => p.id === 'openai');
+            expect(openai).toMatchObject({
+                id: 'openai',
+                name: 'OpenAI'
+            });
+        });
+    });
+    describe('getModels', () => {
+        it('should return all models for a provider', async () => {
+            const models = await service.getModels('openai');
+            expect(models.length).toBeGreaterThan(0);
+            expect(models.some(m => m.id.includes('gpt-4'))).toBe(true);
+            expect(models.some(m => m.id.includes('o4-mini'))).toBe(true);
+        });
+        it('should return empty array for invalid provider', async () => {
+            const models = await service.getModels('invalid-provider');
+            expect(models).toEqual([]);
+        });
+        it('should include model metadata', async () => {
+            const models = await service.getModels('openai');
+            const gpt4 = models.find(m => m.id === 'gpt-4.1');
+            expect(gpt4).toBeDefined();
+            expect(gpt4.contextWindow).toBeGreaterThan(0);
+            expect(gpt4.maxTokens).toBeGreaterThan(0);
+        });
+    });
+});

package/dist/llm/clients/AnthropicClientAdapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/llm/clients/AnthropicClientAdapter.test.js

@@ -0,0 +1,263 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const AnthropicClientAdapter_1 = require("./AnthropicClientAdapter");
+const types_1 = require("./types");
+// Mock the entire '@anthropic-ai/sdk' module
+jest.mock('@anthropic-ai/sdk');
+// Cast the mocked module to allow setting up mock implementations
+const MockAnthropic = sdk_1.default;
+describe('AnthropicClientAdapter', () => {
+    let adapter;
+    let mockCreate;
+    let basicRequest;
+    beforeEach(() => {
+        // Reset mocks before each test
+        MockAnthropic.mockClear();
+        mockCreate = jest.fn();
+        // Mock the messages.create method
+        MockAnthropic.prototype.messages = {
+            create: mockCreate,
+        };
+        adapter = new AnthropicClientAdapter_1.AnthropicClientAdapter();
+        basicRequest = {
+            providerId: 'anthropic',
+            modelId: 'claude-3-5-sonnet-20241022',
+            messages: [{ role: 'user', content: 'Hello' }],
+            settings: {
+                temperature: 0.7,
+                maxTokens: 100,
+                topP: 1,
+                frequencyPenalty: 0,
+                presencePenalty: 0,
+                stopSequences: [],
+                user: 'test-user',
+                geminiSafetySettings: [],
+                supportsSystemMessage: true
+            }
+        };
+    });
+    describe('sendMessage', () => {
+        it('should format the request correctly and call the Anthropic API', async () => {
+            // Setup mock response
+            mockCreate.mockResolvedValueOnce({
+                id: 'msg_123',
+                type: 'message',
+                role: 'assistant',
+                model: 'claude-3-5-sonnet-20241022',
+                content: [{
+                        type: 'text',
+                        text: 'Hello! How can I help you today?'
+                    }],
+                stop_reason: 'end_turn',
+                stop_sequence: null,
+                usage: {
+                    input_tokens: 10,
+                    output_tokens: 20
+                }
+            });
+            const response = await adapter.sendMessage(basicRequest, 'test-api-key');
+            // Verify Anthropic was instantiated with the API key
+            expect(MockAnthropic).toHaveBeenCalledWith({
+                apiKey: 'test-api-key',
+                baseURL: undefined
+            });
+            // Verify the create method was called with correct parameters
+            expect(mockCreate).toHaveBeenCalledWith({
+                model: 'claude-3-5-sonnet-20241022',
+                messages: [{ role: 'user', content: 'Hello' }],
+                max_tokens: 100,
+                temperature: 0.7,
+                top_p: 1
+            });
+            // Verify the response
+            expect(response.object).toBe('chat.completion');
+            const successResponse = response;
+            expect(successResponse.id).toBe('msg_123');
+            expect(successResponse.provider).toBe('anthropic');
+            expect(successResponse.model).toBe('claude-3-5-sonnet-20241022');
+            expect(successResponse.choices[0].message.content).toBe('Hello! How can I help you today?');
+            expect(successResponse.usage?.total_tokens).toBe(30);
+        });
+        it('should handle system messages by merging into first user message', async () => {
+            basicRequest.messages = [
+                { role: 'system', content: 'You are a helpful assistant.' },
+                { role: 'user', content: 'Hello' }
+            ];
+            mockCreate.mockResolvedValueOnce({
+                id: 'msg_123',
+                type: 'message',
+                role: 'assistant',
+                model: 'claude-3-5-sonnet-20241022',
+                content: [{ type: 'text', text: 'Hello!' }],
+                stop_reason: 'end_turn',
+                usage: { input_tokens: 15, output_tokens: 5 }
+            });
+            await adapter.sendMessage(basicRequest, 'test-api-key');
+            // System message should be sent as separate system parameter
+            expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
+                system: 'You are a helpful assistant.',
+                messages: [{
+                        role: 'user',
+                        content: 'Hello'
+                    }]
+            }));
+        });
+        it('should handle stop sequences correctly', async () => {
+            basicRequest.settings.stopSequences = ['END', 'STOP'];
+            mockCreate.mockResolvedValueOnce({
+                id: 'msg_123',
+                type: 'message',
+                role: 'assistant',
+                model: 'claude-3-5-sonnet-20241022',
+                content: [{ type: 'text', text: 'Response' }],
+                stop_reason: 'end_turn',
+                usage: { input_tokens: 10, output_tokens: 10 }
+            });
+            await adapter.sendMessage(basicRequest, 'test-api-key');
+            expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
+                stop_sequences: ['END', 'STOP']
+            }));
+        });
+        it('should handle multi-turn conversations', async () => {
+            basicRequest.messages = [
+                { role: 'user', content: 'Hello' },
+                { role: 'assistant', content: 'Hi there!' },
+                { role: 'user', content: 'How are you?' }
+            ];
+            mockCreate.mockResolvedValueOnce({
+                id: 'msg_123',
+                type: 'message',
+                role: 'assistant',
+                model: 'claude-3-5-sonnet-20241022',
+                content: [{ type: 'text', text: "I'm doing well, thanks!" }],
+                stop_reason: 'end_turn',
+                usage: { input_tokens: 20, output_tokens: 10 }
+            });
+            await adapter.sendMessage(basicRequest, 'test-api-key');
+            expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
+                messages: [
+                    { role: 'user', content: 'Hello' },
+                    { role: 'assistant', content: 'Hi there!' },
+                    { role: 'user', content: 'How are you?' }
+                ]
+            }));
+        });
+        it('should map stop_reason correctly', async () => {
+            const stopReasons = [
+                { anthropic: 'end_turn', expected: 'stop' },
+                { anthropic: 'max_tokens', expected: 'length' },
+                { anthropic: 'stop_sequence', expected: 'stop' },
+                { anthropic: 'unknown_reason', expected: 'other' }
+            ];
+            for (const { anthropic, expected } of stopReasons) {
+                mockCreate.mockResolvedValueOnce({
+                    id: 'msg_123',
+                    type: 'message',
+                    role: 'assistant',
+                    model: 'claude-3-5-sonnet-20241022',
+                    content: [{ type: 'text', text: 'Response' }],
+                    stop_reason: anthropic,
+                    usage: { input_tokens: 10, output_tokens: 10 }
+                });
+                const response = await adapter.sendMessage(basicRequest, 'test-api-key');
+                const successResponse = response;
+                expect(successResponse.choices[0].finish_reason).toBe(expected);
+            }
+        });
+        describe('error handling', () => {
+            it('should handle authentication errors (401)', async () => {
+                const apiError = new Error('Invalid API key');
+                apiError.status = 401;
+                mockCreate.mockRejectedValueOnce(apiError);
+                const response = await adapter.sendMessage(basicRequest, 'invalid-key');
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.INVALID_API_KEY);
+                expect(errorResponse.error.type).toBe('authentication_error');
+            });
+            it('should handle rate limit errors (429)', async () => {
+                const apiError = new Error('Rate limit exceeded');
+                apiError.status = 429;
+                mockCreate.mockRejectedValueOnce(apiError);
+                const response = await adapter.sendMessage(basicRequest, 'test-key');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.RATE_LIMIT_EXCEEDED);
+                expect(errorResponse.error.type).toBe('rate_limit_error');
+            });
+            it('should handle context length errors', async () => {
+                // Create a mock error that simulates Anthropic.APIError
+                const apiError = Object.assign(new Error('Message is too long'), {
+                    status: 400,
+                    constructor: { name: 'APIError' }
+                });
+                Object.setPrototypeOf(apiError, sdk_1.default.APIError.prototype);
+                mockCreate.mockRejectedValueOnce(apiError);
+                const response = await adapter.sendMessage(basicRequest, 'test-key');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.CONTEXT_LENGTH_EXCEEDED);
+                expect(errorResponse.error.type).toBe('invalid_request_error');
+            });
+            it('should handle invalid model errors', async () => {
+                const apiError = new Error('Model not found');
+                apiError.status = 404;
+                mockCreate.mockRejectedValueOnce(apiError);
+                const response = await adapter.sendMessage(basicRequest, 'test-key');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.MODEL_NOT_FOUND);
+                expect(errorResponse.error.type).toBe('invalid_request_error');
+            });
+            it('should handle credit errors', async () => {
+                const apiError = new Error('Insufficient credits');
+                apiError.status = 402;
+                mockCreate.mockRejectedValueOnce(apiError);
+                const response = await adapter.sendMessage(basicRequest, 'test-key');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.INSUFFICIENT_CREDITS);
+                expect(errorResponse.error.type).toBe('rate_limit_error');
+            });
+            it('should handle server errors (500)', async () => {
+                const apiError = new Error('Internal server error');
+                apiError.status = 500;
+                mockCreate.mockRejectedValueOnce(apiError);
+                const response = await adapter.sendMessage(basicRequest, 'test-key');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR);
+                expect(errorResponse.error.type).toBe('server_error');
+            });
+            it('should handle network errors', async () => {
+                const networkError = new Error('Network error');
+                networkError.code = 'ENOTFOUND';
+                mockCreate.mockRejectedValueOnce(networkError);
+                const response = await adapter.sendMessage(basicRequest, 'test-key');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.NETWORK_ERROR);
+                expect(errorResponse.error.type).toBe('connection_error');
+            });
+        });
+    });
+    describe('validateApiKey', () => {
+        it('should validate API key format', () => {
+            // Valid Anthropic API key format - must start with 'sk-ant-' and be at least 30 chars
+            expect(adapter.validateApiKey('sk-ant-api01-test123456789012345')).toBe(true);
+            expect(adapter.validateApiKey('sk-ant-api03-test123456789012345')).toBe(true);
+            // Invalid formats
+            expect(adapter.validateApiKey('invalid')).toBe(false);
+            expect(adapter.validateApiKey('')).toBe(false);
+            expect(adapter.validateApiKey('sk-test')).toBe(false); // OpenAI format
+            expect(adapter.validateApiKey('sk-ant-test123')).toBe(false); // Too short
+        });
+    });
+    describe('getAdapterInfo', () => {
+        it('should return correct adapter information', () => {
+            const info = adapter.getAdapterInfo();
+            expect(info.providerId).toBe('anthropic');
+            expect(info.name).toBe('Anthropic Client Adapter');
+            expect(info.version).toBeDefined();
+            // supportedModels is not part of the interface
+        });
+    });
+});

package/dist/llm/clients/GeminiClientAdapter.test.d.ts

@@ -0,0 +1 @@
+export {};