genai-lite 0.2.0 → 0.2.1

package/dist/llm/LLMService.prepareMessage.test.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const LLMService_1 = require("./LLMService");
+describe('LLMService.prepareMessage', () => {
+    let mockApiKeyProvider;
+    let service;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockApiKeyProvider = jest.fn().mockResolvedValue('test-api-key');
+        service = new LLMService_1.LLMService(mockApiKeyProvider);
+    });
+    describe('Input validation', () => {
+        it('should require either template or messages', async () => {
+            const result = await service.prepareMessage({});
+            expect(result).toMatchObject({
+                object: 'error',
+                error: {
+                    message: 'Either template or messages must be provided',
+                    code: 'INVALID_INPUT',
+                    type: 'validation_error',
+                },
+            });
+        });
+        it('should require either presetId or both providerId and modelId', async () => {
+            const result = await service.prepareMessage({
+                template: 'Test template',
+                providerId: 'openai',
+                // Missing modelId
+            });
+            expect(result).toMatchObject({
+                object: 'error',
+                error: {
+                    message: 'Either presetId or both providerId and modelId must be provided',
+                    code: 'INVALID_MODEL_SELECTION',
+                    type: 'validation_error',
+                },
+            });
+        });
+    });
+    describe('Preset resolution', () => {
+        it('should resolve model info from presetId', async () => {
+            const result = await service.prepareMessage({
+                template: 'Test {{ model_id }}',
+                presetId: 'openai-gpt-4.1-default',
+            });
+            expect(result).toMatchObject({
+                messages: [{ role: 'user', content: 'Test gpt-4.1' }],
+                modelContext: {
+                    model_id: 'gpt-4.1',
+                    provider_id: 'openai',
+                    thinking_enabled: false,
+                    thinking_available: false,
+                },
+            });
+        });
+        it('should handle non-existent presetId', async () => {
+            const result = await service.prepareMessage({
+                template: 'Test',
+                presetId: 'non-existent-preset',
+            });
+            expect(result).toMatchObject({
+                object: 'error',
+                error: {
+                    message: 'Preset not found: non-existent-preset',
+                    code: 'PRESET_NOT_FOUND',
+                    type: 'validation_error',
+                },
+            });
+        });
+        it('should merge preset settings with user settings', async () => {
+            const result = await service.prepareMessage({
+                template: 'Test',
+                presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking',
+                settings: { temperature: 0.5 }, // Override preset temperature
+            });
+            expect(result).not.toHaveProperty('error');
+            // The settings are merged internally and will be used when sendMessage is called
+        });
+    });
+    describe('Model resolution from providerId/modelId', () => {
+        it('should resolve model info from providerId and modelId', async () => {
+            const result = await service.prepareMessage({
+                template: 'Model: {{ model_id }}, Provider: {{ provider_id }}',
+                providerId: 'anthropic',
+                modelId: 'claude-3-5-sonnet-20241022',
+            });
+            expect(result).toMatchObject({
+                messages: [{
+                        role: 'user',
+                        content: 'Model: claude-3-5-sonnet-20241022, Provider: anthropic'
+                    }],
+                modelContext: {
+                    model_id: 'claude-3-5-sonnet-20241022',
+                    provider_id: 'anthropic',
+                    thinking_enabled: false,
+                    thinking_available: false,
+                },
+            });
+        });
+        it('should handle invalid model', async () => {
+            const result = await service.prepareMessage({
+                template: 'Test',
+                providerId: 'openai',
+                modelId: 'non-existent-model',
+            });
+            expect(result).toMatchObject({
+                object: 'error',
+                error: {
+                    message: 'Unsupported model: non-existent-model for provider: openai',
+                    code: 'UNSUPPORTED_MODEL',
+                    type: 'validation_error',
+                },
+            });
+        });
+    });
+    describe('Template rendering with model context', () => {
+        it('should inject model context into template', async () => {
+            const result = await service.prepareMessage({
+                template: `{{ thinking_enabled ? \`Please think step by step about this:\` : \`Please analyze this:\` }}
+Model: {{ model_id }}
+Provider: {{ provider_id }}
+Thinking available: {{ thinking_available }}`,
+                presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking',
+            });
+            expect(result).toMatchObject({
+                messages: [{
+                        role: 'user',
+                        content: expect.stringContaining('Please think step by step about this:'),
+                    }],
+                modelContext: {
+                    thinking_enabled: true,
+                    thinking_available: true,
+                    model_id: 'claude-3-7-sonnet-20250219',
+                    provider_id: 'anthropic',
+                },
+            });
+            const content = result.messages[0].content;
+            expect(content).toContain('Model: claude-3-7-sonnet-20250219');
+            expect(content).toContain('Provider: anthropic');
+            expect(content).toContain('Thinking available: true');
+        });
+        it('should handle reasoning effort in model context', async () => {
+            const result = await service.prepareMessage({
+                template: 'Effort: {{ reasoning_effort ? `{{reasoning_effort}}` : `not set` }}',
+                providerId: 'anthropic',
+                modelId: 'claude-3-7-sonnet-20250219',
+                settings: {
+                    reasoning: {
+                        enabled: true,
+                        effort: 'high',
+                    },
+                },
+            });
+            expect(result).toMatchObject({
+                messages: [{ role: 'user', content: 'Effort: high' }],
+                modelContext: {
+                    reasoning_effort: 'high',
+                },
+            });
+        });
+        it('should handle reasoning maxTokens in model context', async () => {
+            const result = await service.prepareMessage({
+                template: 'Max tokens: {{ reasoning_max_tokens ? `{{reasoning_max_tokens}}` : `default` }}',
+                providerId: 'anthropic',
+                modelId: 'claude-3-7-sonnet-20250219',
+                settings: {
+                    reasoning: {
+                        enabled: true,
+                        maxTokens: 5000,
+                    },
+                },
+            });
+            expect(result).toMatchObject({
+                messages: [{ role: 'user', content: 'Max tokens: 5000' }],
+                modelContext: {
+                    reasoning_max_tokens: 5000,
+                },
+            });
+        });
+        it('should combine template variables with model context', async () => {
+            const result = await service.prepareMessage({
+                template: `
+Task: {{ task }}
+Model: {{ model_id }}
+{{ thinking_enabled ? "Use reasoning to solve this." : "Provide a direct answer." }}`,
+                variables: {
+                    task: 'Calculate fibonacci(10)',
+                },
+                presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking',
+            });
+            const content = result.messages[0].content;
+            expect(content).toContain('Task: Calculate fibonacci(10)');
+            expect(content).toContain('Model: claude-3-7-sonnet-20250219');
+            expect(content).toContain('Use reasoning to solve this.');
+        });
+        it('should handle template rendering errors', async () => {
+            // This will cause an actual error in template rendering by using a variable that throws on toString()
+            const errorObject = {
+                toString: () => {
+                    throw new Error('Test template error');
+                }
+            };
+            const result = await service.prepareMessage({
+                template: '{{ data }}',
+                variables: { data: errorObject },
+                providerId: 'openai',
+                modelId: 'gpt-4.1',
+            });
+            expect(result).toMatchObject({
+                object: 'error',
+                error: {
+                    message: expect.stringContaining('Template rendering failed'),
+                    code: 'TEMPLATE_ERROR',
+                    type: 'validation_error',
+                },
+            });
+        });
+    });
+    describe('Pre-built messages', () => {
+        it('should return pre-built messages with model context', async () => {
+            const messages = [
+                { role: 'system', content: 'You are a helpful assistant.' },
+                { role: 'user', content: 'Hello!' },
+            ];
+            const result = await service.prepareMessage({
+                messages,
+                providerId: 'openai',
+                modelId: 'o4-mini',
+            });
+            expect(result).toMatchObject({
+                messages,
+                modelContext: {
+                    model_id: 'o4-mini',
+                    provider_id: 'openai',
+                    thinking_enabled: true, // o4-mini always has reasoning enabled
+                    thinking_available: true,
+                },
+            });
+        });
+    });
+    describe('Thinking/reasoning models', () => {
+        it('should detect thinking capabilities for supported models', async () => {
+            const testCases = [
+                {
+                    presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking',
+                    expected: { thinking_enabled: true, thinking_available: true },
+                },
+                {
+                    presetId: 'anthropic-claude-3-5-sonnet-20241022-default',
+                    expected: { thinking_enabled: false, thinking_available: false },
+                },
+                {
+                    presetId: 'google-gemini-2.5-flash-thinking',
+                    expected: { thinking_enabled: true, thinking_available: true },
+                },
+                {
+                    presetId: 'openai-o4-mini-default',
+                    expected: { thinking_enabled: true, thinking_available: true }, // Always on
+                },
+            ];
+            for (const testCase of testCases) {
+                const result = await service.prepareMessage({
+                    template: 'Test',
+                    presetId: testCase.presetId,
+                });
+                expect(result).toMatchObject({
+                    modelContext: expect.objectContaining(testCase.expected),
+                });
+            }
+        });
+    });
+    describe('Custom presets', () => {
+        it('should work with custom presets', async () => {
+            const customPresets = [
+                {
+                    id: 'custom-gpt4-thinking',
+                    displayName: 'Custom GPT-4',
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    settings: {
+                        temperature: 0.3,
+                        reasoning: { enabled: true },
+                    },
+                },
+            ];
+            const customService = new LLMService_1.LLMService(mockApiKeyProvider, {
+                presets: customPresets,
+                presetMode: 'extend',
+            });
+            const result = await customService.prepareMessage({
+                template: 'Thinking: {{ thinking_enabled }}',
+                presetId: 'custom-gpt4-thinking',
+            });
+            expect(result).toMatchObject({
+                messages: [{ role: 'user', content: 'Thinking: false' }], // GPT-4.1 doesn't support reasoning
+                modelContext: {
+                    thinking_enabled: false,
+                    thinking_available: false,
+                },
+            });
+        });
+    });
+});

