genai-lite 0.1.0 → 0.1.3

package/dist/llm/LLMService.presets.test.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const LLMService_1 = require("./LLMService");
+const presets_json_1 = __importDefault(require("../config/presets.json"));
+describe('LLMService Presets', () => {
+    let mockApiKeyProvider;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockApiKeyProvider = jest.fn().mockResolvedValue('test-api-key');
+    });
+    describe('Default behavior', () => {
+        it('should load default presets when no options provided', async () => {
+            const service = new LLMService_1.LLMService(mockApiKeyProvider);
+            const presets = service.getPresets();
+            expect(presets).toHaveLength(presets_json_1.default.length);
+            expect(presets).toEqual(expect.arrayContaining(presets_json_1.default.map(preset => expect.objectContaining({
+                id: preset.id,
+                displayName: preset.displayName,
+                providerId: preset.providerId,
+                modelId: preset.modelId
+            }))));
+        });
+        it('should return a copy of presets to prevent external modification', async () => {
+            const service = new LLMService_1.LLMService(mockApiKeyProvider);
+            const presets1 = service.getPresets();
+            const presets2 = service.getPresets();
+            expect(presets1).not.toBe(presets2); // Different array instances
+            expect(presets1).toEqual(presets2); // Same content
+            // Modifying returned array should not affect service
+            presets1.push({
+                id: 'test-preset',
+                displayName: 'Test',
+                providerId: 'openai',
+                modelId: 'gpt-4',
+                settings: {}
+            });
+            const presets3 = service.getPresets();
+            expect(presets3).toHaveLength(presets_json_1.default.length);
+        });
+    });
+    describe('Extend mode', () => {
+        it('should add new presets to defaults in extend mode', async () => {
+            const customPresets = [
+                {
+                    id: 'custom-preset-1',
+                    displayName: 'Custom Preset 1',
+                    providerId: 'openai',
+                    modelId: 'gpt-4',
+                    settings: { temperature: 0.5 }
+                }
+            ];
+            const service = new LLMService_1.LLMService(mockApiKeyProvider, {
+                presets: customPresets,
+                presetMode: 'extend'
+            });
+            const presets = service.getPresets();
+            expect(presets).toHaveLength(presets_json_1.default.length + 1);
+            expect(presets).toContainEqual(expect.objectContaining({
+                id: 'custom-preset-1',
+                displayName: 'Custom Preset 1'
+            }));
+        });
+        it('should override default presets with same ID in extend mode', async () => {
+            const existingPresetId = presets_json_1.default[0].id;
+            const customPresets = [
+                {
+                    id: existingPresetId,
+                    displayName: 'Overridden Preset',
+                    providerId: 'anthropic',
+                    modelId: 'claude-3-5-sonnet-20241022',
+                    settings: { temperature: 0.8 }
+                }
+            ];
+            const service = new LLMService_1.LLMService(mockApiKeyProvider, {
+                presets: customPresets,
+                presetMode: 'extend'
+            });
+            const presets = service.getPresets();
+            const overriddenPreset = presets.find(p => p.id === existingPresetId);
+            expect(presets).toHaveLength(presets_json_1.default.length);
+            expect(overriddenPreset).toBeDefined();
+            expect(overriddenPreset?.displayName).toBe('Overridden Preset');
+            expect(overriddenPreset?.providerId).toBe('anthropic');
+        });
+        it('should use extend mode by default when mode not specified', async () => {
+            const customPresets = [
+                {
+                    id: 'custom-preset-default',
+                    displayName: 'Custom Default',
+                    providerId: 'gemini',
+                    modelId: 'gemini-2.0-flash',
+                    settings: { temperature: 0.3 }
+                }
+            ];
+            const service = new LLMService_1.LLMService(mockApiKeyProvider, {
+                presets: customPresets
+                // presetMode not specified, should default to 'extend'
+            });
+            const presets = service.getPresets();
+            expect(presets).toHaveLength(presets_json_1.default.length + 1);
+        });
+    });
+    describe('Replace mode', () => {
+        it('should use only custom presets in replace mode', async () => {
+            const customPresets = [
+                {
+                    id: 'replace-preset-1',
+                    displayName: 'Replace Preset 1',
+                    providerId: 'openai',
+                    modelId: 'gpt-4',
+                    settings: { temperature: 0.5 }
+                },
+                {
+                    id: 'replace-preset-2',
+                    displayName: 'Replace Preset 2',
+                    providerId: 'anthropic',
+                    modelId: 'claude-3-5-sonnet-20241022',
+                    settings: { temperature: 0.3 }
+                }
+            ];
+            const service = new LLMService_1.LLMService(mockApiKeyProvider, {
+                presets: customPresets,
+                presetMode: 'replace'
+            });
+            const presets = service.getPresets();
+            expect(presets).toHaveLength(2);
+            expect(presets).toEqual(expect.arrayContaining([
+                expect.objectContaining({ id: 'replace-preset-1' }),
+                expect.objectContaining({ id: 'replace-preset-2' })
+            ]));
+            // Should not contain any default presets
+            const defaultPresetIds = presets_json_1.default.map(p => p.id);
+            const actualPresetIds = presets.map(p => p.id);
+            expect(actualPresetIds).not.toContain(expect.arrayContaining(defaultPresetIds));
+        });
+        it('should return empty array when replace mode with no custom presets', async () => {
+            const service = new LLMService_1.LLMService(mockApiKeyProvider, {
+                presets: [],
+                presetMode: 'replace'
+            });
+            const presets = service.getPresets();
+            expect(presets).toHaveLength(0);
+        });
+        it('should handle undefined presets array in replace mode', async () => {
+            const service = new LLMService_1.LLMService(mockApiKeyProvider, {
+                presetMode: 'replace'
+                // presets not provided
+            });
+            const presets = service.getPresets();
+            expect(presets).toHaveLength(0);
+        });
+    });
+    describe('Edge cases', () => {
+        it('should handle duplicate IDs within custom presets', async () => {
+            const customPresets = [
+                {
+                    id: 'duplicate-id',
+                    displayName: 'First Preset',
+                    providerId: 'openai',
+                    modelId: 'gpt-4',
+                    settings: { temperature: 0.5 }
+                },
+                {
+                    id: 'duplicate-id',
+                    displayName: 'Second Preset',
+                    providerId: 'anthropic',
+                    modelId: 'claude-3-5-sonnet-20241022',
+                    settings: { temperature: 0.3 }
+                }
+            ];
+            const service = new LLMService_1.LLMService(mockApiKeyProvider, {
+                presets: customPresets,
+                presetMode: 'replace'
+            });
+            const presets = service.getPresets();
+            const duplicatePresets = presets.filter(p => p.id === 'duplicate-id');
+            // Last one should win
+            expect(duplicatePresets).toHaveLength(1);
+            expect(duplicatePresets[0].displayName).toBe('Second Preset');
+        });
+        it('should handle presets with complex settings including gemini safety settings', async () => {
+            const customPresets = [
+                {
+                    id: 'gemini-complex',
+                    displayName: 'Gemini Complex',
+                    providerId: 'gemini',
+                    modelId: 'gemini-2.0-flash',
+                    settings: {
+                        temperature: 0.5,
+                        maxTokens: 2000,
+                        geminiSafetySettings: [
+                            { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_NONE' },
+                            { category: 'HARM_CATEGORY_DANGEROUS_CONTENT', threshold: 'BLOCK_MEDIUM_AND_ABOVE' }
+                        ]
+                    }
+                }
+            ];
+            const service = new LLMService_1.LLMService(mockApiKeyProvider, {
+                presets: customPresets,
+                presetMode: 'replace'
+            });
+            const presets = service.getPresets();
+            expect(presets).toHaveLength(1);
+            expect(presets[0].settings.geminiSafetySettings).toHaveLength(2);
+        });
+    });
+});

package/dist/llm/LLMService.test.d.ts

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

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 {};