genai-lite 0.3.3 → 0.4.1

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

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

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

@@ -1,250 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const MockClientAdapter_1 = require("./MockClientAdapter");
-const types_1 = require("./types");
-describe('MockClientAdapter', () => {
-    let adapter;
-    let basicRequest;
-    beforeEach(() => {
-        adapter = new MockClientAdapter_1.MockClientAdapter('openai');
-        basicRequest = {
-            providerId: 'openai',
-            modelId: 'mock-model',
-            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 return a successful response for basic messages', async () => {
-            const response = await adapter.sendMessage(basicRequest, 'test-key');
-            expect(response.object).toBe('chat.completion');
-            expect('error' in response).toBe(false);
-            const successResponse = response;
-            expect(successResponse.provider).toBe('openai');
-            expect(successResponse.model).toBe('mock-model');
-            expect(successResponse.choices).toHaveLength(1);
-            expect(successResponse.choices[0].message.role).toBe('assistant');
-            expect(successResponse.choices[0].message.content).toContain('Hello');
-            expect(successResponse.usage).toBeDefined();
-            expect(successResponse.usage?.total_tokens).toBeGreaterThan(0);
-        });
-        describe('error simulations', () => {
-            it('should simulate invalid API key error', async () => {
-                basicRequest.messages[0].content = 'error_invalid_key';
-                const response = await adapter.sendMessage(basicRequest, 'test-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.status).toBe(401);
-            });
-            it('should simulate rate limit error', async () => {
-                basicRequest.messages[0].content = 'error_rate_limit';
-                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');
-                expect(errorResponse.error.status).toBe(429);
-            });
-            it('should simulate insufficient credits error', async () => {
-                basicRequest.messages[0].content = 'error_credits';
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const errorResponse = response;
-                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.INSUFFICIENT_CREDITS);
-                expect(errorResponse.error.type).toBe('rate_limit_error');
-                expect(errorResponse.error.status).toBe(402);
-            });
-            it('should simulate context length exceeded error', async () => {
-                basicRequest.messages[0].content = 'error_context_length';
-                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');
-                expect(errorResponse.error.status).toBe(400);
-            });
-            it('should simulate model not found error', async () => {
-                basicRequest.messages[0].content = 'error_model_not_found';
-                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');
-                expect(errorResponse.error.status).toBe(404);
-            });
-            it('should simulate content filter error', async () => {
-                basicRequest.messages[0].content = 'error_content_filter';
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const errorResponse = response;
-                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.CONTENT_FILTER);
-                expect(errorResponse.error.type).toBe('content_filter_error');
-                expect(errorResponse.error.status).toBe(400);
-            });
-            it('should simulate network error', async () => {
-                basicRequest.messages[0].content = 'error_network';
-                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');
-                // Status is not included when it's 0
-                expect(errorResponse.error.status).toBeUndefined();
-            });
-            it('should simulate generic provider error', async () => {
-                basicRequest.messages[0].content = 'error_generic';
-                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');
-                expect(errorResponse.error.status).toBe(500);
-            });
-        });
-        describe('temperature effects', () => {
-            it('should generate low temperature response', async () => {
-                basicRequest.messages[0].content = 'test_temperature';
-                basicRequest.settings.temperature = 0.2;
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const successResponse = response;
-                expect(successResponse.choices[0].message.content).toContain('Low temperature');
-                expect(successResponse.choices[0].message.content).toContain('deterministic');
-            });
-            it('should generate high temperature response', async () => {
-                basicRequest.messages[0].content = 'test_temperature';
-                basicRequest.settings.temperature = 0.9;
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const successResponse = response;
-                expect(successResponse.choices[0].message.content).toContain('High temperature');
-                expect(successResponse.choices[0].message.content).toContain('creative');
-            });
-            it('should generate moderate temperature response', async () => {
-                basicRequest.messages[0].content = 'test_temperature';
-                basicRequest.settings.temperature = 0.5;
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const successResponse = response;
-                expect(successResponse.choices[0].message.content).toContain('Moderate temperature');
-                expect(successResponse.choices[0].message.content).toContain('balances');
-            });
-        });
-        describe('settings effects', () => {
-            it('should respect maxTokens limit', async () => {
-                basicRequest.messages[0].content = 'long detailed response please';
-                basicRequest.settings.maxTokens = 10; // Very low limit
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const successResponse = response;
-                const content = successResponse.choices[0].message.content;
-                const wordCount = content.split(' ').length;
-                expect(wordCount).toBeLessThanOrEqual(10); // Should be truncated
-                expect(content).toContain('...');
-            });
-            it('should respect stop sequences', async () => {
-                basicRequest.messages[0].content = 'Hello world! This is a test. STOP More content here.';
-                basicRequest.settings.stopSequences = ['STOP'];
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const successResponse = response;
-                const content = successResponse.choices[0].message.content;
-                expect(content).not.toContain('More content here');
-            });
-            it('should generate settings test response', async () => {
-                basicRequest.messages[0].content = 'test_settings';
-                basicRequest.settings.stopSequences = []; // Empty stop sequences to avoid truncation
-                basicRequest.settings.frequencyPenalty = 0.5;
-                basicRequest.settings.presencePenalty = -0.5;
-                basicRequest.settings.maxTokens = 500;
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const successResponse = response;
-                const content = successResponse.choices[0].message.content;
-                expect(content).toContain('Temperature: 0.7');
-                expect(content).toContain('Max Tokens: 500');
-                expect(content).toContain('Stop Sequences: none'); // When empty, it shows "none"
-                expect(content).toContain('Frequency Penalty: 0.5');
-                expect(content).toContain('Presence Penalty: -0.5');
-            });
-        });
-        describe('content-based responses', () => {
-            it('should generate greeting response', async () => {
-                basicRequest.messages[0].content = 'hello';
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const successResponse = response;
-                expect(successResponse.choices[0].message.content).toContain('Hello!');
-                expect(successResponse.choices[0].message.content).toContain('mock LLM assistant');
-            });
-            it('should generate weather response', async () => {
-                basicRequest.messages[0].content = 'What is the weather today?';
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const successResponse = response;
-                expect(successResponse.choices[0].message.content).toContain('weather');
-                expect(successResponse.choices[0].message.content).toContain('72°F');
-            });
-            it('should generate code response', async () => {
-                basicRequest.messages[0].content = 'Show me some code';
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const successResponse = response;
-                expect(successResponse.choices[0].message.content).toContain('```javascript');
-                expect(successResponse.choices[0].message.content).toContain('mockFunction');
-            });
-            it('should generate long response', async () => {
-                basicRequest.messages[0].content = 'Give me a long detailed explanation';
-                basicRequest.settings.maxTokens = 1000; // Allow long response
-                const response = await adapter.sendMessage(basicRequest, 'test-key');
-                const successResponse = response;
-                const content = successResponse.choices[0].message.content;
-                expect(content.length).toBeGreaterThan(500);
-                expect(content).toContain('Error Simulation');
-                expect(content).toContain('Variable Length');
-            });
-        });
-        it('should generate unique IDs for each response', async () => {
-            const response1 = await adapter.sendMessage(basicRequest, 'test-key');
-            const response2 = await adapter.sendMessage(basicRequest, 'test-key');
-            expect(response1.id).not.toBe(response2.id);
-        });
-        it('should calculate token usage', async () => {
-            basicRequest.messages[0].content = 'Calculate tokens for this message';
-            const response = await adapter.sendMessage(basicRequest, 'test-key');
-            const successResponse = response;
-            expect(successResponse.usage?.prompt_tokens).toBeGreaterThan(0);
-            expect(successResponse.usage?.completion_tokens).toBeGreaterThan(0);
-            expect(successResponse.usage?.total_tokens).toBe((successResponse.usage?.prompt_tokens ?? 0) + (successResponse.usage?.completion_tokens ?? 0));
-        });
-    });
-    describe('validateApiKey', () => {
-        it('should return true for non-empty API keys', () => {
-            expect(adapter.validateApiKey('valid-key')).toBe(true);
-            expect(adapter.validateApiKey('a')).toBe(true);
-        });
-        it('should return false for empty API keys', () => {
-            expect(adapter.validateApiKey('')).toBe(false);
-        });
-    });
-    describe('getAdapterInfo', () => {
-        it('should return correct adapter information', () => {
-            const info = adapter.getAdapterInfo();
-            expect(info.providerId).toBe('openai');
-            expect(info.name).toBe('Mock Client Adapter');
-            expect(info.version).toBe('1.0.0');
-            expect(info.supportedModels).toEqual(['mock-model-1', 'mock-model-2']);
-        });
-        it('should use custom provider ID', () => {
-            const customAdapter = new MockClientAdapter_1.MockClientAdapter('anthropic');
-            const info = customAdapter.getAdapterInfo();
-            expect(info.providerId).toBe('anthropic');
-        });
-    });
-});

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

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

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