genai-lite 0.1.1 → 0.1.3

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

@@ -0,0 +1,281 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const genai_1 = require("@google/genai");
+const GeminiClientAdapter_1 = require("./GeminiClientAdapter");
+const types_1 = require("./types");
+// Mock the entire '@google/genai' module
+jest.mock('@google/genai');
+// Cast the mocked module to allow setting up mock implementations
+const MockGoogleGenAI = genai_1.GoogleGenAI;
+describe('GeminiClientAdapter', () => {
+    let adapter;
+    let mockGenerateContent;
+    let mockGetGenerativeModel;
+    let mockModel;
+    let basicRequest;
+    beforeEach(() => {
+        // Reset mocks before each test
+        MockGoogleGenAI.mockClear();
+        mockGenerateContent = jest.fn();
+        // Mock the models.generateContent method
+        MockGoogleGenAI.mockImplementation(() => ({
+            models: {
+                generateContent: mockGenerateContent
+            }
+        }));
+        adapter = new GeminiClientAdapter_1.GeminiClientAdapter();
+        basicRequest = {
+            providerId: 'gemini',
+            modelId: 'gemini-2.5-pro',
+            messages: [{ role: 'user', content: 'Hello' }],
+            settings: {
+                temperature: 0.7,
+                maxTokens: 100,
+                topP: 1,
+                frequencyPenalty: 0,
+                presencePenalty: 0,
+                stopSequences: [],
+                user: 'test-user',
+                geminiSafetySettings: [],
+                supportsSystemMessage: true
+            }
+        };
+    });
+    describe('sendMessage', () => {
+        it('should format the request correctly and call the Gemini API', async () => {
+            // Setup mock response - Gemini API returns the raw response without nesting
+            mockGenerateContent.mockResolvedValueOnce({
+                text: () => 'Hello! How can I help you today?',
+                candidates: [{
+                        finishReason: 'STOP',
+                        content: {
+                            parts: [{ text: 'Hello! How can I help you today?' }],
+                            role: 'model'
+                        }
+                    }],
+                usageMetadata: {
+                    promptTokenCount: 10,
+                    candidatesTokenCount: 20,
+                    totalTokenCount: 30
+                }
+            });
+            const response = await adapter.sendMessage(basicRequest, 'test-api-key');
+            // Verify GoogleGenAI was instantiated with the API key
+            expect(MockGoogleGenAI).toHaveBeenCalledWith({ apiKey: 'test-api-key' });
+            // Verify generateContent was called
+            expect(mockGenerateContent).toHaveBeenCalledTimes(1);
+            const callArgs = mockGenerateContent.mock.calls[0][0];
+            expect(callArgs.model).toBe('gemini-2.5-pro');
+            expect(callArgs.contents).toHaveLength(1);
+            expect(callArgs.contents[0].role).toBe('user');
+            // Verify the response
+            expect(response.object).toBe('chat.completion');
+            const successResponse = response;
+            expect(successResponse.provider).toBe('gemini');
+            expect(successResponse.model).toBe('gemini-2.5-pro');
+            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' }
+            ];
+            mockGenerateContent.mockResolvedValueOnce({
+                text: () => 'Hello!',
+                candidates: [{
+                        finishReason: 'STOP',
+                        content: { parts: [{ text: 'Hello!' }], role: 'model' }
+                    }],
+                usageMetadata: { promptTokenCount: 15, candidatesTokenCount: 5, totalTokenCount: 20 }
+            });
+            await adapter.sendMessage(basicRequest, 'test-api-key');
+            // System message should be passed as systemInstruction
+            expect(mockGenerateContent).toHaveBeenCalledWith({
+                model: 'gemini-2.5-pro',
+                contents: [{
+                        role: 'user',
+                        parts: [{ text: 'Hello' }]
+                    }],
+                config: {
+                    temperature: 0.7,
+                    maxOutputTokens: 100,
+                    topP: 1,
+                    safetySettings: [],
+                    systemInstruction: 'You are a helpful assistant.'
+                }
+            });
+        });
+        it('should handle multi-turn conversations with role mapping', async () => {
+            basicRequest.messages = [
+                { role: 'user', content: 'Hello' },
+                { role: 'assistant', content: 'Hi there!' },
+                { role: 'user', content: 'How are you?' }
+            ];
+            mockGenerateContent.mockResolvedValueOnce({
+                text: () => "I'm doing well!",
+                candidates: [{
+                        finishReason: 'STOP',
+                        content: { parts: [{ text: "I'm doing well!" }], role: 'model' }
+                    }],
+                usageMetadata: { promptTokenCount: 20, candidatesTokenCount: 10, totalTokenCount: 30 }
+            });
+            await adapter.sendMessage(basicRequest, 'test-api-key');
+            // Verify role mapping: assistant -> model
+            expect(mockGenerateContent).toHaveBeenCalledWith({
+                model: 'gemini-2.5-pro',
+                contents: [
+                    { role: 'user', parts: [{ text: 'Hello' }] },
+                    { role: 'model', parts: [{ text: 'Hi there!' }] },
+                    { role: 'user', parts: [{ text: 'How are you?' }] }
+                ],
+                config: {
+                    temperature: 0.7,
+                    maxOutputTokens: 100,
+                    topP: 1,
+                    safetySettings: []
+                }
+            });
+        });
+        it('should handle stop sequences', async () => {
+            basicRequest.settings.stopSequences = ['END', 'STOP'];
+            mockGenerateContent.mockResolvedValueOnce({
+                text: () => 'Response',
+                candidates: [{
+                        finishReason: 'STOP',
+                        content: { parts: [{ text: 'Response' }], role: 'model' }
+                    }]
+            });
+            await adapter.sendMessage(basicRequest, 'test-api-key');
+            expect(mockGenerateContent).toHaveBeenCalledWith(expect.objectContaining({
+                config: expect.objectContaining({
+                    stopSequences: ['END', 'STOP']
+                })
+            }));
+        });
+        it('should handle safety settings', async () => {
+            basicRequest.settings.geminiSafetySettings = [
+                { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_NONE' }
+            ];
+            mockGenerateContent.mockResolvedValueOnce({
+                text: () => 'Response',
+                candidates: [{
+                        finishReason: 'STOP',
+                        content: { parts: [{ text: 'Response' }], role: 'model' }
+                    }]
+            });
+            await adapter.sendMessage(basicRequest, 'test-api-key');
+            expect(mockGenerateContent).toHaveBeenCalledWith(expect.objectContaining({
+                config: expect.objectContaining({
+                    safetySettings: [
+                        { category: 'HARM_CATEGORY_HATE_SPEECH', threshold: 'BLOCK_NONE' }
+                    ]
+                })
+            }));
+        });
+        it('should map finish reasons correctly', async () => {
+            const finishReasons = [
+                { gemini: 'STOP', expected: 'stop' },
+                { gemini: 'MAX_TOKENS', expected: 'length' },
+                { gemini: 'SAFETY', expected: 'content_filter' },
+                { gemini: 'RECITATION', expected: 'content_filter' },
+                { gemini: 'OTHER', expected: 'other' },
+                { gemini: 'UNKNOWN', expected: 'other' }
+            ];
+            for (const { gemini, expected } of finishReasons) {
+                mockGenerateContent.mockResolvedValueOnce({
+                    text: () => 'Response',
+                    candidates: [{
+                            finishReason: gemini,
+                            content: { parts: [{ text: 'Response' }], role: 'model' }
+                        }]
+                });
+                const response = await adapter.sendMessage(basicRequest, 'test-api-key');
+                const successResponse = response;
+                expect(successResponse.choices[0].finish_reason).toBe(expected);
+            }
+        });
+        describe('error handling', () => {
+            it('should handle API key errors', async () => {
+                const apiError = new Error('API key not valid');
+                mockGenerateContent.mockRejectedValueOnce(apiError);
+                const response = await adapter.sendMessage(basicRequest, 'invalid-key');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.INVALID_API_KEY);
+                expect(errorResponse.error.type).toBe('authentication_error');
+            });
+            it('should handle safety/content filter errors', async () => {
+                const apiError = new Error('Response was blocked due to safety reasons');
+                mockGenerateContent.mockRejectedValueOnce(apiError);
+                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');
+            });
+            it('should handle quota exceeded errors', async () => {
+                const apiError = new Error('API rate limit exceeded');
+                mockGenerateContent.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 model not found errors', async () => {
+                const apiError = new Error('Model not found');
+                apiError.status = 404;
+                mockGenerateContent.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 permission errors', async () => {
+                const apiError = new Error('Invalid API key provided');
+                mockGenerateContent.mockRejectedValueOnce(apiError);
+                const response = await adapter.sendMessage(basicRequest, 'test-key');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe(types_1.ADAPTER_ERROR_CODES.INVALID_API_KEY);
+                expect(errorResponse.error.type).toBe('authentication_error');
+            });
+            it('should handle generic errors', async () => {
+                const apiError = new Error('Unknown error');
+                mockGenerateContent.mockRejectedValueOnce(apiError);
+                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');
+            });
+            it('should handle empty response as success with empty content', async () => {
+                mockGenerateContent.mockResolvedValueOnce({
+                    text: () => '',
+                    candidates: []
+                });
+                const response = await adapter.sendMessage(basicRequest, 'test-key');
+                // Empty responses are returned as success with empty content
+                const successResponse = response;
+                expect(successResponse.object).toBe('chat.completion');
+                expect(successResponse.choices[0].message.content).toBe('');
+            });
+        });
+    });
+    describe('validateApiKey', () => {
+        it('should validate API key format', () => {
+            // Gemini API keys must start with 'AIza' and be at least 35 chars
+            expect(adapter.validateApiKey('AIzaSyABCDEFGHIJKLMNOPQRSTUVWXYZ123456')).toBe(true);
+            expect(adapter.validateApiKey('AIzaABCDEFGHIJKLMNOPQRSTUVWXYZ12345')).toBe(true);
+            // Invalid formats
+            expect(adapter.validateApiKey('')).toBe(false);
+            expect(adapter.validateApiKey('short')).toBe(false); // Too short
+            expect(adapter.validateApiKey('abcdef123456')).toBe(false); // Wrong prefix
+        });
+    });
+    describe('getAdapterInfo', () => {
+        it('should return correct adapter information', () => {
+            const info = adapter.getAdapterInfo();
+            expect(info.providerId).toBe('gemini');
+            expect(info.name).toBe('Gemini Client Adapter');
+            expect(info.version).toBeDefined();
+            // supportedModels is not part of the interface
+        });
+    });
+});

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

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

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

@@ -0,0 +1,240 @@
+"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
+            }
+        };
+    });
+    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

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