genai-lite 0.4.0 → 0.4.2

package/dist/llm/services/AdapterRegistry.test.js

@@ -1,239 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// Mock the client adapters first
-jest.mock('../clients/MockClientAdapter');
-jest.mock('../clients/OpenAIClientAdapter', () => ({
-    OpenAIClientAdapter: jest.fn().mockImplementation(() => ({
-        sendMessage: jest.fn(),
-        getAdapterInfo: () => ({ providerId: 'openai', name: 'OpenAI Adapter' })
-    }))
-}));
-jest.mock('../clients/AnthropicClientAdapter', () => ({
-    AnthropicClientAdapter: jest.fn().mockImplementation(() => ({
-        sendMessage: jest.fn(),
-        getAdapterInfo: () => ({ providerId: 'anthropic', name: 'Anthropic Adapter' })
-    }))
-}));
-jest.mock('../clients/GeminiClientAdapter', () => ({
-    GeminiClientAdapter: jest.fn().mockImplementation(() => ({
-        sendMessage: jest.fn(),
-        getAdapterInfo: () => ({ providerId: 'gemini', name: 'Gemini Adapter' })
-    }))
-}));
-// Mock the config imports - must be before imports that use it
-jest.mock('../config', () => {
-    const { OpenAIClientAdapter } = require('../clients/OpenAIClientAdapter');
-    const { AnthropicClientAdapter } = require('../clients/AnthropicClientAdapter');
-    const { GeminiClientAdapter } = require('../clients/GeminiClientAdapter');
-    return {
-        SUPPORTED_PROVIDERS: [
-            { id: 'openai', name: 'OpenAI' },
-            { id: 'anthropic', name: 'Anthropic' },
-            { id: 'gemini', name: 'Google Gemini' },
-            { id: 'mistral', name: 'Mistral' }
-        ],
-        ADAPTER_CONSTRUCTORS: {
-            openai: OpenAIClientAdapter,
-            anthropic: AnthropicClientAdapter,
-            gemini: GeminiClientAdapter,
-            // mistral intentionally missing to test fallback
-        },
-        ADAPTER_CONFIGS: {
-            openai: {},
-            anthropic: {},
-            gemini: {},
-            mistral: {}
-        }
-    };
-});
-// Now import the modules
-const AdapterRegistry_1 = require("./AdapterRegistry");
-const MockClientAdapter_1 = require("../clients/MockClientAdapter");
-const OpenAIClientAdapter_1 = require("../clients/OpenAIClientAdapter");
-describe('AdapterRegistry', () => {
-    let registry;
-    let consoleLogSpy;
-    let consoleWarnSpy;
-    let consoleErrorSpy;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
-        consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
-    });
-    afterEach(() => {
-        consoleLogSpy.mockRestore();
-        consoleWarnSpy.mockRestore();
-        consoleErrorSpy.mockRestore();
-    });
-    describe('initialization', () => {
-        it('should initialize with adapters for providers with constructors', () => {
-            registry = new AdapterRegistry_1.AdapterRegistry();
-            // Should have logged successful initialization
-            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Initialized with 3 dynamically registered adapter(s)'));
-            expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('openai, anthropic, gemini'));
-            // Should warn about missing constructor for mistral
-            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("No adapter constructor found for supported provider 'mistral'"));
-        });
-        it('should handle adapter initialization errors gracefully', () => {
-            // Make OpenAIClientAdapter throw an error on construction
-            OpenAIClientAdapter_1.OpenAIClientAdapter.mockImplementationOnce(() => {
-                throw new Error('Initialization failed');
-            });
-            registry = new AdapterRegistry_1.AdapterRegistry();
-            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to instantiate adapter for provider 'openai'"), expect.any(Error));
-        });
-        it('should log when no adapters are registered', () => {
-            // Clear all module cache to ensure clean isolation
-            jest.resetModules();
-            // Mock the config module with no constructors before requiring AdapterRegistry
-            jest.doMock('../config', () => ({
-                SUPPORTED_PROVIDERS: [
-                    { id: 'openai', name: 'OpenAI' },
-                    { id: 'anthropic', name: 'Anthropic' },
-                    { id: 'gemini', name: 'Google Gemini' },
-                    { id: 'mistral', name: 'Mistral' }
-                ],
-                ADAPTER_CONSTRUCTORS: {}, // No constructors
-                ADAPTER_CONFIGS: {
-                    openai: {},
-                    anthropic: {},
-                    gemini: {},
-                    mistral: {}
-                }
-            }));
-            // Mock the client adapters to prevent import errors
-            jest.doMock('../clients/MockClientAdapter', () => ({
-                MockClientAdapter: jest.fn()
-            }));
-            jest.doMock('../clients/OpenAIClientAdapter', () => ({
-                OpenAIClientAdapter: jest.fn()
-            }));
-            jest.doMock('../clients/AnthropicClientAdapter', () => ({
-                AnthropicClientAdapter: jest.fn()
-            }));
-            jest.doMock('../clients/GeminiClientAdapter', () => ({
-                GeminiClientAdapter: jest.fn()
-            }));
-            // Clear console spy calls before the test
-            consoleLogSpy.mockClear();
-            // Now require the AdapterRegistry with mocked dependencies
-            const { AdapterRegistry: IsolatedAdapterRegistry } = require('./AdapterRegistry');
-            const isolatedRegistry = new IsolatedAdapterRegistry();
-            expect(consoleLogSpy).toHaveBeenCalledWith('LLMService: No real adapters were dynamically registered. All providers will use the mock adapter.');
-            // Restore modules after test
-            jest.resetModules();
-        });
-    });
-    describe('getAdapter', () => {
-        beforeEach(() => {
-            registry = new AdapterRegistry_1.AdapterRegistry();
-        });
-        it('should return registered adapter for supported provider', () => {
-            const adapter = registry.getAdapter('openai');
-            expect(adapter).toBeDefined();
-            expect(consoleLogSpy).toHaveBeenCalledWith('Using registered adapter for provider: openai');
-        });
-        it('should return mock adapter for provider without adapter', () => {
-            const adapter = registry.getAdapter('mistral');
-            expect(adapter).toBeInstanceOf(MockClientAdapter_1.MockClientAdapter);
-            expect(consoleLogSpy).toHaveBeenCalledWith('No real adapter found for mistral, using mock adapter');
-        });
-        it('should return mock adapter for unknown provider', () => {
-            const adapter = registry.getAdapter('unknown-provider');
-            expect(adapter).toBeInstanceOf(MockClientAdapter_1.MockClientAdapter);
-            expect(consoleLogSpy).toHaveBeenCalledWith('No real adapter found for unknown-provider, using mock adapter');
-        });
-    });
-    describe('registerAdapter', () => {
-        beforeEach(() => {
-            registry = new AdapterRegistry_1.AdapterRegistry();
-        });
-        it('should register new adapter', () => {
-            const mockAdapter = {
-                sendMessage: jest.fn(),
-                getAdapterInfo: () => ({ providerId: 'custom-provider', name: 'Custom Adapter' })
-            };
-            registry.registerAdapter('custom-provider', mockAdapter);
-            expect(consoleLogSpy).toHaveBeenCalledWith('Registered client adapter for provider: custom-provider');
-            // Should be able to retrieve it
-            const retrievedAdapter = registry.getAdapter('custom-provider');
-            expect(retrievedAdapter).toBe(mockAdapter);
-        });
-        it('should override existing adapter', () => {
-            const newAdapter = {
-                sendMessage: jest.fn(),
-                getAdapterInfo: () => ({ providerId: 'openai', name: 'New OpenAI Adapter' })
-            };
-            registry.registerAdapter('openai', newAdapter);
-            const retrievedAdapter = registry.getAdapter('openai');
-            expect(retrievedAdapter).toBe(newAdapter);
-        });
-    });
-    describe('getRegisteredAdapters', () => {
-        beforeEach(() => {
-            registry = new AdapterRegistry_1.AdapterRegistry();
-        });
-        it('should return info for all registered adapters', () => {
-            const adapterInfo = registry.getRegisteredAdapters();
-            expect(adapterInfo.size).toBe(3); // openai, anthropic, gemini
-            expect(adapterInfo.get('openai')).toEqual({
-                providerId: 'openai',
-                hasAdapter: true,
-                adapterInfo: { providerId: 'openai', name: 'OpenAI Adapter' }
-            });
-            expect(adapterInfo.get('anthropic')).toEqual({
-                providerId: 'anthropic',
-                hasAdapter: true,
-                adapterInfo: { providerId: 'anthropic', name: 'Anthropic Adapter' }
-            });
-            expect(adapterInfo.get('gemini')).toEqual({
-                providerId: 'gemini',
-                hasAdapter: true,
-                adapterInfo: { providerId: 'gemini', name: 'Gemini Adapter' }
-            });
-            // mistral should not be in the map
-            expect(adapterInfo.has('mistral')).toBe(false);
-        });
-        it('should handle adapters without getAdapterInfo method', () => {
-            const adapterWithoutInfo = {
-                sendMessage: jest.fn(),
-                // No getAdapterInfo method
-            };
-            registry.registerAdapter('custom', adapterWithoutInfo);
-            const adapterInfo = registry.getRegisteredAdapters();
-            expect(adapterInfo.get('custom')).toEqual({
-                providerId: 'custom',
-                hasAdapter: true,
-                adapterInfo: { name: 'Unknown Adapter' }
-            });
-        });
-    });
-    describe('getProviderSummary', () => {
-        beforeEach(() => {
-            registry = new AdapterRegistry_1.AdapterRegistry();
-        });
-        it('should return correct summary of provider availability', () => {
-            const summary = registry.getProviderSummary();
-            expect(summary).toEqual({
-                totalProviders: 4,
-                providersWithAdapters: 3,
-                availableProviders: ['openai', 'anthropic', 'gemini'],
-                unavailableProviders: ['mistral']
-            });
-        });
-        it('should update summary after registering new adapter', () => {
-            const mockAdapter = {
-                sendMessage: jest.fn(),
-            };
-            registry.registerAdapter('mistral', mockAdapter);
-            const summary = registry.getProviderSummary();
-            expect(summary).toEqual({
-                totalProviders: 4,
-                providersWithAdapters: 4,
-                availableProviders: ['openai', 'anthropic', 'gemini', 'mistral'],
-                unavailableProviders: []
-            });
-        });
-    });
-});