package/dist/llm/LLMService.sendMessage.preset.test.d.ts

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

package/dist/llm/LLMService.sendMessage.preset.test.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const LLMService_1 = require("./LLMService");
+describe('LLMService.sendMessage with presetId', () => {
+    let mockApiKeyProvider;
+    let service;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockApiKeyProvider = jest.fn().mockResolvedValue('test-api-key');
+        service = new LLMService_1.LLMService(mockApiKeyProvider);
+    });
+    describe('Preset resolution in sendMessage', () => {
+        it('should send message using presetId', async () => {
+            const request = {
+                presetId: 'openai-gpt-4.1-default',
+                messages: [{ role: 'user', content: 'Hello' }],
+            };
+            const response = await service.sendMessage(request);
+            // The request will fail because we don't have a real API key,
+            // but we can verify it tried with the correct provider/model
+            expect(response).toMatchObject({
+                provider: 'openai',
+                model: 'gpt-4.1',
+                object: 'error',
+            });
+        });
+        it('should override preset settings with request settings', async () => {
+            const request = {
+                presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking',
+                messages: [{ role: 'user', content: 'Test' }],
+                settings: {
+                    temperature: 0.2, // Override preset temperature
+                    reasoning: {
+                        enabled: false, // Disable reasoning despite thinking preset
+                    },
+                },
+            };
+            const response = await service.sendMessage(request);
+            expect(response).toMatchObject({
+                provider: 'anthropic',
+                model: 'claude-3-7-sonnet-20250219',
+                object: 'error',
+            });
+        });
+        it('should handle invalid presetId', async () => {
+            const request = {
+                presetId: 'non-existent-preset',
+                messages: [{ role: 'user', content: 'Test' }],
+            };
+            const response = await service.sendMessage(request);
+            expect(response).toMatchObject({
+                object: 'error',
+                error: {
+                    message: 'Preset not found: non-existent-preset',
+                    code: 'PRESET_NOT_FOUND',
+                    type: 'validation_error',
+                },
+            });
+        });
+        it('should allow either presetId or providerId/modelId', async () => {
+            // Test with providerId/modelId (existing behavior)
+            const request1 = {
+                providerId: 'openai',
+                modelId: 'gpt-4.1',
+                messages: [{ role: 'user', content: 'Test' }],
+            };
+            const response1 = await service.sendMessage(request1);
+            expect(response1).toMatchObject({
+                provider: 'openai',
+                model: 'gpt-4.1',
+            });
+            // Test with presetId (new behavior)
+            const request2 = {
+                presetId: 'openai-gpt-4.1-default',
+                messages: [{ role: 'user', content: 'Test' }],
+            };
+            const response2 = await service.sendMessage(request2);
+            expect(response2).toMatchObject({
+                provider: 'openai',
+                model: 'gpt-4.1',
+            });
+        });
+        it('should prefer presetId when both are provided', async () => {
+            const request = {
+                presetId: 'anthropic-claude-3-5-sonnet-20241022-default',
+                providerId: 'openai', // These will be ignored
+                modelId: 'gpt-4.1', // These will be ignored
+                messages: [{ role: 'user', content: 'Test' }],
+            };
+            const response = await service.sendMessage(request);
+            // Should use the preset's provider/model
+            expect(response).toMatchObject({
+                provider: 'anthropic',
+                model: 'claude-3-5-sonnet-20241022',
+            });
+        });
+        it('should handle preset with model that was removed from config', async () => {
+            // Create a service with a preset pointing to a non-existent model
+            const customService = new LLMService_1.LLMService(mockApiKeyProvider, {
+                presets: [{
+                        id: 'broken-preset',
+                        displayName: 'Broken',
+                        providerId: 'openai',
+                        modelId: 'non-existent-model',
+                        settings: {},
+                    }],
+                presetMode: 'extend',
+            });
+            const request = {
+                presetId: 'broken-preset',
+                messages: [{ role: 'user', content: 'Test' }],
+            };
+            const response = await customService.sendMessage(request);
+            expect(response).toMatchObject({
+                object: 'error',
+                error: {
+                    message: 'Model not found for preset: broken-preset',
+                    code: 'MODEL_NOT_FOUND',
+                    type: 'validation_error',
+                },
+            });
+        });
+    });
+    describe('Settings merge with presets', () => {
+        it('should apply preset settings correctly', async () => {
+            const request = {
+                presetId: 'google-gemini-2.5-flash',
+                messages: [{ role: 'user', content: 'Test' }],
+            };
+            const response = await service.sendMessage(request);
+            // The preset includes geminiSafetySettings which should be applied
+            expect(response).toMatchObject({
+                provider: 'gemini',
+                model: 'gemini-2.5-flash',
+            });
+        });
+        it('should merge preset reasoning settings with request settings', async () => {
+            const request = {
+                presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking',
+                messages: [{ role: 'user', content: 'Complex problem' }],
+                settings: {
+                    maxTokens: 2000, // Add to preset settings
+                },
+            };
+            const response = await service.sendMessage(request);
+            expect(response).toMatchObject({
+                provider: 'anthropic',
+                model: 'claude-3-7-sonnet-20250219',
+            });
+            // Settings would be merged internally with both reasoning enabled and maxTokens
+        });
+    });
+});

