genai-lite 0.2.1 → 0.3.0

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

@@ -0,0 +1,239 @@
+"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.d.ts

@@ -0,0 +1,35 @@
+import type { LLMFailureResponse, LLMSettings, ModelInfo } from "../types";
+import { PresetManager } from "./PresetManager";
+/**
+ * Options for model selection
+ */
+export interface ModelSelectionOptions {
+    presetId?: string;
+    providerId?: string;
+    modelId?: string;
+    settings?: LLMSettings;
+}
+/**
+ * Result of model resolution
+ */
+export interface ModelResolution {
+    providerId?: string;
+    modelId?: string;
+    modelInfo?: ModelInfo;
+    settings?: LLMSettings;
+    error?: LLMFailureResponse;
+}
+/**
+ * Resolves model information from presets or direct provider/model IDs
+ */
+export declare class ModelResolver {
+    private presetManager;
+    constructor(presetManager: PresetManager);
+    /**
+     * Resolves model information from either a preset ID or provider/model IDs
+     *
+     * @param options Options containing either presetId or providerId/modelId
+     * @returns Resolved model info and settings or error response
+     */
+    resolve(options: ModelSelectionOptions): ModelResolution;
+}

package/dist/llm/services/ModelResolver.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelResolver = void 0;
+const config_1 = require("../config");
+/**
+ * Resolves model information from presets or direct provider/model IDs
+ */
+class ModelResolver {
+    constructor(presetManager) {
+        this.presetManager = presetManager;
+    }
+    /**
+     * Resolves model information from either a preset ID or provider/model IDs
+     *
+     * @param options Options containing either presetId or providerId/modelId
+     * @returns Resolved model info and settings or error response
+     */
+    resolve(options) {
+        // If presetId is provided, use it
+        if (options.presetId) {
+            const preset = this.presetManager.resolvePreset(options.presetId);
+            if (!preset) {
+                return {
+                    error: {
+                        provider: 'unknown',
+                        model: 'unknown',
+                        error: {
+                            message: `Preset not found: ${options.presetId}`,
+                            code: 'PRESET_NOT_FOUND',
+                            type: 'validation_error',
+                        },
+                        object: 'error',
+                    }
+                };
+            }
+            const modelInfo = (0, config_1.getModelById)(preset.modelId, preset.providerId);
+            if (!modelInfo) {
+                return {
+                    error: {
+                        provider: preset.providerId,
+                        model: preset.modelId,
+                        error: {
+                            message: `Model not found for preset: ${options.presetId}`,
+                            code: 'MODEL_NOT_FOUND',
+                            type: 'validation_error',
+                        },
+                        object: 'error',
+                    }
+                };
+            }
+            // Merge preset settings with user settings
+            const settings = {
+                ...preset.settings,
+                ...options.settings
+            };
+            return {
+                providerId: preset.providerId,
+                modelId: preset.modelId,
+                modelInfo,
+                settings
+            };
+        }
+        // Otherwise, use providerId and modelId
+        if (!options.providerId || !options.modelId) {
+            return {
+                error: {
+                    provider: (options.providerId || 'unknown'),
+                    model: options.modelId || 'unknown',
+                    error: {
+                        message: 'Either presetId or both providerId and modelId must be provided',
+                        code: 'INVALID_MODEL_SELECTION',
+                        type: 'validation_error',
+                    },
+                    object: 'error',
+                }
+            };
+        }
+        // Check if provider is supported first
+        if (!(0, config_1.isProviderSupported)(options.providerId)) {
+            return {
+                error: {
+                    provider: options.providerId,
+                    model: options.modelId,
+                    error: {
+                        message: `Unsupported provider: ${options.providerId}. Supported providers: ${config_1.SUPPORTED_PROVIDERS.map((p) => p.id).join(', ')}`,
+                        code: 'UNSUPPORTED_PROVIDER',
+                        type: 'validation_error',
+                    },
+                    object: 'error',
+                }
+            };
+        }
+        const modelInfo = (0, config_1.getModelById)(options.modelId, options.providerId);
+        if (!modelInfo) {
+            return {
+                error: {
+                    provider: options.providerId,
+                    model: options.modelId,
+                    error: {
+                        message: `Unsupported model: ${options.modelId} for provider: ${options.providerId}`,
+                        code: 'UNSUPPORTED_MODEL',
+                        type: 'validation_error',
+                    },
+                    object: 'error',
+                }
+            };
+        }
+        return {
+            providerId: options.providerId,
+            modelId: options.modelId,
+            modelInfo,
+            settings: options.settings
+        };
+    }
+}
+exports.ModelResolver = ModelResolver;

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

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

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

@@ -0,0 +1,158 @@
+"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 return error for unsupported model', () => {
+            const result = resolver.resolve({
+                providerId: 'openai',
+                modelId: 'unsupported-model'
+            });
+            expect(result.error).toBeDefined();
+            expect(result.error?.error.code).toBe('UNSUPPORTED_MODEL');
+            expect(result.error?.error.message).toContain('Unsupported model: unsupported-model');
+        });
+        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.d.ts

@@ -0,0 +1,27 @@
+import type { ModelPreset } from "../../types/presets";
+/**
+ * Defines how custom presets interact with the default presets.
+ * 'replace': Use only the custom presets provided. The default set is ignored.
+ * 'extend': Use the default presets, and add/override them with the custom presets. This is the default behavior.
+ */
+export type PresetMode = 'replace' | 'extend';
+/**
+ * Manages model presets including loading, merging, and resolution
+ */
+export declare class PresetManager {
+    private presets;
+    constructor(customPresets?: ModelPreset[], mode?: PresetMode);
+    /**
+     * Gets all configured model presets
+     *
+     * @returns Array of model presets
+     */
+    getPresets(): ModelPreset[];
+    /**
+     * Resolves a preset by ID
+     *
+     * @param presetId - The preset ID to resolve
+     * @returns The preset if found, null otherwise
+     */
+    resolvePreset(presetId: string): ModelPreset | null;
+}

package/dist/llm/services/PresetManager.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresetManager = void 0;
+const presets_json_1 = __importDefault(require("../../config/presets.json"));
+/**
+ * Manages model presets including loading, merging, and resolution
+ */
+class PresetManager {
+    constructor(customPresets = [], mode = 'extend') {
+        // Initialize presets based on mode
+        const finalPresets = new Map();
+        if (mode === 'replace') {
+            // Replace Mode: Only use custom presets.
+            for (const preset of customPresets) {
+                finalPresets.set(preset.id, preset);
+            }
+        }
+        else {
+            // Extend Mode: Load defaults first, then add/override.
+            for (const preset of presets_json_1.default) {
+                finalPresets.set(preset.id, preset);
+            }
+            for (const preset of customPresets) {
+                finalPresets.set(preset.id, preset);
+            }
+        }
+        this.presets = Array.from(finalPresets.values());
+    }
+    /**
+     * Gets all configured model presets
+     *
+     * @returns Array of model presets
+     */
+    getPresets() {
+        return [...this.presets]; // Return a copy to prevent external modification
+    }
+    /**
+     * Resolves a preset by ID
+     *
+     * @param presetId - The preset ID to resolve
+     * @returns The preset if found, null otherwise
+     */
+    resolvePreset(presetId) {
+        return this.presets.find(p => p.id === presetId) || null;
+    }
+}
+exports.PresetManager = PresetManager;

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

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