genai-lite 0.4.0 → 0.4.2

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

@@ -1,303 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const LLMService_1 = require("./LLMService");
-describe('LLMService.prepareMessage', () => {
-    let mockApiKeyProvider;
-    let service;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockApiKeyProvider = jest.fn().mockResolvedValue('test-api-key');
-        service = new LLMService_1.LLMService(mockApiKeyProvider);
-    });
-    describe('Input validation', () => {
-        it('should require either template or messages', async () => {
-            const result = await service.prepareMessage({});
-            expect(result).toMatchObject({
-                object: 'error',
-                error: {
-                    message: 'Either template or messages must be provided',
-                    code: 'INVALID_INPUT',
-                    type: 'validation_error',
-                },
-            });
-        });
-        it('should require either presetId or both providerId and modelId', async () => {
-            const result = await service.prepareMessage({
-                template: 'Test template',
-                providerId: 'openai',
-                // Missing modelId
-            });
-            expect(result).toMatchObject({
-                object: 'error',
-                error: {
-                    message: 'Either presetId or both providerId and modelId must be provided',
-                    code: 'INVALID_MODEL_SELECTION',
-                    type: 'validation_error',
-                },
-            });
-        });
-    });
-    describe('Preset resolution', () => {
-        it('should resolve model info from presetId', async () => {
-            const result = await service.prepareMessage({
-                template: 'Test {{ model_id }}',
-                presetId: 'openai-gpt-4.1-default',
-            });
-            expect(result).toMatchObject({
-                messages: [{ role: 'user', content: 'Test gpt-4.1' }],
-                modelContext: {
-                    model_id: 'gpt-4.1',
-                    provider_id: 'openai',
-                    thinking_enabled: false,
-                    thinking_available: false,
-                },
-            });
-        });
-        it('should handle non-existent presetId', async () => {
-            const result = await service.prepareMessage({
-                template: 'Test',
-                presetId: 'non-existent-preset',
-            });
-            expect(result).toMatchObject({
-                object: 'error',
-                error: {
-                    message: 'Preset not found: non-existent-preset',
-                    code: 'PRESET_NOT_FOUND',
-                    type: 'validation_error',
-                },
-            });
-        });
-        it('should merge preset settings with user settings', async () => {
-            const result = await service.prepareMessage({
-                template: 'Test',
-                presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking',
-                settings: { temperature: 0.5 }, // Override preset temperature
-            });
-            expect(result).not.toHaveProperty('error');
-            // The settings are merged internally and will be used when sendMessage is called
-        });
-    });
-    describe('Model resolution from providerId/modelId', () => {
-        it('should resolve model info from providerId and modelId', async () => {
-            const result = await service.prepareMessage({
-                template: 'Model: {{ model_id }}, Provider: {{ provider_id }}',
-                providerId: 'anthropic',
-                modelId: 'claude-3-5-sonnet-20241022',
-            });
-            expect(result).toMatchObject({
-                messages: [{
-                        role: 'user',
-                        content: 'Model: claude-3-5-sonnet-20241022, Provider: anthropic'
-                    }],
-                modelContext: {
-                    model_id: 'claude-3-5-sonnet-20241022',
-                    provider_id: 'anthropic',
-                    thinking_enabled: false,
-                    thinking_available: false,
-                },
-            });
-        });
-        it('should handle invalid model', async () => {
-            const result = await service.prepareMessage({
-                template: 'Test',
-                providerId: 'openai',
-                modelId: 'non-existent-model',
-            });
-            expect(result).toMatchObject({
-                object: 'error',
-                error: {
-                    message: 'Unsupported model: non-existent-model for provider: openai',
-                    code: 'UNSUPPORTED_MODEL',
-                    type: 'validation_error',
-                },
-            });
-        });
-    });
-    describe('Template rendering with model context', () => {
-        it('should inject model context into template', async () => {
-            const result = await service.prepareMessage({
-                template: `{{ thinking_enabled ? \`Please think step by step about this:\` : \`Please analyze this:\` }}
-Model: {{ model_id }}
-Provider: {{ provider_id }}
-Thinking available: {{ thinking_available }}`,
-                presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking',
-            });
-            expect(result).toMatchObject({
-                messages: [{
-                        role: 'user',
-                        content: expect.stringContaining('Please think step by step about this:'),
-                    }],
-                modelContext: {
-                    thinking_enabled: true,
-                    thinking_available: true,
-                    model_id: 'claude-3-7-sonnet-20250219',
-                    provider_id: 'anthropic',
-                },
-            });
-            const content = result.messages[0].content;
-            expect(content).toContain('Model: claude-3-7-sonnet-20250219');
-            expect(content).toContain('Provider: anthropic');
-            expect(content).toContain('Thinking available: true');
-        });
-        it('should handle reasoning effort in model context', async () => {
-            const result = await service.prepareMessage({
-                template: 'Effort: {{ reasoning_effort ? `{{reasoning_effort}}` : `not set` }}',
-                providerId: 'anthropic',
-                modelId: 'claude-3-7-sonnet-20250219',
-                settings: {
-                    reasoning: {
-                        enabled: true,
-                        effort: 'high',
-                    },
-                },
-            });
-            expect(result).toMatchObject({
-                messages: [{ role: 'user', content: 'Effort: high' }],
-                modelContext: {
-                    reasoning_effort: 'high',
-                },
-            });
-        });
-        it('should handle reasoning maxTokens in model context', async () => {
-            const result = await service.prepareMessage({
-                template: 'Max tokens: {{ reasoning_max_tokens ? `{{reasoning_max_tokens}}` : `default` }}',
-                providerId: 'anthropic',
-                modelId: 'claude-3-7-sonnet-20250219',
-                settings: {
-                    reasoning: {
-                        enabled: true,
-                        maxTokens: 5000,
-                    },
-                },
-            });
-            expect(result).toMatchObject({
-                messages: [{ role: 'user', content: 'Max tokens: 5000' }],
-                modelContext: {
-                    reasoning_max_tokens: 5000,
-                },
-            });
-        });
-        it('should combine template variables with model context', async () => {
-            const result = await service.prepareMessage({
-                template: `
-Task: {{ task }}
-Model: {{ model_id }}
-{{ thinking_enabled ? "Use reasoning to solve this." : "Provide a direct answer." }}`,
-                variables: {
-                    task: 'Calculate fibonacci(10)',
-                },
-                presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking',
-            });
-            const content = result.messages[0].content;
-            expect(content).toContain('Task: Calculate fibonacci(10)');
-            expect(content).toContain('Model: claude-3-7-sonnet-20250219');
-            expect(content).toContain('Use reasoning to solve this.');
-        });
-        it('should handle template rendering errors', async () => {
-            // This will cause an actual error in template rendering by using a variable that throws on toString()
-            const errorObject = {
-                toString: () => {
-                    throw new Error('Test template error');
-                }
-            };
-            const result = await service.prepareMessage({
-                template: '{{ data }}',
-                variables: { data: errorObject },
-                providerId: 'openai',
-                modelId: 'gpt-4.1',
-            });
-            expect(result).toMatchObject({
-                object: 'error',
-                error: {
-                    message: expect.stringContaining('Template rendering failed'),
-                    code: 'TEMPLATE_ERROR',
-                    type: 'validation_error',
-                },
-            });
-        });
-    });
-    describe('Pre-built messages', () => {
-        it('should return pre-built messages with model context', async () => {
-            const messages = [
-                { role: 'system', content: 'You are a helpful assistant.' },
-                { role: 'user', content: 'Hello!' },
-            ];
-            const result = await service.prepareMessage({
-                messages,
-                providerId: 'openai',
-                modelId: 'o4-mini',
-            });
-            expect(result).toMatchObject({
-                messages,
-                modelContext: {
-                    model_id: 'o4-mini',
-                    provider_id: 'openai',
-                    thinking_enabled: true, // o4-mini always has reasoning enabled
-                    thinking_available: true,
-                },
-            });
-        });
-    });
-    describe('Thinking/reasoning models', () => {
-        it('should detect thinking capabilities for supported models', async () => {
-            const testCases = [
-                {
-                    presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking',
-                    expected: { thinking_enabled: true, thinking_available: true },
-                },
-                {
-                    presetId: 'anthropic-claude-3-5-sonnet-20241022-default',
-                    expected: { thinking_enabled: false, thinking_available: false },
-                },
-                {
-                    presetId: 'google-gemini-2.5-flash-thinking',
-                    expected: { thinking_enabled: true, thinking_available: true },
-                },
-                {
-                    presetId: 'openai-o4-mini-default',
-                    expected: { thinking_enabled: true, thinking_available: true }, // Always on
-                },
-            ];
-            for (const testCase of testCases) {
-                const result = await service.prepareMessage({
-                    template: 'Test',
-                    presetId: testCase.presetId,
-                });
-                expect(result).toMatchObject({
-                    modelContext: expect.objectContaining(testCase.expected),
-                });
-            }
-        });
-    });
-    describe('Custom presets', () => {
-        it('should work with custom presets', async () => {
-            const customPresets = [
-                {
-                    id: 'custom-gpt4-thinking',
-                    displayName: 'Custom GPT-4',
-                    providerId: 'openai',
-                    modelId: 'gpt-4.1',
-                    settings: {
-                        temperature: 0.3,
-                        reasoning: { enabled: true },
-                    },
-                },
-            ];
-            const customService = new LLMService_1.LLMService(mockApiKeyProvider, {
-                presets: customPresets,
-                presetMode: 'extend',
-            });
-            const result = await customService.prepareMessage({
-                template: 'Thinking: {{ thinking_enabled }}',
-                presetId: 'custom-gpt4-thinking',
-            });
-            expect(result).toMatchObject({
-                messages: [{ role: 'user', content: 'Thinking: false' }], // GPT-4.1 doesn't support reasoning
-                modelContext: {
-                    thinking_enabled: false,
-                    thinking_available: false,
-                },
-            });
-        });
-    });
-});

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

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

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