package/dist/llm/LLMService.test.js

@@ -237,6 +237,89 @@ describe('LLMService', () => {
                 expect(errorResponse.error.code).toBe('INVALID_SETTINGS');
                 expect(errorResponse.error.message).toContain('topP must be a number between 0 and 1');
             });
+            it('should reject reasoning settings for non-reasoning models', async () => {
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1', // This model doesn't support reasoning
+                    messages: [{ role: 'user', content: 'Hello' }],
+                    settings: {
+                        reasoning: {
+                            enabled: true
+                        }
+                    }
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('reasoning_not_supported');
+                expect(errorResponse.error.message).toContain('does not support reasoning/thinking');
+            });
+            it('should reject reasoning with effort for non-reasoning models', async () => {
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Hello' }],
+                    settings: {
+                        reasoning: {
+                            effort: 'high'
+                        }
+                    }
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('reasoning_not_supported');
+            });
+            it('should reject reasoning with maxTokens for non-reasoning models', async () => {
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Hello' }],
+                    settings: {
+                        reasoning: {
+                            maxTokens: 5000
+                        }
+                    }
+                };
+                const response = await service.sendMessage(request);
+                expect(response.object).toBe('error');
+                const errorResponse = response;
+                expect(errorResponse.error.code).toBe('reasoning_not_supported');
+            });
+            it('should allow disabled reasoning for non-reasoning models', async () => {
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Hello' }],
+                    settings: {
+                        reasoning: {
+                            enabled: false
+                        }
+                    }
+                };
+                // This should pass validation but will fail at the adapter level since we don't have a real API key
+                const response = await service.sendMessage(request);
+                // Should not be a reasoning validation error
+                const errorResponse = response;
+                expect(errorResponse.error.code).not.toBe('reasoning_not_supported');
+            });
+            it('should allow reasoning with exclude=true for non-reasoning models', async () => {
+                const request = {
+                    providerId: 'openai',
+                    modelId: 'gpt-4.1',
+                    messages: [{ role: 'user', content: 'Hello' }],
+                    settings: {
+                        reasoning: {
+                            exclude: true
+                        }
+                    }
+                };
+                // This should pass validation
+                const response = await service.sendMessage(request);
+                // Should not be a reasoning validation error
+                const errorResponse = response;
+                expect(errorResponse.error.code).not.toBe('reasoning_not_supported');
+            });
         });
     });
     describe('getProviders', () => {

package/dist/llm/clients/AnthropicClientAdapter.js

@@ -57,6 +57,42 @@ class AnthropicClientAdapter {
                     stop_sequences: request.settings.stopSequences,
                 }),
             };