package/dist/llm/services/ModelResolver.test.d.ts

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

package/dist/llm/services/ModelResolver.test.js

@@ -1,179 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ModelResolver_1 = require("./ModelResolver");
-describe('ModelResolver', () => {
-    let resolver;
-    let mockPresetManager;
-    beforeEach(() => {
-        mockPresetManager = {
-            getPresets: jest.fn(),
-            resolvePreset: jest.fn(),
-        };
-        resolver = new ModelResolver_1.ModelResolver(mockPresetManager);
-    });
-    describe('preset resolution', () => {
-        it('should resolve model from valid preset', () => {
-            const mockPreset = {
-                id: 'test-preset',
-                displayName: 'Test Preset',
-                providerId: 'openai',
-                modelId: 'gpt-4.1',
-                settings: { temperature: 0.7 }
-            };
-            mockPresetManager.resolvePreset.mockReturnValue(mockPreset);
-            const result = resolver.resolve({ presetId: 'test-preset' });
-            expect(mockPresetManager.resolvePreset).toHaveBeenCalledWith('test-preset');
-            expect(result.error).toBeUndefined();
-            expect(result.providerId).toBe('openai');
-            expect(result.modelId).toBe('gpt-4.1');
-            expect(result.modelInfo).toBeDefined();
-            expect(result.settings).toEqual({ temperature: 0.7 });
-        });
-        it('should return error for non-existent preset', () => {
-            mockPresetManager.resolvePreset.mockReturnValue(null);
-            const result = resolver.resolve({ presetId: 'non-existent' });
-            expect(result.error).toBeDefined();
-            expect(result.error?.error.code).toBe('PRESET_NOT_FOUND');
-            expect(result.error?.error.message).toContain('Preset not found: non-existent');
-        });
-        it('should return error for preset with invalid model', () => {
-            const mockPreset = {
-                id: 'invalid-model-preset',
-                displayName: 'Invalid Model Preset',
-                providerId: 'openai',
-                modelId: 'invalid-model',
-                settings: {}
-            };
-            mockPresetManager.resolvePreset.mockReturnValue(mockPreset);
-            const result = resolver.resolve({ presetId: 'invalid-model-preset' });
-            expect(result.error).toBeDefined();
-            expect(result.error?.error.code).toBe('MODEL_NOT_FOUND');
-            expect(result.error?.error.message).toContain('Model not found for preset');
-        });
-        it('should merge preset settings with user settings', () => {
-            const mockPreset = {
-                id: 'test-preset',
-                displayName: 'Test Preset',
-                providerId: 'openai',
-                modelId: 'gpt-4.1',
-                settings: {
-                    temperature: 0.7,
-                    maxTokens: 1000
-                }
-            };
-            mockPresetManager.resolvePreset.mockReturnValue(mockPreset);
-            const result = resolver.resolve({
-                presetId: 'test-preset',
-                settings: {
-                    temperature: 0.9, // Override
-                    topP: 0.95 // New setting
-                }
-            });
-            expect(result.settings).toEqual({
-                temperature: 0.9, // User override
-                maxTokens: 1000, // From preset
-                topP: 0.95 // User addition
-            });
-        });
-    });
-    describe('direct model resolution', () => {
-        it('should resolve model from valid provider and model IDs', () => {
-            const result = resolver.resolve({
-                providerId: 'openai',
-                modelId: 'gpt-4.1'
-            });
-            expect(result.error).toBeUndefined();
-            expect(result.providerId).toBe('openai');
-            expect(result.modelId).toBe('gpt-4.1');
-            expect(result.modelInfo).toBeDefined();
-            expect(result.modelInfo?.id).toBe('gpt-4.1');
-        });
-        it('should return error when neither preset nor provider/model provided', () => {
-            const result = resolver.resolve({});
-            expect(result.error).toBeDefined();
-            expect(result.error?.error.code).toBe('INVALID_MODEL_SELECTION');
-            expect(result.error?.error.message).toContain('Either presetId or both providerId and modelId must be provided');
-        });
-        it('should return error when only providerId provided', () => {
-            const result = resolver.resolve({ providerId: 'openai' });
-            expect(result.error).toBeDefined();
-            expect(result.error?.error.code).toBe('INVALID_MODEL_SELECTION');
-        });
-        it('should return error when only modelId provided', () => {
-            const result = resolver.resolve({ modelId: 'gpt-4.1' });
-            expect(result.error).toBeDefined();
-            expect(result.error?.error.code).toBe('INVALID_MODEL_SELECTION');
-        });
-        it('should return error for unsupported provider', () => {
-            const result = resolver.resolve({
-                providerId: 'unsupported-provider',
-                modelId: 'some-model'
-            });
-            expect(result.error).toBeDefined();
-            expect(result.error?.error.code).toBe('UNSUPPORTED_PROVIDER');
-            expect(result.error?.error.message).toContain('Unsupported provider');
-            expect(result.error?.error.message).toContain('Supported providers:');
-        });
-        it('should create fallback model info for unknown models (with warning)', () => {
-            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-            const result = resolver.resolve({
-                providerId: 'openai',
-                modelId: 'unsupported-model'
-            });
-            // Should succeed with fallback, not error
-            expect(result.error).toBeUndefined();
-            expect(result.modelInfo).toBeDefined();
-            expect(result.modelInfo?.id).toBe('unsupported-model');
-            expect(result.modelInfo?.providerId).toBe('openai');
-            // Should warn about unknown model
-            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('Unknown model "unsupported-model"'));
-            consoleWarnSpy.mockRestore();
-        });
-        it('should silently create fallback for llamacpp unknown models (no warning)', () => {
-            const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation();
-            const result = resolver.resolve({
-                providerId: 'llamacpp',
-                modelId: 'my-custom-gguf-model'
-            });
-            // Should succeed with fallback, not error
-            expect(result.error).toBeUndefined();
-            expect(result.modelInfo).toBeDefined();
-            expect(result.modelInfo?.id).toBe('my-custom-gguf-model');
-            expect(result.modelInfo?.providerId).toBe('llamacpp');
-            // Should NOT warn (llamacpp allows unknown models silently)
-            expect(consoleWarnSpy).not.toHaveBeenCalled();
-            consoleWarnSpy.mockRestore();
-        });
-        it('should pass through user settings for direct resolution', () => {
-            const settings = {
-                temperature: 0.8,
-                maxTokens: 2000
-            };
-            const result = resolver.resolve({
-                providerId: 'openai',
-                modelId: 'gpt-4.1',
-                settings
-            });
-            expect(result.settings).toBe(settings); // Should be the same reference
-        });
-    });
-    describe('priority handling', () => {
-        it('should prioritize presetId over providerId/modelId when both provided', () => {
-            const mockPreset = {
-                id: 'test-preset',
-                displayName: 'Test Preset',
-                providerId: 'anthropic',
-                modelId: 'claude-3-5-sonnet-20241022',
-                settings: {}
-            };
-            mockPresetManager.resolvePreset.mockReturnValue(mockPreset);
-            const result = resolver.resolve({
-                presetId: 'test-preset',
-                providerId: 'openai', // These should be ignored
-                modelId: 'gpt-4.1' // These should be ignored
-            });
-            expect(result.providerId).toBe('anthropic');
-            expect(result.modelId).toBe('claude-3-5-sonnet-20241022');
-        });
-    });
-});

