genai-lite 0.4.0 → 0.4.2

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

@@ -1,258 +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 openai_1 = __importDefault(require("openai"));
-const OpenAIClientAdapter_1 = require("./OpenAIClientAdapter");
-const types_1 = require("./types");
-// Mock the entire 'openai' module
-jest.mock('openai');
-// Cast the mocked module to allow setting up mock implementations
-const MockOpenAI = openai_1.default;
-describe('OpenAIClientAdapter', () => {
-    let adapter;
-    let mockCreate;
-    let basicRequest;
-    beforeEach(() => {
-        // Reset mocks before each test
-        MockOpenAI.mockClear();
-        mockCreate = jest.fn();
-        // Mock the chat.completions.create method
-        MockOpenAI.prototype.chat = {
-            completions: {
-                create: mockCreate,
-            },
-        };
-        adapter = new OpenAIClientAdapter_1.OpenAIClientAdapter();
-        basicRequest = {
-            providerId: 'openai',
-            modelId: 'gpt-4.1',
-            messages: [{ role: 'user', content: 'Hello' }],
-            settings: {
-                temperature: 0.7,
-                maxTokens: 100,
-                topP: 1,
-                frequencyPenalty: 0,
-                presencePenalty: 0,
-                stopSequences: [],
-                user: 'test-user',
-                geminiSafetySettings: [],
-                supportsSystemMessage: true,
-                reasoning: {
-                    enabled: false,
-                    effort: undefined,
-                    maxTokens: undefined,
-                    exclude: false
-                },
-                thinkingExtraction: {
-                    enabled: true,
-                    tag: 'thinking'
-                }
-            }
-        };
-    });
-    describe('sendMessage', () => {
-        it('should format the request correctly and call the OpenAI API', async () => {
-            // Setup mock response
-            mockCreate.mockResolvedValueOnce({
-                id: 'chatcmpl-123',
-                object: 'chat.completion',
-                created: 1234567890,
-                model: 'gpt-4.1',
-                choices: [{
-                        index: 0,
-                        message: {
-                            role: 'assistant',
-                            content: 'Hello! How can I help you today?'
-                        },
-                        finish_reason: 'stop'
-                    }],
-                usage: {
-                    prompt_tokens: 10,
-                    completion_tokens: 20,
-                    total_tokens: 30
-                }
-            });
-            const response = await adapter.sendMessage(basicRequest, 'test-api-key');
-            // Verify OpenAI was instantiated with the API key
-            expect(MockOpenAI).toHaveBeenCalledWith({
-                apiKey: 'test-api-key',
-                baseURL: undefined
-            });
-            // Verify the create method was called with correct parameters
-            expect(mockCreate).toHaveBeenCalledWith({
-                model: 'gpt-4.1',
-                messages: [{ role: 'user', content: 'Hello' }],
-                temperature: 0.7,
-                max_completion_tokens: 100,
-                top_p: 1,
-                user: 'test-user'
-            });
-            // Verify the response
-            expect(response.object).toBe('chat.completion');
-            const successResponse = response;
-            expect(successResponse.id).toBe('chatcmpl-123');
-            expect(successResponse.provider).toBe('openai');
-            expect(successResponse.model).toBe('gpt-4.1');
-            expect(successResponse.choices[0].message.content).toBe('Hello! How can I help you today?');
-            expect(successResponse.usage?.total_tokens).toBe(30);
-        });
-        it('should handle system messages correctly', async () => {
-            basicRequest.messages = [
-                { role: 'system', content: 'You are a helpful assistant.' },
-                { role: 'user', content: 'Hello' }
-            ];
-            mockCreate.mockResolvedValueOnce({
-                id: 'chatcmpl-123',
-                object: 'chat.completion',
-                created: 1234567890,
-                model: 'gpt-4.1',
-                choices: [{
-                        index: 0,
-                        message: { role: 'assistant', content: 'Hello!' },
-                        finish_reason: 'stop'
-                    }]
-            });
-            await adapter.sendMessage(basicRequest, 'test-api-key');
-            expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
-                messages: [
-                    { role: 'system', content: 'You are a helpful assistant.' },
-                    { role: 'user', content: 'Hello' }
-                ]
-            }));
-        });
-        it('should handle stop sequences correctly', async () => {
-            basicRequest.settings.stopSequences = ['END', 'STOP'];
-            mockCreate.mockResolvedValueOnce({
-                id: 'chatcmpl-123',
-                object: 'chat.completion',
-                created: 1234567890,
-                model: 'gpt-4.1',
-                choices: [{
-                        index: 0,
-                        message: { role: 'assistant', content: 'Response' },
-                        finish_reason: 'stop'
-                    }]
-            });
-            await adapter.sendMessage(basicRequest, 'test-api-key');
-            expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
-                stop: ['END', 'STOP']
-            }));
-        });
-        it('should use custom baseURL when provided', async () => {
-            const customAdapter = new OpenAIClientAdapter_1.OpenAIClientAdapter({ baseURL: 'https://custom.api.com' });
-            mockCreate.mockResolvedValueOnce({
-                id: 'chatcmpl-123',
-                object: 'chat.completion',
-                created: 1234567890,
-                model: 'gpt-4.1',
-                choices: [{
-                        index: 0,
-                        message: { role: 'assistant', content: 'Response' },
-                        finish_reason: 'stop'
-                    }]
-            });
-            await customAdapter.sendMessage(basicRequest, 'test-api-key');
-            expect(MockOpenAI).toHaveBeenCalledWith({
-                apiKey: 'test-api-key',
-                baseURL: 'https://custom.api.com'
-            });
-        });
-        describe('error handling', () => {
-            it('should handle authentication errors (401)', async () => {
-                const apiError = new Error('Invalid API key');
-                apiError.status = 401;
-                mockCreate.mockRejectedValueOnce(apiError);
-                const response = await adapter.sendMessage(basicRequest, 'invalid-key');
-                expect(response.object).toBe('error');
-                const errorResponse = response;
-                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.INVALID_API_KEY);
-                expect(errorResponse.error.type).toBe('authentication_error');
-                expect(errorResponse.error.message).toContain('Invalid API key');
-            });
-            it('should handle rate limit errors (429)', async () => {
-                const apiError = new Error('Rate limit exceeded');
-                apiError.status = 429;
-                mockCreate.mockRejectedValueOnce(apiError);
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const errorResponse = response;
-                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.RATE_LIMIT_EXCEEDED);
-                expect(errorResponse.error.type).toBe('rate_limit_error');
-            });
-            it('should handle insufficient quota errors (429 with specific message)', async () => {
-                const apiError = new Error('You exceeded your current quota, please check your plan and billing details');
-                apiError.status = 429;
-                mockCreate.mockRejectedValueOnce(apiError);
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const errorResponse = response;
-                // Without special handling for quota messages, this is just a rate limit error
-                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.RATE_LIMIT_EXCEEDED);
-                expect(errorResponse.error.type).toBe('rate_limit_error');
-            });
-            it('should handle context length errors (400)', async () => {
-                const apiError = new Error("This model's maximum context length is 4096 tokens");
-                apiError.status = 400;
-                // Mock it as an OpenAI APIError
-                Object.setPrototypeOf(apiError, openai_1.default.APIError.prototype);
-                mockCreate.mockRejectedValueOnce(apiError);
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const errorResponse = response;
-                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.CONTEXT_LENGTH_EXCEEDED);
-                expect(errorResponse.error.type).toBe('invalid_request_error');
-            });
-            it('should handle model not found errors (404)', async () => {
-                const apiError = new Error('The model does not exist');
-                apiError.status = 404;
-                mockCreate.mockRejectedValueOnce(apiError);
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const errorResponse = response;
-                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.MODEL_NOT_FOUND);
-                expect(errorResponse.error.type).toBe('invalid_request_error');
-            });
-            it('should handle server errors (500)', async () => {
-                const apiError = new Error('Internal server error');
-                apiError.status = 500;
-                mockCreate.mockRejectedValueOnce(apiError);
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const errorResponse = response;
-                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR);
-                expect(errorResponse.error.type).toBe('server_error');
-            });
-            it('should handle network errors', async () => {
-                const networkError = new Error('Network error');
-                networkError.code = 'ECONNREFUSED';
-                mockCreate.mockRejectedValueOnce(networkError);
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const errorResponse = response;
-                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.NETWORK_ERROR);
-                expect(errorResponse.error.type).toBe('connection_error');
-            });
-            it('should handle unknown errors', async () => {
-                mockCreate.mockRejectedValueOnce(new Error('Unknown error'));
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const errorResponse = response;
-                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.UNKNOWN_ERROR);
-                expect(errorResponse.error.message).toContain('Unknown error');
-            });
-        });
-    });
-    describe('validateApiKey', () => {
-        it('should validate API key format', () => {
-            expect(adapter.validateApiKey('sk-test123456789012345678')).toBe(true);
-            expect(adapter.validateApiKey('sk-proj-test123456789012')).toBe(true);
-            expect(adapter.validateApiKey('invalid')).toBe(false);
-            expect(adapter.validateApiKey('')).toBe(false);
-            expect(adapter.validateApiKey('sk-short')).toBe(false); // Too short
-        });
-    });
-    describe('getAdapterInfo', () => {
-        it('should return correct adapter information', () => {
-            const info = adapter.getAdapterInfo();
-            expect(info.providerId).toBe('openai');
-            expect(info.name).toBe('OpenAI Client Adapter');
-            expect(info.version).toBeDefined();
-            // supportedModels is not part of the interface
-        });
-    });
-});

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

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

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

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const adapterErrorUtils_1 = require("./adapterErrorUtils");
-const types_1 = require("./types");
-describe('adapterErrorUtils', () => {
-    describe('getCommonMappedErrorDetails', () => {
-        it('should map 400 status to provider error', () => {
-            const error = { status: 400, message: 'Bad request' };
-            const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error);
-            expect(result.errorCode).toBe(types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR);
-            expect(result.errorType).toBe('invalid_request_error');
-            expect(result.errorMessage).toBe('Bad request');
-            expect(result.status).toBe(400);
-        });
-        it('should map 401 status to invalid API key', () => {
-            const error = { status: 401, message: 'Unauthorized' };
-            const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error);
-            expect(result.errorCode).toBe(types_1.ADAPTER_ERROR_CODES.INVALID_API_KEY);
-            expect(result.errorType).toBe('authentication_error');
-            expect(result.errorMessage).toBe('Unauthorized');
-            expect(result.status).toBe(401);
-        });
-        it('should map 402 status to insufficient credits', () => {
-            const error = { status: 402, message: 'Payment required' };
-            const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error);
-            expect(result.errorCode).toBe(types_1.ADAPTER_ERROR_CODES.INSUFFICIENT_CREDITS);
-            expect(result.errorType).toBe('rate_limit_error');
-            expect(result.errorMessage).toBe('Payment required');
-            expect(result.status).toBe(402);
-        });
-        it('should map 404 status to model not found', () => {
-            const error = { status: 404, message: 'Not found' };
-            const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error);
-            expect(result.errorCode).toBe(types_1.ADAPTER_ERROR_CODES.MODEL_NOT_FOUND);
-            expect(result.errorType).toBe('invalid_request_error');
-            expect(result.errorMessage).toBe('Not found');
-            expect(result.status).toBe(404);
-        });
-        it('should map 429 status to rate limit exceeded', () => {
-            const error = { status: 429, message: 'Too many requests' };
-            const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error);
-            expect(result.errorCode).toBe(types_1.ADAPTER_ERROR_CODES.RATE_LIMIT_EXCEEDED);
-            expect(result.errorType).toBe('rate_limit_error');
-            expect(result.errorMessage).toBe('Too many requests');
-            expect(result.status).toBe(429);
-        });
-        it('should map 5xx status codes to provider error', () => {
-            const testCases = [500, 502, 503, 504];
-            testCases.forEach(status => {
-                const error = { status, message: `Server error ${status}` };
-                const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error);
-                expect(result.errorCode).toBe(types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR);
-                expect(result.errorType).toBe('server_error');
-                expect(result.errorMessage).toBe(`Server error ${status}`);
-                expect(result.status).toBe(status);
-            });
-        });
-        it('should map other 4xx status codes to provider error', () => {
-            const error = { status: 403, message: 'Forbidden' };
-            const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error);
-            expect(result.errorCode).toBe(types_1.ADAPTER_ERROR_CODES.PROVIDER_ERROR);
-            expect(result.errorType).toBe('invalid_request_error');
-            expect(result.errorMessage).toBe('Forbidden');
-            expect(result.status).toBe(403);
-        });
-        it('should map network errors to network error', () => {
-            const networkErrors = [
-                { code: 'ENOTFOUND', message: 'DNS lookup failed' },
-                { code: 'ECONNREFUSED', message: 'Connection refused' },
-                { code: 'ETIMEDOUT', message: 'Request timed out' },
-                { name: 'ConnectTimeoutError', message: 'Connection timeout' },
-                { type: 'request-timeout', message: 'Request timeout' }
-            ];
-            networkErrors.forEach(error => {
-                const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error);
-                expect(result.errorCode).toBe(types_1.ADAPTER_ERROR_CODES.NETWORK_ERROR);
-                expect(result.errorType).toBe('connection_error');
-                expect(result.errorMessage).toBe(error.message);
-                expect(result.status).toBeUndefined();
-            });
-        });
-        it('should handle generic Error instances', () => {
-            const error = new Error('Something went wrong');
-            const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error);
-            expect(result.errorCode).toBe(types_1.ADAPTER_ERROR_CODES.UNKNOWN_ERROR);
-            expect(result.errorType).toBe('client_error');
-            expect(result.errorMessage).toBe('Something went wrong');
-            expect(result.status).toBeUndefined();
-        });
-        it('should handle unknown error types', () => {
-            const testCases = [
-                null,
-                undefined,
-                'string error',
-                123,
-                { random: 'object' }
-            ];
-            testCases.forEach(error => {
-                const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error);
-                expect(result.errorCode).toBe(types_1.ADAPTER_ERROR_CODES.UNKNOWN_ERROR);
-                expect(result.errorType).toBe('server_error');
-                expect(result.errorMessage).toBe('Unknown error occurred');
-                expect(result.status).toBeUndefined();
-            });
-        });
-        it('should use provider message override when provided', () => {
-            const error = { status: 400, message: 'Original message' };
-            const override = 'Custom error message';
-            const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error, override);
-            expect(result.errorMessage).toBe(override);
-        });
-        it('should handle errors without message property', () => {
-            const error = { status: 400 };
-            const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error);
-            expect(result.errorMessage).toBe('HTTP 400 error');
-        });
-        it('should handle errors with empty message', () => {
-            const error = { status: 400, message: '' };
-            const result = (0, adapterErrorUtils_1.getCommonMappedErrorDetails)(error);
-            expect(result.errorMessage).toBe('HTTP 400 error');
-        });
-    });
-});

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

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

