genai-lite 0.1.1 → 0.1.4

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

@@ -0,0 +1,263 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const AnthropicClientAdapter_1 = require("./AnthropicClientAdapter");
+const types_1 = require("./types");
+// Mock the entire '@anthropic-ai/sdk' module
+jest.mock('@anthropic-ai/sdk');
+// Cast the mocked module to allow setting up mock implementations
+const MockAnthropic = sdk_1.default;
+describe('AnthropicClientAdapter', () => {
+    let adapter;
+    let mockCreate;
+    let basicRequest;
+    beforeEach(() => {
+        // Reset mocks before each test
+        MockAnthropic.mockClear();
+        mockCreate = jest.fn();
+        // Mock the messages.create method
+        MockAnthropic.prototype.messages = {
+            create: mockCreate,
+        };
+        adapter = new AnthropicClientAdapter_1.AnthropicClientAdapter();
+        basicRequest = {
+            providerId: 'anthropic',
+            modelId: 'claude-3-5-sonnet-20241022',
+            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 Anthropic API', async () => {
+            // Setup mock response
+            mockCreate.mockResolvedValueOnce({
+                id: 'msg_123',
+                type: 'message',
+                role: 'assistant',
+                model: 'claude-3-5-sonnet-20241022',
+                content: [{
+                        type: 'text',
+                        text: 'Hello! How can I help you today?'
+                    }],
+                stop_reason: 'end_turn',
+                stop_sequence: null,
+                usage: {
+                    input_tokens: 10,
+                    output_tokens: 20
+                }
+            });
+            const response = await adapter.sendMessage(basicRequest, 'test-api-key');
+            // Verify Anthropic was instantiated with the API key
+            expect(MockAnthropic).toHaveBeenCalledWith({
+                apiKey: 'test-api-key',
+                baseURL: undefined
+            });
+            // Verify the create method was called with correct parameters
+            expect(mockCreate).toHaveBeenCalledWith({
+                model: 'claude-3-5-sonnet-20241022',
+                messages: [{ role: 'user', content: 'Hello' }],
+                max_tokens: 100,
+                temperature: 0.7,
+                top_p: 1
+            });
+            // Verify the response
+            expect(response.object).toBe('chat.completion');
+            const successResponse = response;
+            expect(successResponse.id).toBe('msg_123');
+            expect(successResponse.provider).toBe('anthropic');
+            expect(successResponse.model).toBe('claude-3-5-sonnet-20241022');
+            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 by merging into first user message', async () => {
+            basicRequest.messages = [
+                { role: 'system', content: 'You are a helpful assistant.' },
+                { role: 'user', content: 'Hello' }
+            ];
+            mockCreate.mockResolvedValueOnce({
+                id: 'msg_123',
+                type: 'message',
+                role: 'assistant',
+                model: 'claude-3-5-sonnet-20241022',
+                content: [{ type: 'text', text: 'Hello!' }],
+                stop_reason: 'end_turn',
+                usage: { input_tokens: 15, output_tokens: 5 }
+            });
+            await adapter.sendMessage(basicRequest, 'test-api-key');
+            // System message should be sent as separate system parameter
+            expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
+                system: 'You are a helpful assistant.',
+                messages: [{
+                        role: 'user',
+                        content: 'Hello'
+                    }]
+            }));
+        });
+        it('should handle stop sequences correctly', async () => {
+            basicRequest.settings.stopSequences = ['END', 'STOP'];
+            mockCreate.mockResolvedValueOnce({
+                id: 'msg_123',
+                type: 'message',
+                role: 'assistant',
+                model: 'claude-3-5-sonnet-20241022',
+                content: [{ type: 'text', text: 'Response' }],
+                stop_reason: 'end_turn',
+                usage: { input_tokens: 10, output_tokens: 10 }
+            });
+            await adapter.sendMessage(basicRequest, 'test-api-key');
+            expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
+                stop_sequences: ['END', 'STOP']
+            }));
+        });
+        it('should handle multi-turn conversations', async () => {
+            basicRequest.messages = [
+                { role: 'user', content: 'Hello' },
+                { role: 'assistant', content: 'Hi there!' },
+                { role: 'user', content: 'How are you?' }
+            ];
+            mockCreate.mockResolvedValueOnce({
+                id: 'msg_123',
+                type: 'message',
+                role: 'assistant',
+                model: 'claude-3-5-sonnet-20241022',
+                content: [{ type: 'text', text: "I'm doing well, thanks!" }],
+                stop_reason: 'end_turn',
+                usage: { input_tokens: 20, output_tokens: 10 }
+            });
+            await adapter.sendMessage(basicRequest, 'test-api-key');
+            expect(mockCreate).toHaveBeenCalledWith(expect.objectContaining({
+                messages: [
+                    { role: 'user', content: 'Hello' },
+                    { role: 'assistant', content: 'Hi there!' },
+                    { role: 'user', content: 'How are you?' }
+                ]
+            }));
+        });
+        it('should map stop_reason correctly', async () => {
+            const stopReasons = [
+                { anthropic: 'end_turn', expected: 'stop' },
+                { anthropic: 'max_tokens', expected: 'length' },
+                { anthropic: 'stop_sequence', expected: 'stop' },
+                { anthropic: 'unknown_reason', expected: 'other' }
+            ];
+            for (const { anthropic, expected } of stopReasons) {
+                mockCreate.mockResolvedValueOnce({
+                    id: 'msg_123',
+                    type: 'message',
+                    role: 'assistant',
+                    model: 'claude-3-5-sonnet-20241022',
+                    content: [{ type: 'text', text: 'Response' }],
+                    stop_reason: anthropic,
+                    usage: { input_tokens: 10, output_tokens: 10 }
+                });
+                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 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');
+            });
+            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 context length errors', async () => {
+                // Create a mock error that simulates Anthropic.APIError
+                const apiError = Object.assign(new Error('Message is too long'), {
+                    status: 400,
+                    constructor: { name: 'APIError' }
+                });
+                Object.setPrototypeOf(apiError, sdk_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 invalid model errors', async () => {
+                const apiError = new Error('Model not found');
+                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 credit errors', async () => {
+                const apiError = new Error('Insufficient credits');
+                apiError.status = 402;
+                mockCreate.mockRejectedValueOnce(apiError);
+                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');
+            });
+            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 = 'ENOTFOUND';
+                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');
+            });
+        });
+    });
+    describe('validateApiKey', () => {
+        it('should validate API key format', () => {
+            // Valid Anthropic API key format - must start with 'sk-ant-' and be at least 30 chars
+            expect(adapter.validateApiKey('sk-ant-api01-test123456789012345')).toBe(true);
+            expect(adapter.validateApiKey('sk-ant-api03-test123456789012345')).toBe(true);
+            // Invalid formats
+            expect(adapter.validateApiKey('invalid')).toBe(false);
+            expect(adapter.validateApiKey('')).toBe(false);
+            expect(adapter.validateApiKey('sk-test')).toBe(false); // OpenAI format
+            expect(adapter.validateApiKey('sk-ant-test123')).toBe(false); // Too short
+        });
+    });
+    describe('getAdapterInfo', () => {
+        it('should return correct adapter information', () => {
+            const info = adapter.getAdapterInfo();
+            expect(info.providerId).toBe('anthropic');
+            expect(info.name).toBe('Anthropic Client Adapter');
+            expect(info.version).toBeDefined();
+            // supportedModels is not part of the interface
+        });
+    });
+});

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

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

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