package/dist/llm/services/PresetManager.test.d.ts

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

package/dist/llm/services/PresetManager.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 PresetManager_1 = require("./PresetManager");
-const presets_json_1 = __importDefault(require("../../config/presets.json"));
-describe('PresetManager', () => {
-    describe('Default behavior', () => {
-        it('should load default presets when no options provided', () => {
-            const manager = new PresetManager_1.PresetManager();
-            const presets = manager.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', () => {
-            const manager = new PresetManager_1.PresetManager();
-            const presets1 = manager.getPresets();
-            const presets2 = manager.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 = manager.getPresets();
-            expect(presets3).toHaveLength(presets_json_1.default.length);
-        });
-    });
-    describe('Extend mode', () => {
-        it('should add new presets to defaults in extend mode', () => {
-            const customPresets = [
-                {
-                    id: 'custom-preset-1',
-                    displayName: 'Custom Preset 1',
-                    providerId: 'openai',
-                    modelId: 'gpt-4',
-                    settings: { temperature: 0.5 }
-                }
-            ];
-            const manager = new PresetManager_1.PresetManager(customPresets, 'extend');
-            const presets = manager.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', () => {
-            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 manager = new PresetManager_1.PresetManager(customPresets, 'extend');
-            const presets = manager.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', () => {
-            const customPresets = [
-                {
-                    id: 'custom-preset-default',
-                    displayName: 'Custom Default',
-                    providerId: 'gemini',
-                    modelId: 'gemini-2.0-flash',
-                    settings: { temperature: 0.3 }
-                }
-            ];
-            const manager = new PresetManager_1.PresetManager(customPresets);
-            const presets = manager.getPresets();
-            expect(presets).toHaveLength(presets_json_1.default.length + 1);
-        });
-    });
-    describe('Replace mode', () => {
-        it('should use only custom presets in replace mode', () => {
-            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 manager = new PresetManager_1.PresetManager(customPresets, 'replace');
-            const presets = manager.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', () => {
-            const manager = new PresetManager_1.PresetManager([], 'replace');
-            const presets = manager.getPresets();
-            expect(presets).toHaveLength(0);
-        });
-        it('should handle undefined presets array in replace mode', () => {
-            const manager = new PresetManager_1.PresetManager(undefined, 'replace');
-            const presets = manager.getPresets();
-            expect(presets).toHaveLength(0);
-        });
-    });
-    describe('Edge cases', () => {
-        it('should handle duplicate IDs within custom presets', () => {
-            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 manager = new PresetManager_1.PresetManager(customPresets, 'replace');
-            const presets = manager.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', () => {
-            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 manager = new PresetManager_1.PresetManager(customPresets, 'replace');
-            const presets = manager.getPresets();
-            expect(presets).toHaveLength(1);
-            expect(presets[0].settings.geminiSafetySettings).toHaveLength(2);
-        });
-    });
-    describe('resolvePreset', () => {
-        it('should find preset by ID', () => {
-            const customPresets = [
-                {
-                    id: 'test-preset-1',
-                    displayName: 'Test Preset 1',
-                    providerId: 'openai',
-                    modelId: 'gpt-4',
-                    settings: {}
-                }
-            ];
-            const manager = new PresetManager_1.PresetManager(customPresets, 'replace');
-            const preset = manager.resolvePreset('test-preset-1');
-            expect(preset).toBeDefined();
-            expect(preset?.displayName).toBe('Test Preset 1');
-        });
-        it('should return null for non-existent preset', () => {
-            const manager = new PresetManager_1.PresetManager();
-            const preset = manager.resolvePreset('non-existent-preset');
-            expect(preset).toBeNull();
-        });
-        it('should find default preset in extend mode', () => {
-            const manager = new PresetManager_1.PresetManager();
-            const firstDefaultPresetId = presets_json_1.default[0].id;
-            const preset = manager.resolvePreset(firstDefaultPresetId);
-            expect(preset).toBeDefined();
-            expect(preset?.id).toBe(firstDefaultPresetId);
-        });
-    });
-});

package/dist/llm/services/RequestValidator.test.d.ts

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