genai-lite 0.4.0 → 0.4.1

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

@@ -1,273 +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 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,
-                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 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

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

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

@@ -1,405 +0,0 @@
-"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,
-                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 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('reasoning/thinking configuration', () => {
-            it('should add thinking config when reasoning is enabled with maxTokens', async () => {
-                const requestWithReasoning = {
-                    ...basicRequest,
-                    settings: {
-                        ...basicRequest.settings,
-                        reasoning: {
-                            enabled: true,
-                            maxTokens: 5000,
-                            effort: undefined,
-                            exclude: false
-                        }
-                    }
-                };
-                mockGenerateContent.mockResolvedValueOnce({
-                    text: () => 'Response with thinking',
-                    candidates: [{
-                            finishReason: 'STOP',
-                            content: {
-                                parts: [{ text: 'Response with thinking' }]
-                            }
-                        }],
-                    usageMetadata: {}
-                });
-                await adapter.sendMessage(requestWithReasoning, 'test-api-key');
-                const callArgs = mockGenerateContent.mock.calls[0][0];
-                expect(callArgs.config.thinkingConfig).toEqual({
-                    thinkingBudget: 5000,
-                    includeThoughts: true
-                });
-            });
-            it('should convert effort levels to thinking budget', async () => {
-                const requestWithEffort = {
-                    ...basicRequest,
-                    settings: {
-                        ...basicRequest.settings,
-                        reasoning: {
-                            enabled: true,
-                            effort: 'high',
-                            maxTokens: undefined,
-                            exclude: false
-                        }
-                    }
-                };
-                mockGenerateContent.mockResolvedValueOnce({
-                    text: () => 'Response',
-                    candidates: [{
-                            finishReason: 'STOP',
-                            content: {
-                                parts: [{ text: 'Response' }]
-                            }
-                        }],
-                    usageMetadata: {}
-                });
-                await adapter.sendMessage(requestWithEffort, 'test-api-key');
-                const callArgs = mockGenerateContent.mock.calls[0][0];
-                // For gemini-2.5-pro (not flash), max budget is 65536, high effort = 80%
-                expect(callArgs.config.thinkingConfig?.thinkingBudget).toBe(Math.floor(65536 * 0.8));
-            });
-            it('should use dynamic budget (-1) when reasoning enabled without specific settings', async () => {
-                const requestWithBasicReasoning = {
-                    ...basicRequest,
-                    settings: {
-                        ...basicRequest.settings,
-                        reasoning: {
-                            enabled: true,
-                            effort: undefined,
-                            maxTokens: undefined,
-                            exclude: false
-                        }
-                    }
-                };
-                mockGenerateContent.mockResolvedValueOnce({
-                    text: () => 'Response',
-                    candidates: [{
-                            finishReason: 'STOP',
-                            content: {
-                                parts: [{ text: 'Response' }]
-                            }
-                        }],
-                    usageMetadata: {}
-                });
-                await adapter.sendMessage(requestWithBasicReasoning, 'test-api-key');
-                const callArgs = mockGenerateContent.mock.calls[0][0];
-                expect(callArgs.config.thinkingConfig?.thinkingBudget).toBe(-1);
-            });
-            it('should exclude thinking config when reasoning.exclude is true', async () => {
-                const requestWithExclude = {
-                    ...basicRequest,
-                    settings: {
-                        ...basicRequest.settings,
-                        reasoning: {
-                            enabled: true,
-                            maxTokens: 5000,
-                            effort: undefined,
-                            exclude: true
-                        }
-                    }
-                };
-                mockGenerateContent.mockResolvedValueOnce({
-                    text: () => 'Response',
-                    candidates: [{
-                            finishReason: 'STOP',
-                            content: {
-                                parts: [{ text: 'Response' }]
-                            }
-                        }],
-                    usageMetadata: {}
-                });
-                await adapter.sendMessage(requestWithExclude, 'test-api-key');
-                const callArgs = mockGenerateContent.mock.calls[0][0];
-                expect(callArgs.config.thinkingConfig).toBeUndefined();
-            });
-        });
-        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
-        });
-    });
-});