@@ -1,210 +0,0 @@
-"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.sendMessage.preset.test.d.ts

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

package/dist/llm/LLMService.sendMessage.preset.test.js

@@ -1,153 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const LLMService_1 = require("./LLMService");
-describe('LLMService.sendMessage with presetId', () => {
-    let mockApiKeyProvider;
-    let service;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockApiKeyProvider = jest.fn().mockResolvedValue('test-api-key');
-        service = new LLMService_1.LLMService(mockApiKeyProvider);
-    });
-    describe('Preset resolution in sendMessage', () => {
-        it('should send message using presetId', async () => {
-            const request = {
-                presetId: 'openai-gpt-4.1-default',
-                messages: [{ role: 'user', content: 'Hello' }],
-            };
-            const response = await service.sendMessage(request);
-            // The request will fail because we don't have a real API key,
-            // but we can verify it tried with the correct provider/model
-            expect(response).toMatchObject({
-                provider: 'openai',
-                model: 'gpt-4.1',
-                object: 'error',
-            });
-        });
-        it('should override preset settings with request settings', async () => {
-            const request = {
-                presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking',
-                messages: [{ role: 'user', content: 'Test' }],
-                settings: {
-                    temperature: 0.2, // Override preset temperature
-                    reasoning: {
-                        enabled: false, // Disable reasoning despite thinking preset
-                    },
-                },
-            };
-            const response = await service.sendMessage(request);
-            expect(response).toMatchObject({
-                provider: 'anthropic',
-                model: 'claude-3-7-sonnet-20250219',
-                object: 'error',
-            });
-        });
-        it('should handle invalid presetId', async () => {
-            const request = {
-                presetId: 'non-existent-preset',
-                messages: [{ role: 'user', content: 'Test' }],
-            };
-            const response = await service.sendMessage(request);
-            expect(response).toMatchObject({
-                object: 'error',
-                error: {
-                    message: 'Preset not found: non-existent-preset',
-                    code: 'PRESET_NOT_FOUND',
-                    type: 'validation_error',
-                },
-            });
-        });
-        it('should allow either presetId or providerId/modelId', async () => {
-            // Test with providerId/modelId (existing behavior)
-            const request1 = {
-                providerId: 'openai',
-                modelId: 'gpt-4.1',
-                messages: [{ role: 'user', content: 'Test' }],
-            };
-            const response1 = await service.sendMessage(request1);
-            expect(response1).toMatchObject({
-                provider: 'openai',
-                model: 'gpt-4.1',
-            });
-            // Test with presetId (new behavior)
-            const request2 = {
-                presetId: 'openai-gpt-4.1-default',
-                messages: [{ role: 'user', content: 'Test' }],
-            };
-            const response2 = await service.sendMessage(request2);
-            expect(response2).toMatchObject({
-                provider: 'openai',
-                model: 'gpt-4.1',
-            });
-        });
-        it('should prefer presetId when both are provided', async () => {
-            const request = {
-                presetId: 'anthropic-claude-3-5-sonnet-20241022-default',
-                providerId: 'openai', // These will be ignored
-                modelId: 'gpt-4.1', // These will be ignored
-                messages: [{ role: 'user', content: 'Test' }],
-            };
-            const response = await service.sendMessage(request);
-            // Should use the preset's provider/model
-            expect(response).toMatchObject({
-                provider: 'anthropic',
-                model: 'claude-3-5-sonnet-20241022',
-            });
-        });
-        it('should handle preset with model that was removed from config', async () => {
-            // Create a service with a preset pointing to a non-existent model
-            const customService = new LLMService_1.LLMService(mockApiKeyProvider, {
-                presets: [{
-                        id: 'broken-preset',
-                        displayName: 'Broken',
-                        providerId: 'openai',
-                        modelId: 'non-existent-model',
-                        settings: {},
-                    }],
-                presetMode: 'extend',
-            });
-            const request = {
-                presetId: 'broken-preset',
-                messages: [{ role: 'user', content: 'Test' }],
-            };
-            const response = await customService.sendMessage(request);
-            expect(response).toMatchObject({
-                object: 'error',
-                error: {
-                    message: 'Model not found for preset: broken-preset',
-                    code: 'MODEL_NOT_FOUND',
-                    type: 'validation_error',
-                },
-            });
-        });
-    });
-    describe('Settings merge with presets', () => {
-        it('should apply preset settings correctly', async () => {
-            const request = {
-                presetId: 'google-gemini-2.5-flash',
-                messages: [{ role: 'user', content: 'Test' }],
-            };
-            const response = await service.sendMessage(request);
-            // The preset includes geminiSafetySettings which should be applied
-            expect(response).toMatchObject({
-                provider: 'gemini',
-                model: 'gemini-2.5-flash',
-            });
-        });
-        it('should merge preset reasoning settings with request settings', async () => {
-            const request = {
-                presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking',
-                messages: [{ role: 'user', content: 'Complex problem' }],
-                settings: {
-                    maxTokens: 2000, // Add to preset settings
-                },
-            };
-            const response = await service.sendMessage(request);
-            expect(response).toMatchObject({
-                provider: 'anthropic',
-                model: 'claude-3-7-sonnet-20250219',
-            });
-            // Settings would be merged internally with both reasoning enabled and maxTokens
-        });
-    });
-});

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

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