package/dist/llm/config.test.js

@@ -1,176 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const config_1 = require("./config");
-describe('LLM Config', () => {
-    describe('isProviderSupported', () => {
-        it('should correctly identify supported providers', () => {
-            expect((0, config_1.isProviderSupported)('openai')).toBe(true);
-            expect((0, config_1.isProviderSupported)('anthropic')).toBe(true);
-            expect((0, config_1.isProviderSupported)('gemini')).toBe(true);
-        });
-        it('should return false for unsupported providers', () => {
-            expect((0, config_1.isProviderSupported)('unsupported-provider')).toBe(false);
-            expect((0, config_1.isProviderSupported)('')).toBe(false);
-        });
-    });
-    describe('getProviderById', () => {
-        it('should return provider info for valid providers', () => {
-            const openaiProvider = (0, config_1.getProviderById)('openai');
-            expect(openaiProvider).toBeDefined();
-            expect(openaiProvider?.id).toBe('openai');
-            expect(openaiProvider?.name).toBe('OpenAI');
-        });
-        it('should return undefined for invalid providers', () => {
-            expect((0, config_1.getProviderById)('unsupported-provider')).toBeUndefined();
-            expect((0, config_1.getProviderById)('')).toBeUndefined();
-        });
-    });
-    describe('getModelById', () => {
-        it('should return model info for valid model and provider combination', () => {
-            const model = (0, config_1.getModelById)('gpt-4.1', 'openai');
-            expect(model).toBeDefined();
-            expect(model?.id).toBe('gpt-4.1');
-            expect(model?.providerId).toBe('openai');
-        });
-        it('should return undefined for invalid model or provider', () => {
-            expect((0, config_1.getModelById)('invalid-model', 'openai')).toBeUndefined();
-            expect((0, config_1.getModelById)('gpt-4.1', 'anthropic')).toBeUndefined();
-            expect((0, config_1.getModelById)('gpt-4.1', 'invalid-provider')).toBeUndefined();
-        });
-    });
-    describe('getModelsByProvider', () => {
-        it('should return models for valid providers', () => {
-            const openaiModels = (0, config_1.getModelsByProvider)('openai');
-            expect(openaiModels.length).toBeGreaterThan(0);
-            expect(openaiModels.every(model => model.providerId === 'openai')).toBe(true);
-        });
-        it('should return empty array for invalid providers', () => {
-            expect((0, config_1.getModelsByProvider)('invalid-provider')).toEqual([]);
-            expect((0, config_1.getModelsByProvider)('')).toEqual([]);
-        });
-    });
-    describe('isModelSupported', () => {
-        it('should correctly identify supported model/provider combinations', () => {
-            expect((0, config_1.isModelSupported)('gpt-4.1', 'openai')).toBe(true);
-            expect((0, config_1.isModelSupported)('claude-sonnet-4-20250514', 'anthropic')).toBe(true);
-            expect((0, config_1.isModelSupported)('gemini-2.5-pro', 'gemini')).toBe(true);
-        });
-        it('should return false for unsupported combinations', () => {
-            expect((0, config_1.isModelSupported)('gpt-4.1', 'anthropic')).toBe(false);
-            expect((0, config_1.isModelSupported)('claude-sonnet-4-20250514', 'openai')).toBe(false);
-            expect((0, config_1.isModelSupported)('invalid-model', 'openai')).toBe(false);
-        });
-    });
-    describe('getDefaultSettingsForModel', () => {
-        it('should return default settings for valid models', () => {
-            const settings = (0, config_1.getDefaultSettingsForModel)('gpt-4.1', 'openai');
-            expect(settings).toBeDefined();
-            expect(settings.temperature).toBeDefined();
-            expect(settings.maxTokens).toBeDefined();
-            expect(settings.topP).toBeDefined();
-        });
-        it('should apply model-specific overrides', () => {
-            const gpt4Settings = (0, config_1.getDefaultSettingsForModel)('gpt-4.1', 'openai');
-            const gpt4MiniSettings = (0, config_1.getDefaultSettingsForModel)('gpt-4.1-mini', 'openai');
-            // These might have different maxTokens based on model capabilities
-            expect(gpt4Settings.maxTokens).toBeDefined();
-            expect(gpt4MiniSettings.maxTokens).toBeDefined();
-        });
-    });
-    describe('validateLLMSettings', () => {
-        it('should return empty array for valid settings', () => {
-            const validSettings = {
-                temperature: 0.7,
-                maxTokens: 1000,
-                topP: 0.9,
-                frequencyPenalty: 0.5,
-                presencePenalty: -0.5,
-                stopSequences: ['\\n', 'END'],
-                user: 'test-user'
-            };
-            expect((0, config_1.validateLLMSettings)(validSettings)).toEqual([]);
-        });
-        it('should validate temperature bounds', () => {
-            expect((0, config_1.validateLLMSettings)({ temperature: -0.1 })).toContain('temperature must be a number between 0 and 2');
-            expect((0, config_1.validateLLMSettings)({ temperature: 2.1 })).toContain('temperature must be a number between 0 and 2');
-            expect((0, config_1.validateLLMSettings)({ temperature: 'invalid' })).toContain('temperature must be a number between 0 and 2');
-        });
-        it('should validate maxTokens', () => {
-            expect((0, config_1.validateLLMSettings)({ maxTokens: 0 })).toContain('maxTokens must be an integer between 1 and 100000');
-            expect((0, config_1.validateLLMSettings)({ maxTokens: 100001 })).toContain('maxTokens must be an integer between 1 and 100000');
-            expect((0, config_1.validateLLMSettings)({ maxTokens: 1.5 })).toContain('maxTokens must be an integer between 1 and 100000');
-        });
-        it('should validate topP bounds', () => {
-            expect((0, config_1.validateLLMSettings)({ topP: -0.1 })).toContain('topP must be a number between 0 and 1');
-            expect((0, config_1.validateLLMSettings)({ topP: 1.1 })).toContain('topP must be a number between 0 and 1');
-        });
-        it('should validate frequencyPenalty bounds', () => {
-            expect((0, config_1.validateLLMSettings)({ frequencyPenalty: -2.1 })).toContain('frequencyPenalty must be a number between -2 and 2');
-            expect((0, config_1.validateLLMSettings)({ frequencyPenalty: 2.1 })).toContain('frequencyPenalty must be a number between -2 and 2');
-        });
-        it('should validate presencePenalty bounds', () => {
-            expect((0, config_1.validateLLMSettings)({ presencePenalty: -2.1 })).toContain('presencePenalty must be a number between -2 and 2');
-            expect((0, config_1.validateLLMSettings)({ presencePenalty: 2.1 })).toContain('presencePenalty must be a number between -2 and 2');
-        });
-        it('should validate stopSequences', () => {
-            expect((0, config_1.validateLLMSettings)({ stopSequences: 'invalid' })).toContain('stopSequences must be an array');
-            expect((0, config_1.validateLLMSettings)({ stopSequences: ['1', '2', '3', '4', '5'] })).toContain('stopSequences can contain at most 4 sequences');
-            expect((0, config_1.validateLLMSettings)({ stopSequences: ['valid', ''] })).toContain('stopSequences must contain only non-empty strings');
-            expect((0, config_1.validateLLMSettings)({ stopSequences: ['valid', 123] })).toContain('stopSequences must contain only non-empty strings');
-        });
-        it('should validate user field', () => {
-            expect((0, config_1.validateLLMSettings)({ user: 123 })).toContain('user must be a string');
-        });
-        it('should validate geminiSafetySettings', () => {
-            const invalidSettings = { geminiSafetySettings: 'invalid' };
-            expect((0, config_1.validateLLMSettings)(invalidSettings)).toContain('geminiSafetySettings must be an array');
-            const invalidCategory = {
-                geminiSafetySettings: [
-                    { category: 'INVALID_CATEGORY', threshold: 'BLOCK_NONE' }
-                ]
-            };
-            expect((0, config_1.validateLLMSettings)(invalidCategory)).toContain('geminiSafetySettings[0].category must be a valid Gemini harm category');
-            const invalidThreshold = {
-                geminiSafetySettings: [
-                    { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'INVALID_THRESHOLD' }
-                ]
-            };
-            expect((0, config_1.validateLLMSettings)(invalidThreshold)).toContain('geminiSafetySettings[0].threshold must be a valid Gemini harm block threshold');
-            const validGeminiSettings = {
-                geminiSafetySettings: [
-                    { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_NONE' }
-                ]
-            };
-            expect((0, config_1.validateLLMSettings)(validGeminiSettings)).toEqual([]);
-        });
-        it('should validate reasoning settings', () => {
-            // Invalid reasoning object
-            expect((0, config_1.validateLLMSettings)({ reasoning: 'invalid' })).toContain('reasoning must be an object');
-            // Invalid enabled value
-            expect((0, config_1.validateLLMSettings)({ reasoning: { enabled: 'yes' } })).toContain('reasoning.enabled must be a boolean');
-            // Invalid effort value
-            expect((0, config_1.validateLLMSettings)({ reasoning: { effort: 'maximum' } })).toContain("reasoning.effort must be 'high', 'medium', or 'low'");
-            expect((0, config_1.validateLLMSettings)({ reasoning: { effort: 'high' } })).toEqual([]);
-            // Invalid maxTokens value
-            expect((0, config_1.validateLLMSettings)({ reasoning: { maxTokens: -100 } })).toContain('reasoning.maxTokens must be a non-negative integer');
-            expect((0, config_1.validateLLMSettings)({ reasoning: { maxTokens: 1.5 } })).toContain('reasoning.maxTokens must be a non-negative integer');
-            expect((0, config_1.validateLLMSettings)({ reasoning: { maxTokens: 5000 } })).toEqual([]);
-            // Invalid exclude value
-            expect((0, config_1.validateLLMSettings)({ reasoning: { exclude: 'yes' } })).toContain('reasoning.exclude must be a boolean');
-            // Valid reasoning settings
-            expect((0, config_1.validateLLMSettings)({ reasoning: { enabled: true, effort: 'medium', maxTokens: 10000, exclude: false } })).toEqual([]);
-        });
-        it('should return multiple errors for multiple invalid fields', () => {
-            const invalidSettings = {
-                temperature: -1,
-                maxTokens: 0,
-                topP: 2
-            };
-            const errors = (0, config_1.validateLLMSettings)(invalidSettings);
-            expect(errors).toHaveLength(3);
-            expect(errors).toContain('temperature must be a number between 0 and 2');
-            expect(errors).toContain('maxTokens must be an integer between 1 and 100000');
-            expect(errors).toContain('topP must be a number between 0 and 1');
-        });
-    });
-});

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

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