+            // Handle reasoning/thinking configuration for Claude models
+            if (request.settings.reasoning && !request.settings.reasoning.exclude) {
+                const reasoning = request.settings.reasoning;
+                let budgetTokens;
+                // Convert reasoning settings to Anthropic's thinking format
+                if (reasoning.maxTokens !== undefined) {
+                    budgetTokens = Math.max(reasoning.maxTokens, 1024); // Minimum 1024
+                }
+                else if (reasoning.effort) {
+                    // Convert effort levels to token budgets
+                    // Max budget for Anthropic is 32000
+                    const maxBudget = 32000;
+                    switch (reasoning.effort) {
+                        case 'high':
+                            budgetTokens = Math.floor(maxBudget * 0.8);
+                            break;
+                        case 'medium':
+                            budgetTokens = Math.floor(maxBudget * 0.5);
+                            break;
+                        case 'low':
+                            budgetTokens = Math.floor(maxBudget * 0.2);
+                            break;
+                    }
+                }
+                else if (reasoning.enabled !== false) {
+                    // Use default budget
+                    budgetTokens = 10000;
+                }
+                if (budgetTokens !== undefined) {
+                    // Add thinking configuration to the request
+                    messageParams.thinking = {
+                        type: "enabled",
+                        budget_tokens: Math.min(budgetTokens, 32000) // Cap at max
+                    };
+                }
+            }
             console.log(`Making Anthropic API call for model: ${request.modelId}`);
             console.log(`Anthropic API parameters:`, {
                 model: messageParams.model,
@@ -195,23 +231,41 @@ class AnthropicClientAdapter {
         if (!contentBlock || contentBlock.type !== "text") {
             throw new Error("Invalid completion structure from Anthropic API");
         }
+        // Extract thinking/reasoning content if available
+        let reasoning;
+        let reasoning_details;
+        // Check for thinking content in the response
+        if (completion.thinking_content) {
+            reasoning = completion.thinking_content;
+        }
+        // Check for reasoning details that need to be preserved
+        if (completion.reasoning_details) {
+            reasoning_details = completion.reasoning_details;
+        }
         // Map Anthropic's stop reason to our standard format
         const finishReason = this.mapAnthropicStopReason(completion.stop_reason);
+        const choice = {
+            message: {
+                role: "assistant",
+                content: contentBlock.text,
+            },
+            finish_reason: finishReason,
+            index: 0,
+        };
+        // Include reasoning if available and not excluded
+        if (reasoning && request.settings.reasoning && !request.settings.reasoning.exclude) {
+            choice.reasoning = reasoning;
+        }
+        // Always include reasoning_details if present (for tool use continuation)
+        if (reasoning_details) {
+            choice.reasoning_details = reasoning_details;
+        }
         return {
             id: completion.id,
             provider: request.providerId,
             model: completion.model || request.modelId,
             created: Math.floor(Date.now() / 1000), // Anthropic doesn't provide created timestamp
-            choices: [
-                {
-                    message: {
-                        role: "assistant",
-                        content: contentBlock.text,
-                    },
-                    finish_reason: finishReason,
-                    index: 0,
-                },
-            ],
+            choices: [choice],
             usage: completion.usage
                 ? {
                     prompt_tokens: completion.usage.input_tokens,

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

@@ -36,7 +36,13 @@ describe('AnthropicClientAdapter', () => {
                 stopSequences: [],
                 user: 'test-user',
                 geminiSafetySettings: [],
-                supportsSystemMessage: true
+                supportsSystemMessage: true,
+                reasoning: {
+                    enabled: false,
+                    effort: undefined,
+                    maxTokens: undefined,
+                    exclude: false
+                }
             }
         };
     });