Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🧪 ci: Tests for Anthropic and OpenAI LLM Configuration (#9484)

Danny Avila035f85c3bae0
diff --git a/api/server/services/Endpoints/anthropic/llm.spec.js b/api/server/services/Endpoints/anthropic/llm.spec.js
index a1cdc160c5..fc132008f2 100644
--- a/api/server/services/Endpoints/anthropic/llm.spec.js
+++ b/api/server/services/Endpoints/anthropic/llm.spec.js
@@ -338,4 +338,799 @@ describe('getLLMConfig', () => {
expect(result.llmConfig).toHaveProperty('stopSequences', []);
});
});
+
+ describe('Real Usage Integration Tests', () => {
+ describe('Initialize.js Simulation', () => {
+ it('should handle basic Anthropic endpoint configuration like initialize.js', () => {
+ // Simulate the configuration from Anthropic initialize.js
+ const anthropicApiKey = 'sk-ant-api-key-123';
+ const endpointOption = {
+ model_parameters: {
+ model: 'claude-3-5-sonnet-latest',
+ temperature: 0.7,
+ maxOutputTokens: 4096,
+ topP: 0.9,
+ topK: 40,
+ stop: ['\\n\\n', 'Human:', 'Assistant:'],
+ stream: true,
+ },
+ };
+
+ // Simulate clientOptions from initialize.js
+ const clientOptions = {
+ proxy: null,
+ userId: 'test-user-id-123',
+ reverseProxyUrl: null,
+ modelOptions: endpointOption.model_parameters,
+ streamRate: 25,
+ titleModel: 'claude-3-haiku',
+ };
+
+ const result = getLLMConfig(anthropicApiKey, clientOptions);
+
+ expect(result.llmConfig).toMatchObject({
+ apiKey: anthropicApiKey,
+ model: 'claude-3-5-sonnet-latest',
+ temperature: 0.7,
+ maxTokens: 4096,
+ topP: 0.9,
+ topK: 40,
+ stopSequences: ['\\n\\n', 'Human:', 'Assistant:'],
+ stream: true,
+ invocationKwargs: {
+ metadata: {
+ user_id: 'test-user-id-123',
+ },
+ },
+ });
+ expect(result.tools).toEqual([]);
+ });
+
+ it('should handle Anthropic with proxy configuration like initialize.js', () => {
+ const anthropicApiKey = 'sk-ant-proxy-key';
+ const clientOptions = {
+ proxy: 'http://corporate-proxy:8080',
+ userId: 'proxy-user-456',
+ reverseProxyUrl: null,
+ modelOptions: {
+ model: 'claude-3-opus',
+ temperature: 0.3,
+ maxOutputTokens: 2048,
+ },
+ };
+
+ const result = getLLMConfig(anthropicApiKey, clientOptions);
+
+ expect(result.llmConfig).toMatchObject({
+ apiKey: anthropicApiKey,
+ model: 'claude-3-opus',
+ temperature: 0.3,
+ maxTokens: 2048,
+ invocationKwargs: {
+ metadata: {
+ user_id: 'proxy-user-456',
+ },
+ },
+ });
+ expect(result.llmConfig.clientOptions.fetchOptions).toHaveProperty('dispatcher');
+ expect(result.llmConfig.clientOptions.fetchOptions.dispatcher.constructor.name).toBe(
+ 'ProxyAgent',
+ );
+ });
+
+ it('should handle Anthropic with reverse proxy like initialize.js', () => {
+ const anthropicApiKey = 'sk-ant-reverse-proxy';
+ const reverseProxyUrl = 'https://api.custom-anthropic.com/v1';
+ const clientOptions = {
+ proxy: null,
+ userId: 'reverse-proxy-user',
+ reverseProxyUrl: reverseProxyUrl,
+ modelOptions: {
+ model: 'claude-3-5-haiku',
+ temperature: 0.5,
+ stream: false,
+ },
+ };
+
+ const result = getLLMConfig(anthropicApiKey, clientOptions);
+
+ expect(result.llmConfig).toMatchObject({
+ apiKey: anthropicApiKey,
+ model: 'claude-3-5-haiku',
+ temperature: 0.5,
+ stream: false,
+ anthropicApiUrl: reverseProxyUrl,
+ });
+ expect(result.llmConfig.clientOptions).toMatchObject({
+ baseURL: reverseProxyUrl,
+ });
+ });
+ });
+
+ describe('Model-Specific Real Usage Scenarios', () => {
+ it('should handle Claude-3.7 with thinking enabled like production', () => {
+ const clientOptions = {
+ userId: 'thinking-user-789',
+ modelOptions: {
+ model: 'claude-3-7-sonnet',
+ temperature: 0.4,
+ maxOutputTokens: 8192,
+ topP: 0.95,
+ topK: 50,
+ thinking: true,
+ thinkingBudget: 3000,
+ promptCache: true,
+ },
+ };
+
+ const result = getLLMConfig('sk-ant-thinking-key', clientOptions);
+
+ expect(result.llmConfig).toMatchObject({
+ model: 'claude-3-7-sonnet',
+ temperature: 0.4,
+ maxTokens: 8192,
+ stream: true, // default
+ thinking: {
+ type: 'enabled',
+ budget_tokens: 3000,
+ },
+ });
+ // topP and topK should NOT be included for Claude-3.7 with thinking enabled
+ expect(result.llmConfig).not.toHaveProperty('topP');
+ expect(result.llmConfig).not.toHaveProperty('topK');
+ // Should have appropriate headers for Claude-3.7 with prompt cache
+ expect(result.llmConfig.clientOptions.defaultHeaders).toEqual({
+ 'anthropic-beta':
+ 'token-efficient-tools-2025-02-19,output-128k-2025-02-19,prompt-caching-2024-07-31',
+ });
+ });
+
+ it('should handle web search functionality like production', () => {
+ const clientOptions = {
+ userId: 'websearch-user-303',
+ modelOptions: {
+ model: 'claude-3-5-sonnet-latest',
+ temperature: 0.6,
+ maxOutputTokens: 4096,
+ web_search: true,
+ },
+ };
+
+ const result = getLLMConfig('sk-ant-websearch-key', clientOptions);
+
+ expect(result.llmConfig).toMatchObject({
+ model: 'claude-3-5-sonnet-latest',
+ temperature: 0.6,
+ maxTokens: 4096,
+ });
+ expect(result.tools).toEqual([
+ {
+ type: 'web_search_20250305',
+ name: 'web_search',
+ },
+ ]);
+ });
+ });
+
+ describe('Production-like Configuration Scenarios', () => {
+ it('should handle complex production configuration', () => {
+ const clientOptions = {
+ proxy: 'http://prod-proxy.company.com:3128',
+ userId: 'prod-user-enterprise-404',
+ reverseProxyUrl: 'https://anthropic-gateway.company.com/v1',
+ modelOptions: {
+ model: 'claude-3-opus-20240229',
+ temperature: 0.2, // Conservative for production
+ maxOutputTokens: 4096,
+ topP: 0.95,
+ topK: 10,
+ stop: ['\\n\\nHuman:', '\\n\\nAssistant:', 'END_CONVERSATION'],
+ stream: true,
+ promptCache: true,
+ },
+ streamRate: 15, // Conservative stream rate
+ titleModel: 'claude-3-haiku-20240307',
+ };
+
+ const result = getLLMConfig('sk-ant-prod-enterprise-key', clientOptions);
+
+ expect(result.llmConfig).toMatchObject({
+ apiKey: 'sk-ant-prod-enterprise-key',
+ model: 'claude-3-opus-20240229',
+ temperature: 0.2,
+ maxTokens: 4096,
+ topP: 0.95,
+ topK: 10,
+ stopSequences: ['\\n\\nHuman:', '\\n\\nAssistant:', 'END_CONVERSATION'],
+ stream: true,
+ anthropicApiUrl: 'https://anthropic-gateway.company.com/v1',
+ invocationKwargs: {
+ metadata: {
+ user_id: 'prod-user-enterprise-404',
+ },
+ },
+ });
+ expect(result.llmConfig.clientOptions).toMatchObject({
+ baseURL: 'https://anthropic-gateway.company.com/v1',
+ fetchOptions: {
+ dispatcher: expect.any(Object),
+ },
+ });
+ expect(result.tools).toEqual([]);
+ });
+
+ it('should handle multiple system options removal from modelOptions', () => {
+ const modelOptions = {
+ model: 'claude-3-5-sonnet',
+ temperature: 0.7,
+ maxOutputTokens: 8192,
+ // System options that should be removed
+ thinking: true,
+ promptCache: true,
+ thinkingBudget: 2500,
+ // Regular options that should remain
+ topP: 0.9,
+ topK: 40,
+ };
+
+ const clientOptions = {
+ userId: 'system-options-user',
+ modelOptions,
+ };
+
+ getLLMConfig('sk-ant-system-key', clientOptions);
+
+ // System options should be removed from original modelOptions
+ expect(modelOptions).not.toHaveProperty('thinking');
+ expect(modelOptions).not.toHaveProperty('promptCache');
+ expect(modelOptions).not.toHaveProperty('thinkingBudget');
+ // Regular options should remain
+ expect(modelOptions).toHaveProperty('temperature', 0.7);
+ expect(modelOptions).toHaveProperty('topP', 0.9);
+ expect(modelOptions).toHaveProperty('topK', 40);
+ });
+ });
+
+ describe('Error Handling and Edge Cases from Real Usage', () => {
+ it('should handle missing userId gracefully', () => {
+ const clientOptions = {
+ modelOptions: {
+ model: 'claude-3-haiku',
+ temperature: 0.5,
+ },
+ // userId is missing
+ };
+
+ const result = getLLMConfig('sk-ant-no-user-key', clientOptions);
+
+ expect(result.llmConfig.invocationKwargs.metadata).toMatchObject({
+ user_id: undefined,
+ });
+ });
+
+ it('should handle large parameter sets without performance issues', () => {
+ const largeModelOptions = {
+ model: 'claude-3-opus',
+ temperature: 0.7,
+ maxOutputTokens: 4096,
+ topP: 0.9,
+ topK: 40,
+ };
+
+ // Add many additional properties to test performance
+ for (let i = 0; i < 100; i++) {
+ largeModelOptions[`custom_param_${i}`] = `value_${i}`;
+ }
+
+ const clientOptions = {
+ userId: 'performance-test-user',
+ modelOptions: largeModelOptions,
+ proxy: 'http://performance-proxy:8080',
+ reverseProxyUrl: 'https://performance-reverse-proxy.com',
+ };
+
+ const startTime = Date.now();
+ const result = getLLMConfig('sk-ant-performance-key', clientOptions);
+ const endTime = Date.now();
+
+ expect(endTime - startTime).toBeLessThan(50); // Should be very fast
+ expect(result.llmConfig).toMatchObject({
+ model: 'claude-3-opus',
+ temperature: 0.7,
+ maxTokens: 4096,
+ topP: 0.9,
+ topK: 40,
+ });
+ });
+
+ it('should handle model name variations and edge cases', () => {
+ const modelVariations = [
+ 'claude-3-7-sonnet',
+ 'claude-3.7-sonnet',
+ 'anthropic/claude-3-opus-20240229',
+ 'claude-sonnet-4-latest',
+ 'claude-3-5-sonnet-latest',
+ ];
+
+ modelVariations.forEach((model) => {
+ const clientOptions = {
+ userId: 'model-variation-user',
+ modelOptions: {
+ model,
+ temperature: 0.5,
+ topP: 0.9,
+ topK: 40,
+ thinking: true,
+ promptCache: true,
+ },
+ };
+
+ const result = getLLMConfig('sk-ant-variation-key', clientOptions);
+
+ expect(result.llmConfig).toHaveProperty('model', model);
+ expect(result.llmConfig).toHaveProperty('temperature', 0.5);
+ // The specific behavior (thinking, topP/topK inclusion) depends on model pattern
+ });
+ });
+ });
+ });
+
+ describe('Comprehensive Parameter Logic Tests', () => {
+ describe('Default Values and Fallbacks', () => {
+ it('should apply correct default values from anthropicSettings', () => {
+ const result = getLLMConfig('test-key', { modelOptions: {} });
+
+ expect(result.llmConfig).toMatchObject({
+ model: 'claude-3-5-sonnet-latest', // default model
+ stream: true, // default stream
+ maxTokens: 8192, // DEFAULT_MAX_OUTPUT for claude-3-5-sonnet
+ });
+ });
+
+ it('should handle maxOutputTokens reset logic for different models', () => {
+ const testCases = [
+ { model: 'claude-3-5-sonnet', expectedMaxTokens: 8192 },
+ { model: 'claude-3.5-sonnet-20241022', expectedMaxTokens: 8192 },
+ { model: 'claude-3-7-sonnet', expectedMaxTokens: 8192 },
+ { model: 'claude-3.7-sonnet-20250109', expectedMaxTokens: 8192 },
+ { model: 'claude-3-opus', expectedMaxTokens: 4096 },
+ { model: 'claude-3-haiku', expectedMaxTokens: 4096 },
+ { model: 'claude-2.1', expectedMaxTokens: 4096 },
+ ];
+
+ testCases.forEach(({ model, expectedMaxTokens }) => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: { model, maxOutputTokens: null }, // Force reset
+ });
+ expect(result.llmConfig.maxTokens).toBe(expectedMaxTokens);
+ });
+ });
+
+ it('should handle system options defaults correctly', () => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: {
+ model: 'claude-3-7-sonnet',
+ // Don't specify thinking, promptCache, thinkingBudget - should use defaults
+ },
+ });
+
+ // Should have thinking enabled by default for claude-3-7
+ expect(result.llmConfig.thinking).toMatchObject({
+ type: 'enabled',
+ budget_tokens: 2000, // default thinkingBudget
+ });
+ // Should have prompt cache headers by default
+ expect(result.llmConfig.clientOptions.defaultHeaders).toBeDefined();
+ });
+ });
+
+ describe('Parameter Boundary and Validation Logic', () => {
+ it('should handle temperature boundary values', () => {
+ const testCases = [
+ { temperature: 0, expected: 0 }, // min
+ { temperature: 1, expected: 1 }, // max
+ { temperature: 0.5, expected: 0.5 }, // middle
+ { temperature: -0.1, expected: -0.1 }, // below min (should pass through)
+ { temperature: 1.1, expected: 1.1 }, // above max (should pass through)
+ ];
+
+ testCases.forEach(({ temperature, expected }) => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: { temperature },
+ });
+ expect(result.llmConfig.temperature).toBe(expected);
+ });
+ });
+
+ it('should handle topP boundary values', () => {
+ const testCases = [
+ { topP: 0, expected: 0 }, // min
+ { topP: 1, expected: 1 }, // max
+ { topP: 0.7, expected: 0.7 }, // default
+ { topP: -0.1, expected: -0.1 }, // below min
+ { topP: 1.1, expected: 1.1 }, // above max
+ ];
+
+ testCases.forEach(({ topP, expected }) => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: { model: 'claude-3-opus', topP },
+ });
+ expect(result.llmConfig.topP).toBe(expected);
+ });
+ });
+
+ it('should handle topK boundary values', () => {
+ const testCases = [
+ { topK: 1, expected: 1 }, // min
+ { topK: 40, expected: 40 }, // max
+ { topK: 5, expected: 5 }, // default
+ { topK: 0, expected: 0 }, // below min
+ { topK: 50, expected: 50 }, // above max
+ ];
+
+ testCases.forEach(({ topK, expected }) => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: { model: 'claude-3-opus', topK },
+ });
+ expect(result.llmConfig.topK).toBe(expected);
+ });
+ });
+
+ it('should handle maxOutputTokens boundary values', () => {
+ const testCases = [
+ { model: 'claude-3-opus', maxOutputTokens: 1, expected: 1 }, // min
+ { model: 'claude-3-opus', maxOutputTokens: 4096, expected: 4096 }, // max for legacy
+ { model: 'claude-3-5-sonnet', maxOutputTokens: 1, expected: 1 }, // min
+ { model: 'claude-3-5-sonnet', maxOutputTokens: 200000, expected: 200000 }, // max for new
+ { model: 'claude-3-7-sonnet', maxOutputTokens: 8192, expected: 8192 }, // default
+ ];
+
+ testCases.forEach(({ model, maxOutputTokens, expected }) => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: { model, maxOutputTokens },
+ });
+ expect(result.llmConfig.maxTokens).toBe(expected);
+ });
+ });
+
+ it('should handle thinkingBudget boundary values', () => {
+ const testCases = [
+ { thinkingBudget: 1024, expected: 1024 }, // min
+ { thinkingBudget: 2000, expected: 2000 }, // default
+ { thinkingBudget: 7000, expected: 7000 }, // within max tokens (8192)
+ { thinkingBudget: 500, expected: 500 }, // below min
+ { thinkingBudget: 200000, expected: 7372 }, // above max tokens, constrained to 90% of 8192
+ ];
+
+ testCases.forEach(({ thinkingBudget, expected }) => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: {
+ model: 'claude-3-7-sonnet',
+ thinking: true,
+ thinkingBudget,
+ },
+ });
+ expect(result.llmConfig.thinking.budget_tokens).toBe(expected);
+ });
+ });
+ });
+
+ describe('Complex Parameter Interactions', () => {
+ it('should handle thinking budget vs maxTokens constraints', () => {
+ const testCases = [
+ // Budget within maxTokens - should keep original
+ { maxOutputTokens: 4096, thinkingBudget: 2000, expectedBudget: 2000 },
+ // Budget exceeds maxTokens - should constrain to 90%
+ { maxOutputTokens: 4096, thinkingBudget: 5000, expectedBudget: 3686 }, // 90% of 4096
+ // Budget equals maxTokens - should keep original (not constrained unless it exceeds)
+ { maxOutputTokens: 2000, thinkingBudget: 2000, expectedBudget: 2000 },
+ // Budget slightly exceeds maxTokens - should constrain to 90%
+ { maxOutputTokens: 2000, thinkingBudget: 2001, expectedBudget: 1800 }, // 90% of 2000
+ // Very small maxTokens
+ { maxOutputTokens: 1000, thinkingBudget: 3000, expectedBudget: 900 }, // 90% of 1000
+ ];
+
+ testCases.forEach(({ maxOutputTokens, thinkingBudget, expectedBudget }) => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: {
+ model: 'claude-3-7-sonnet',
+ maxOutputTokens,
+ thinking: true,
+ thinkingBudget,
+ },
+ });
+ expect(result.llmConfig.thinking.budget_tokens).toBe(expectedBudget);
+ });
+ });
+
+ it('should handle topP/topK exclusion logic for Claude-3.7 models', () => {
+ const testCases = [
+ // Claude-3.7 with thinking = true - should exclude topP/topK
+ { model: 'claude-3-7-sonnet', thinking: true, shouldInclude: false },
+ { model: 'claude-3.7-sonnet', thinking: true, shouldInclude: false },
+ // Claude-3.7 with thinking = false - should include topP/topK
+ { model: 'claude-3-7-sonnet', thinking: false, shouldInclude: true },
+ { model: 'claude-3.7-sonnet', thinking: false, shouldInclude: true },
+ // Claude-3.7 with thinking = null - thinking defaults to true, so should exclude topP/topK
+ { model: 'claude-3-7-sonnet', thinking: null, shouldInclude: false },
+ // Non-Claude-3.7 models - should always include topP/topK (thinking doesn't affect them)
+ { model: 'claude-3-5-sonnet', thinking: true, shouldInclude: true },
+ { model: 'claude-3-opus', thinking: true, shouldInclude: true },
+ { model: 'claude-sonnet-4', thinking: true, shouldInclude: true },
+ ];
+
+ testCases.forEach(({ model, thinking, shouldInclude }) => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: {
+ model,
+ thinking,
+ topP: 0.9,
+ topK: 40,
+ },
+ });
+
+ if (shouldInclude) {
+ expect(result.llmConfig).toHaveProperty('topP', 0.9);
+ expect(result.llmConfig).toHaveProperty('topK', 40);
+ } else {
+ expect(result.llmConfig).not.toHaveProperty('topP');
+ expect(result.llmConfig).not.toHaveProperty('topK');
+ }
+ });
+ });
+
+ it('should handle prompt cache support logic for different models', () => {
+ const testCases = [
+ // Models that support prompt cache
+ { model: 'claude-3-5-sonnet', promptCache: true, shouldHaveHeaders: true },
+ { model: 'claude-3.5-sonnet-20241022', promptCache: true, shouldHaveHeaders: true },
+ { model: 'claude-3-7-sonnet', promptCache: true, shouldHaveHeaders: true },
+ { model: 'claude-3.7-sonnet-20250109', promptCache: true, shouldHaveHeaders: true },
+ { model: 'claude-3-opus', promptCache: true, shouldHaveHeaders: true },
+ { model: 'claude-sonnet-4-20250514', promptCache: true, shouldHaveHeaders: true },
+ // Models that don't support prompt cache
+ { model: 'claude-3-5-sonnet-latest', promptCache: true, shouldHaveHeaders: false },
+ { model: 'claude-3.5-sonnet-latest', promptCache: true, shouldHaveHeaders: false },
+ // Prompt cache disabled
+ { model: 'claude-3-5-sonnet', promptCache: false, shouldHaveHeaders: false },
+ ];
+
+ testCases.forEach(({ model, promptCache, shouldHaveHeaders }) => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: { model, promptCache },
+ });
+
+ if (shouldHaveHeaders) {
+ expect(result.llmConfig.clientOptions.defaultHeaders).toBeDefined();
+ expect(result.llmConfig.clientOptions.defaultHeaders['anthropic-beta']).toContain(
+ 'prompt-caching',
+ );
+ } else {
+ expect(result.llmConfig.clientOptions.defaultHeaders).toBeUndefined();
+ }
+ });
+ });
+ });
+
+ describe('Parameter Type Handling', () => {
+ it('should handle different data types for numeric parameters', () => {
+ const testCases = [
+ { temperature: '0.5', expected: '0.5' }, // string
+ { temperature: 0.5, expected: 0.5 }, // number
+ { topP: '0.9', expected: '0.9' }, // string
+ { topP: 0.9, expected: 0.9 }, // number
+ { topK: '20', expected: '20' }, // string
+ { topK: 20, expected: 20 }, // number
+ { maxOutputTokens: '4096', expected: '4096' }, // string
+ { maxOutputTokens: 4096, expected: 4096 }, // number
+ ];
+
+ testCases.forEach((testCase) => {
+ const key = Object.keys(testCase)[0];
+ const value = testCase[key];
+ const expected = testCase.expected;
+
+ const result = getLLMConfig('test-key', {
+ modelOptions: { model: 'claude-3-opus', [key]: value },
+ });
+
+ const outputKey = key === 'maxOutputTokens' ? 'maxTokens' : key;
+ expect(result.llmConfig[outputKey]).toBe(expected);
+ });
+ });
+
+ it('should handle array parameters correctly', () => {
+ const testCases = [
+ { stop: [], expected: [] }, // empty array
+ { stop: ['\\n'], expected: ['\\n'] }, // single item
+ { stop: ['\\n', 'Human:', 'Assistant:'], expected: ['\\n', 'Human:', 'Assistant:'] }, // multiple items
+ { stop: null, expected: null }, // null
+ { stop: undefined, expected: undefined }, // undefined
+ ];
+
+ testCases.forEach(({ stop, expected }) => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: { model: 'claude-3-opus', stop },
+ });
+
+ if (expected === null || expected === undefined) {
+ expect(result.llmConfig).not.toHaveProperty('stopSequences');
+ } else {
+ expect(result.llmConfig.stopSequences).toEqual(expected);
+ }
+ });
+ });
+
+ it('should handle boolean parameters correctly', () => {
+ const testCases = [
+ { stream: true, expected: true },
+ { stream: false, expected: false },
+ { stream: 'true', expected: 'true' }, // string boolean
+ { stream: 'false', expected: 'false' }, // string boolean
+ { stream: 1, expected: 1 }, // truthy number
+ { stream: 0, expected: 0 }, // falsy number
+ { thinking: true, expected: true },
+ { thinking: false, expected: false },
+ { promptCache: true, expected: true },
+ { promptCache: false, expected: false },
+ { web_search: true, expected: true },
+ { web_search: false, expected: false },
+ ];
+
+ testCases.forEach((testCase) => {
+ const key = Object.keys(testCase)[0];
+ const value = testCase[key];
+ const expected = testCase.expected;
+
+ const result = getLLMConfig('test-key', {
+ modelOptions: { model: 'claude-3-opus', [key]: value },
+ });
+
+ if (key === 'stream') {
+ expect(result.llmConfig.stream).toBe(expected);
+ } else if (key === 'web_search' && expected) {
+ expect(result.tools).toEqual([{ type: 'web_search_20250305', name: 'web_search' }]);
+ }
+ });
+ });
+ });
+
+ describe('Parameter Precedence and Override Logic', () => {
+ it('should handle modelOptions vs defaultOptions precedence', () => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: {
+ model: 'claude-3-opus', // override default
+ maxOutputTokens: 2048, // override default
+ stream: false, // override default
+ temperature: 0.3, // new parameter
+ },
+ });
+
+ expect(result.llmConfig).toMatchObject({
+ model: 'claude-3-opus', // overridden
+ maxTokens: 2048, // overridden
+ stream: false, // overridden
+ temperature: 0.3, // added
+ });
+ });
+
+ it('should handle system options extraction and defaults', () => {
+ const modelOptions = {
+ model: 'claude-3-7-sonnet',
+ temperature: 0.5,
+ // Missing system options should use defaults
+ };
+
+ const result = getLLMConfig('test-key', {
+ modelOptions,
+ });
+
+ // System options should be removed from modelOptions
+ expect(modelOptions).not.toHaveProperty('thinking');
+ expect(modelOptions).not.toHaveProperty('promptCache');
+ expect(modelOptions).not.toHaveProperty('thinkingBudget');
+
+ // Should use defaults for system options
+ expect(result.llmConfig.thinking).toMatchObject({
+ type: 'enabled',
+ budget_tokens: 2000, // default
+ });
+ });
+
+ it('should handle partial system options with defaults', () => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: {
+ model: 'claude-3-7-sonnet',
+ thinking: false, // explicit false
+ // promptCache and thinkingBudget should use defaults
+ },
+ });
+
+ // thinking is false, so no thinking object should be created
+ expect(result.llmConfig.thinking).toBeUndefined();
+ // promptCache default is true, so should have headers
+ expect(result.llmConfig.clientOptions.defaultHeaders).toBeDefined();
+ });
+ });
+
+ describe('Edge Cases and Error Conditions', () => {
+ it('should handle extremely large numbers', () => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: {
+ temperature: Number.MAX_SAFE_INTEGER,
+ topP: Number.MAX_VALUE,
+ topK: 999999,
+ maxOutputTokens: Number.MAX_SAFE_INTEGER,
+ thinkingBudget: Number.MAX_SAFE_INTEGER,
+ },
+ });
+
+ // Should pass through without crashing
+ expect(result.llmConfig.temperature).toBe(Number.MAX_SAFE_INTEGER);
+ expect(result.llmConfig.topP).toBe(Number.MAX_VALUE);
+ expect(result.llmConfig.topK).toBe(999999);
+ expect(result.llmConfig.maxTokens).toBe(Number.MAX_SAFE_INTEGER);
+ });
+
+ it('should handle negative numbers', () => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: {
+ temperature: -1,
+ topP: -0.5,
+ topK: -10,
+ maxOutputTokens: -1000,
+ thinkingBudget: -500,
+ },
+ });
+
+ // Should pass through negative values (API will handle validation)
+ expect(result.llmConfig.temperature).toBe(-1);
+ expect(result.llmConfig.topP).toBe(-0.5);
+ expect(result.llmConfig.topK).toBe(-10);
+ expect(result.llmConfig.maxTokens).toBe(-1000);
+ });
+
+ it('should handle special numeric values', () => {
+ const testCases = [
+ { value: NaN, shouldBeRemoved: false }, // NaN passes through removeNullishValues
+ { value: Infinity, shouldBeRemoved: false },
+ { value: -Infinity, shouldBeRemoved: false },
+ { value: 0, shouldBeRemoved: false },
+ { value: -0, shouldBeRemoved: false },
+ ];
+
+ testCases.forEach(({ value, shouldBeRemoved }) => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: {
+ model: 'claude-3-opus',
+ temperature: value,
+ },
+ });
+
+ if (shouldBeRemoved) {
+ expect(result.llmConfig).not.toHaveProperty('temperature');
+ } else {
+ expect(result.llmConfig.temperature).toBe(value);
+ }
+ });
+ });
+
+ it('should handle malformed stop sequences', () => {
+ const testCases = [
+ { stop: 'string', expected: 'string' }, // single string instead of array
+ { stop: [null, undefined, ''], expected: [null, undefined, ''] }, // mixed values
+ { stop: [123, true, false], expected: [123, true, false] }, // non-string values
+ { stop: {}, expected: {} }, // object instead of array
+ ];
+
+ testCases.forEach(({ stop, expected }) => {
+ const result = getLLMConfig('test-key', {
+ modelOptions: { model: 'claude-3-opus', stop },
+ });
+
+ expect(result.llmConfig.stopSequences).toEqual(expected);
+ });
+ });
+ });
+ });
});
diff --git a/packages/api/src/endpoints/openai/llm.spec.ts b/packages/api/src/endpoints/openai/llm.spec.ts
index 90a96c118c..4fd88e2e9a 100644
--- a/packages/api/src/endpoints/openai/llm.spec.ts
+++ b/packages/api/src/endpoints/openai/llm.spec.ts
@@ -1,6 +1,7 @@
-import { ReasoningEffort, ReasoningSummary, Verbosity } from 'librechat-data-provider';
+import { Verbosity, ReasoningEffort, ReasoningSummary } from 'librechat-data-provider';
import type { RequestInit } from 'undici';
-import { getOpenAIConfig } from './llm';
+import type { OpenAIParameters, AzureOptions } from '~/types';
+import { getOpenAIConfig, knownOpenAIParams } from './llm';
describe('getOpenAIConfig', () => {
const mockApiKey = 'test-api-key';
@@ -75,7 +76,7 @@ describe('getOpenAIConfig', () => {
expect(result.llmConfig.modelKwargs).toBeUndefined();
});
- it('should handle reasoning params for useResponsesApi', () => {
+ it('should handle reasoning params for `useResponsesApi`', () => {
const modelOptions = {
reasoning_effort: ReasoningEffort.high,
reasoning_summary: ReasoningSummary.detailed,
@@ -93,7 +94,7 @@ describe('getOpenAIConfig', () => {
expect((result.llmConfig as Record<string, unknown>).reasoning_summary).toBeUndefined();
});
- it('should handle reasoning params without useResponsesApi', () => {
+ it('should handle reasoning params without `useResponsesApi`', () => {
const modelOptions = {
reasoning_effort: ReasoningEffort.high,
reasoning_summary: ReasoningSummary.detailed,
@@ -421,4 +422,907 @@ describe('getOpenAIConfig', () => {
},
});
});
+
+ describe('Azure Configuration', () => {
+ it('should handle Azure configuration with model name as deployment', () => {
+ const originalEnv = process.env.AZURE_USE_MODEL_AS_DEPLOYMENT_NAME;
+ process.env.AZURE_USE_MODEL_AS_DEPLOYMENT_NAME = 'true';
+
+ const azure = {
+ azureOpenAIApiInstanceName: 'test-instance',
+ azureOpenAIApiDeploymentName: 'original-deployment',
+ azureOpenAIApiVersion: '2023-05-15',
+ azureOpenAIApiKey: 'azure-key',
+ };
+
+ const modelOptions = { model: 'gpt-4.0-turbo' };
+ const result = getOpenAIConfig(mockApiKey, { azure, modelOptions });
+
+ // Should sanitize model name by removing dots
+ expect(result.llmConfig.model).toBe('gpt-40-turbo');
+ expect((result.llmConfig as Record<string, unknown>).azureOpenAIApiDeploymentName).toBe(
+ 'gpt-40-turbo',
+ );
+
+ // Cleanup
+ if (originalEnv !== undefined) {
+ process.env.AZURE_USE_MODEL_AS_DEPLOYMENT_NAME = originalEnv;
+ } else {
+ delete process.env.AZURE_USE_MODEL_AS_DEPLOYMENT_NAME;
+ }
+ });
+
+ it('should use default Azure deployment name when not using model name', () => {
+ const originalEnv = process.env.AZURE_USE_MODEL_AS_DEPLOYMENT_NAME;
+ delete process.env.AZURE_USE_MODEL_AS_DEPLOYMENT_NAME;
+
+ const azure = {
+ azureOpenAIApiInstanceName: 'test-instance',
+ azureOpenAIApiDeploymentName: 'custom-deployment',
+ azureOpenAIApiVersion: '2023-05-15',
+ azureOpenAIApiKey: 'azure-key',
+ };
+
+ const result = getOpenAIConfig(mockApiKey, { azure });
+
+ expect((result.llmConfig as Record<string, unknown>).azureOpenAIApiDeploymentName).toBe(
+ 'custom-deployment',
+ );
+ expect(result.llmConfig.model).toBe('custom-deployment');
+
+ // Cleanup
+ if (originalEnv !== undefined) {
+ process.env.AZURE_USE_MODEL_AS_DEPLOYMENT_NAME = originalEnv;
+ }
+ });
+
+ it('should handle Azure default model from environment', () => {
+ const originalEnv = process.env.AZURE_OPENAI_DEFAULT_MODEL;
+ process.env.AZURE_OPENAI_DEFAULT_MODEL = 'gpt-4-env-default';
+
+ const azure = {
+ azureOpenAIApiInstanceName: 'test-instance',
+ azureOpenAIApiDeploymentName: 'deployment',
+ azureOpenAIApiVersion: '2023-05-15',
+ azureOpenAIApiKey: 'azure-key',
+ };
+
+ const result = getOpenAIConfig(mockApiKey, { azure });
+
+ expect(result.llmConfig.model).toBe('deployment'); // deployment name takes precedence
+
+ // Cleanup
+ if (originalEnv !== undefined) {
+ process.env.AZURE_OPENAI_DEFAULT_MODEL = originalEnv;
+ } else {
+ delete process.env.AZURE_OPENAI_DEFAULT_MODEL;
+ }
+ });
+
+ it('should construct Azure base URL correctly', () => {
+ const azure = {
+ azureOpenAIApiInstanceName: 'test-instance',
+ azureOpenAIApiDeploymentName: 'test-deployment',
+ azureOpenAIApiVersion: '2023-05-15',
+ azureOpenAIApiKey: 'azure-key',
+ };
+
+ const result = getOpenAIConfig(mockApiKey, {
+ azure,
+ reverseProxyUrl: 'https://${INSTANCE_NAME}.openai.azure.com/openai/v1',
+ });
+
+ // The constructAzureURL should replace placeholders with actual values
+ expect((result.llmConfig as Record<string, unknown>).azureOpenAIBasePath).toBe(
+ 'https://test-instance.openai.azure.com/openai/v1',
+ );
+ });
+
+ it('should handle Azure Responses API configuration', () => {
+ const azure = {
+ azureOpenAIApiInstanceName: 'test-instance',
+ azureOpenAIApiDeploymentName: 'test-deployment',
+ azureOpenAIApiVersion: '2023-05-15',
+ azureOpenAIApiKey: 'azure-key',
+ };
+
+ const modelOptions = { useResponsesApi: true };
+ const result = getOpenAIConfig(mockApiKey, { azure, modelOptions });
+
+ // Should construct the responses API URL
+ expect(result.configOptions?.baseURL).toContain('test-instance.openai.azure.com');
+ expect(result.configOptions?.defaultHeaders).toMatchObject({
+ 'api-key': mockApiKey,
+ });
+ expect(result.configOptions?.defaultQuery).toMatchObject({
+ 'api-version': 'preview',
+ });
+ expect(result.llmConfig.apiKey).toBe(mockApiKey);
+ expect(
+ (result.llmConfig as Record<string, unknown>).azureOpenAIApiDeploymentName,
+ ).toBeUndefined();
+ expect(
+ (result.llmConfig as Record<string, unknown>).azureOpenAIApiInstanceName,
+ ).toBeUndefined();
+ });
+
+ it('should handle Azure with organization from environment', () => {
+ const originalOrg = process.env.OPENAI_ORGANIZATION;
+ process.env.OPENAI_ORGANIZATION = 'test-org-123';
+
+ const azure = {
+ azureOpenAIApiInstanceName: 'test-instance',
+ azureOpenAIApiDeploymentName: 'test-deployment',
+ azureOpenAIApiVersion: '2023-05-15',
+ azureOpenAIApiKey: 'azure-key',
+ };
+
+ const result = getOpenAIConfig(mockApiKey, { azure });
+
+ expect(result.configOptions?.organization).toBe('test-org-123');
+
+ // Cleanup
+ if (originalOrg !== undefined) {
+ process.env.OPENAI_ORGANIZATION = originalOrg;
+ } else {
+ delete process.env.OPENAI_ORGANIZATION;
+ }
+ });
+ });
+
+ describe('OpenRouter Configuration', () => {
+ it('should detect OpenRouter from endpoint parameter', () => {
+ const result = getOpenAIConfig(mockApiKey, {}, 'openrouter');
+
+ expect(result.llmConfig.include_reasoning).toBe(true);
+ expect(result.provider).toBe('openrouter');
+ });
+
+ it('should handle OpenRouter with reasoning params', () => {
+ const modelOptions = {
+ reasoning_effort: ReasoningEffort.high,
+ reasoning_summary: ReasoningSummary.detailed,
+ };
+
+ const result = getOpenAIConfig(mockApiKey, {
+ reverseProxyUrl: 'https://openrouter.ai/api/v1',
+ modelOptions,
+ });
+
+ expect(result.llmConfig.reasoning).toEqual({
+ effort: ReasoningEffort.high,
+ summary: ReasoningSummary.detailed,
+ });
+ expect(result.provider).toBe('openrouter');
+ });
+
+ it('should merge custom headers with OpenRouter defaults', () => {
+ const customHeaders = {
+ 'X-Custom-Header': 'custom-value',
+ Authorization: 'Bearer custom-token',
+ };
+
+ const result = getOpenAIConfig(mockApiKey, {
+ reverseProxyUrl: 'https://openrouter.ai/api/v1',
+ headers: customHeaders,
+ });
+
+ expect(result.configOptions?.defaultHeaders).toEqual({
+ 'HTTP-Referer': 'https://librechat.ai',
+ 'X-Title': 'LibreChat',
+ 'X-Custom-Header': 'custom-value',
+ Authorization: 'Bearer custom-token',
+ });
+ });
+ });
+
+ describe('Direct Endpoint Configuration', () => {
+ it('should create custom fetch for direct endpoint', () => {
+ const result = getOpenAIConfig(mockApiKey, {
+ directEndpoint: true,
+ reverseProxyUrl: 'https://direct-api.com',
+ });
+
+ // Should have a custom fetch function when directEndpoint is true
+ expect(result.configOptions?.fetch).toBeDefined();
+ expect(typeof result.configOptions?.fetch).toBe('function');
+ });
+
+ it('should not create custom fetch when directEndpoint is false', () => {
+ const result = getOpenAIConfig(mockApiKey, {
+ directEndpoint: false,
+ reverseProxyUrl: 'https://proxy-api.com',
+ });
+
+ expect(result.configOptions?.fetch).toBeUndefined();
+ });
+
+ it('should not create custom fetch when baseURL is not set', () => {
+ const result = getOpenAIConfig(mockApiKey, {
+ directEndpoint: true,
+ });
+
+ expect(result.configOptions?.fetch).toBeUndefined();
+ });
+ });
+
+ describe('Edge Cases and Error Handling', () => {
+ it('should handle null and undefined values in reasoning params', () => {
+ const testCases = [
+ { reasoning_effort: null, reasoning_summary: null, shouldHaveReasoning: false },
+ { reasoning_effort: undefined, reasoning_summary: undefined, shouldHaveReasoning: false },
+ { reasoning_effort: '', reasoning_summary: '', shouldHaveReasoning: false },
+ {
+ reasoning_effort: null,
+ reasoning_summary: ReasoningSummary.concise,
+ shouldHaveReasoning: true,
+ },
+ {
+ reasoning_effort: ReasoningEffort.low,
+ reasoning_summary: null,
+ shouldHaveReasoning: true,
+ },
+ ];
+
+ testCases.forEach(({ shouldHaveReasoning, ...modelOptions }) => {
+ const result = getOpenAIConfig(mockApiKey, {
+ modelOptions: { ...modelOptions, useResponsesApi: true } as Partial<OpenAIParameters>,
+ });
+
+ if (shouldHaveReasoning) {
+ expect(result.llmConfig?.reasoning).toBeDefined();
+ } else {
+ expect(result.llmConfig?.reasoning).toBeUndefined();
+ }
+ });
+ });
+
+ it('should handle empty dropParams array', () => {
+ const modelOptions = {
+ temperature: 0.7,
+ topP: 0.9,
+ };
+
+ const result = getOpenAIConfig(mockApiKey, {
+ modelOptions,
+ dropParams: [],
+ });
+
+ expect(result.llmConfig.temperature).toBe(0.7);
+ expect(result.llmConfig.topP).toBe(0.9);
+ });
+
+ it('should handle non-array dropParams gracefully', () => {
+ const modelOptions = {
+ temperature: 0.7,
+ topP: 0.9,
+ };
+
+ const result = getOpenAIConfig(mockApiKey, {
+ modelOptions,
+ /** Invalid type */
+ dropParams: 'temperature' as unknown as string[],
+ });
+
+ // Should not crash and should keep all params
+ expect(result.llmConfig.temperature).toBe(0.7);
+ expect(result.llmConfig.topP).toBe(0.9);
+ });
+
+ it('should handle max_tokens conversion edge cases', () => {
+ const testCases = [
+ { model: 'gpt-4', max_tokens: 1000 }, // Should keep maxTokens
+ { model: 'gpt-5', max_tokens: null }, // Should not create modelKwargs
+ { model: 'gpt-6', max_tokens: undefined }, // Should not create modelKwargs
+ { model: 'gpt-7', max_tokens: 0 }, // Should handle zero
+ ];
+
+ testCases.forEach(({ model, max_tokens }) => {
+ const result = getOpenAIConfig(mockApiKey, {
+ modelOptions: { model, max_tokens: max_tokens ?? undefined },
+ });
+
+ if (model === 'gpt-4') {
+ expect(result.llmConfig.maxTokens).toBe(1000);
+ expect(result.llmConfig.modelKwargs).toBeUndefined();
+ } else if (max_tokens != null) {
+ expect(result.llmConfig.maxTokens).toBeUndefined();
+ expect(result.llmConfig.modelKwargs?.max_completion_tokens).toBe(max_tokens);
+ } else {
+ expect(result.llmConfig.maxTokens).toBeUndefined();
+ expect(result.llmConfig.modelKwargs).toBeUndefined();
+ }
+ });
+ });
+
+ it('should handle various search model patterns', () => {
+ const searchModels = [
+ 'gpt-4o-search',
+ 'gpt-4o-mini-search',
+ 'gpt-4o-2024-search',
+ 'custom-gpt-4o-search-model',
+ ];
+
+ searchModels.forEach((model) => {
+ const modelOptions = {
+ model,
+ temperature: 0.7,
+ frequency_penalty: 0.5,
+ presence_penalty: 0.6,
+ max_tokens: 1000,
+ custom_param: 'should-remain',
+ };
+
+ const result = getOpenAIConfig(mockApiKey, { modelOptions });
+
+ expect(result.llmConfig.temperature).toBeUndefined();
+ expect((result.llmConfig as Record<string, unknown>).frequency_penalty).toBeUndefined();
+ expect((result.llmConfig as Record<string, unknown>).presence_penalty).toBeUndefined();
+ /** `frequency_penalty` is converted to `frequencyPenalty` */
+ expect(result.llmConfig.frequencyPenalty).toBe(0.5);
+ expect(result.llmConfig.presencePenalty).toBe(0.6);
+ /** `presence_penalty` is converted to `presencePenalty` */
+ expect(result.llmConfig.maxTokens).toBe(1000); // max_tokens is allowed
+ expect((result.llmConfig as Record<string, unknown>).custom_param).toBe('should-remain');
+ });
+ });
+
+ it('should preserve streaming default when not specified', () => {
+ const result = getOpenAIConfig(mockApiKey, {});
+ expect(result.llmConfig.streaming).toBe(true);
+ });
+
+ it('should override streaming when explicitly set', () => {
+ const result = getOpenAIConfig(mockApiKey, { streaming: false });
+ expect(result.llmConfig.streaming).toBe(false);
+ });
+ });
+
+ describe('Parameter Classification', () => {
+ it('should correctly identify all known OpenAI parameters', () => {
+ const allKnownParams = Array.from(knownOpenAIParams);
+ const testParams: Record<string, unknown> = {};
+
+ // Create test object with all known params
+ allKnownParams.forEach((param) => {
+ testParams[param] = `test-${param}`;
+ });
+
+ const result = getOpenAIConfig(mockApiKey, { addParams: testParams });
+
+ // All should be in llmConfig, none in modelKwargs
+ expect(result.llmConfig.modelKwargs).toBeUndefined();
+
+ // Check a few key parameters are correctly placed
+ expect((result.llmConfig as Record<string, unknown>).model).toBe('test-model');
+ expect((result.llmConfig as Record<string, unknown>).temperature).toBe('test-temperature');
+ expect((result.llmConfig as Record<string, unknown>).maxTokens).toBe('test-maxTokens');
+ });
+
+ it('should handle mixed case and underscore variations', () => {
+ const addParams = {
+ maxTokens: 1000, // camelCase - known
+ topP: 0.9, // camelCase - known
+ top_p: 0.8, // snake_case - unknown, should go to modelKwargs
+ customParam: 'value', // unknown
+ };
+
+ const result = getOpenAIConfig(mockApiKey, { addParams });
+
+ expect(result.llmConfig.maxTokens).toBe(1000);
+ expect(result.llmConfig.topP).toBe(0.9);
+ expect(result.llmConfig.modelKwargs).toEqual({
+ top_p: 0.8,
+ customParam: 'value',
+ });
+ });
+ });
+
+ describe('Complex Integration Scenarios', () => {
+ it('should handle Azure + OpenRouter combination (OpenRouter still detected)', () => {
+ const azure = {
+ azureOpenAIApiInstanceName: 'test-instance',
+ azureOpenAIApiDeploymentName: 'test-deployment',
+ azureOpenAIApiVersion: '2023-05-15',
+ azureOpenAIApiKey: 'azure-key',
+ };
+
+ const result = getOpenAIConfig(mockApiKey, {
+ azure,
+ reverseProxyUrl: 'https://openrouter.ai/api/v1',
+ });
+
+ // Azure config should be present
+ expect((result.llmConfig as Record<string, unknown>).azureOpenAIApiInstanceName).toBe(
+ 'test-instance',
+ );
+ // But OpenRouter is still detected from URL
+ expect(result.provider).toBe('openrouter');
+ expect(result.llmConfig.include_reasoning).toBe(true);
+ });
+
+ it('should handle all configuration options together', () => {
+ const complexConfig = {
+ modelOptions: {
+ model: 'gpt-4-turbo',
+ temperature: 0.7,
+ max_tokens: 2000,
+ verbosity: Verbosity.medium,
+ reasoning_effort: ReasoningEffort.high,
+ web_search: true,
+ },
+ reverseProxyUrl: 'https://api.custom.com',
+ headers: { 'X-Custom': 'value' },
+ defaultQuery: { version: 'v1' },
+ proxy: 'http://proxy.com:8080',
+ streaming: false,
+ addParams: {
+ customParam: 'custom-value',
+ temperature: 0.8, // Should override modelOptions
+ },
+ dropParams: ['frequency_penalty'],
+ };
+
+ const result = getOpenAIConfig(mockApiKey, complexConfig);
+
+ expect(result.llmConfig).toMatchObject({
+ model: 'gpt-4-turbo',
+ temperature: 0.8, // From addParams
+ streaming: false,
+ useResponsesApi: true, // From web_search
+ });
+ expect(result.llmConfig.maxTokens).toBe(2000);
+ expect(result.llmConfig.modelKwargs).toEqual({
+ text: { verbosity: Verbosity.medium },
+ customParam: 'custom-value',
+ });
+ expect(result.tools).toEqual([{ type: 'web_search_preview' }]);
+ expect(result.configOptions).toMatchObject({
+ baseURL: 'https://api.custom.com',
+ defaultHeaders: { 'X-Custom': 'value' },
+ defaultQuery: { version: 'v1' },
+ fetchOptions: expect.objectContaining({
+ dispatcher: expect.any(Object),
+ }),
+ });
+ });
+ });
+
+ describe('Real Usage Integration Tests', () => {
+ describe('OpenAI Initialize.js Simulation', () => {
+ it('should handle OpenAI endpoint configuration like initialize.js', () => {
+ // Simulate the configuration from OpenAI initialize.js
+ const modelName = 'gpt-4-turbo';
+ const endpointOption = {
+ model_parameters: {
+ temperature: 0.7,
+ max_tokens: 2048,
+ top_p: 0.9,
+ frequency_penalty: 0.1,
+ presence_penalty: 0.1,
+ },
+ };
+
+ // Simulate clientOptions from initialize.js
+ const clientOptions = {
+ contextStrategy: 'summarize',
+ proxy: null,
+ debug: false,
+ reverseProxyUrl: null,
+ streamRate: 30,
+ titleModel: 'gpt-3.5-turbo',
+ titleMethod: 'completion',
+ modelOptions: {
+ model: modelName,
+ user: 'test-user-id',
+ ...endpointOption.model_parameters,
+ },
+ };
+
+ const result = getOpenAIConfig(mockApiKey, clientOptions);
+
+ expect(result.llmConfig).toMatchObject({
+ model: modelName,
+ temperature: 0.7,
+ maxTokens: 2048,
+ // topP is converted from top_p in modelOptions
+ frequencyPenalty: 0.1, // converted from frequency_penalty
+ presencePenalty: 0.1, // converted from presence_penalty
+ user: 'test-user-id',
+ streaming: true, // default
+ apiKey: mockApiKey,
+ });
+ expect(result.configOptions).toEqual({});
+ expect(result.tools).toEqual([]);
+ });
+
+ it('should handle Azure OpenAI configuration like initialize.js', () => {
+ // Simulate Azure configuration from mapModelToAzureConfig
+ const modelName = 'gpt-4-turbo';
+ const azureOptions = {
+ azureOpenAIApiKey: 'azure-key-123',
+ azureOpenAIApiInstanceName: 'prod-instance',
+ azureOpenAIApiDeploymentName: 'gpt-4-turbo-deployment',
+ azureOpenAIApiVersion: '2023-12-01-preview',
+ };
+ const baseURL = 'https://prod-instance.openai.azure.com';
+ const headers = {
+ 'X-Custom-Header': 'azure-value',
+ Authorization: 'Bearer custom-token',
+ };
+
+ // Simulate clientOptions from Azure initialize.js
+ const clientOptions = {
+ contextStrategy: null,
+ proxy: null,
+ debug: false,
+ reverseProxyUrl: baseURL,
+ headers,
+ titleConvo: true,
+ titleModel: 'gpt-3.5-turbo',
+ streamRate: 30,
+ titleMethod: 'completion',
+ azure: azureOptions,
+ addParams: {
+ temperature: 0.8,
+ max_completion_tokens: 4000,
+ },
+ dropParams: ['frequency_penalty'],
+ forcePrompt: false,
+ modelOptions: {
+ model: modelName,
+ user: 'azure-user-123',
+ temperature: 0.7, // Should be overridden by addParams
+ frequency_penalty: 0.2, // Should be dropped
+ },
+ };
+
+ const result = getOpenAIConfig(mockApiKey, clientOptions);
+
+ expect(result.llmConfig).toMatchObject({
+ model: 'gpt-4-turbo-deployment', // Uses deployment name
+ temperature: 0.8, // From addParams
+ user: 'azure-user-123',
+ streaming: true,
+ azureOpenAIApiKey: 'azure-key-123',
+ azureOpenAIApiInstanceName: 'prod-instance',
+ azureOpenAIApiDeploymentName: 'gpt-4-turbo-deployment',
+ azureOpenAIApiVersion: '2023-12-01-preview',
+ });
+ expect((result.llmConfig as Record<string, unknown>).frequency_penalty).toBeUndefined(); // Dropped
+ expect(result.llmConfig.modelKwargs).toMatchObject({
+ max_completion_tokens: 4000,
+ });
+ expect(result.configOptions).toMatchObject({
+ baseURL: baseURL,
+ defaultHeaders: headers,
+ });
+ });
+
+ it('should handle Azure serverless configuration', () => {
+ const modelName = 'gpt-4';
+ const azureOptions = {
+ azureOpenAIApiKey: 'serverless-key',
+ azureOpenAIApiInstanceName: 'serverless-instance',
+ azureOpenAIApiDeploymentName: 'gpt-4-serverless',
+ azureOpenAIApiVersion: '2024-02-15-preview',
+ };
+
+ const clientOptions = {
+ reverseProxyUrl: 'https://serverless.openai.azure.com/openai/v1',
+ headers: {
+ 'api-key': azureOptions.azureOpenAIApiKey,
+ },
+ defaultQuery: {
+ 'api-version': azureOptions.azureOpenAIApiVersion,
+ },
+ azure: false as const, // Serverless doesn't use azure object
+ modelOptions: {
+ model: modelName,
+ user: 'serverless-user',
+ },
+ };
+
+ const result = getOpenAIConfig(azureOptions.azureOpenAIApiKey, clientOptions);
+
+ expect(result.llmConfig).toMatchObject({
+ model: modelName,
+ user: 'serverless-user',
+ apiKey: azureOptions.azureOpenAIApiKey,
+ });
+ expect(result.configOptions).toMatchObject({
+ baseURL: 'https://serverless.openai.azure.com/openai/v1',
+ defaultHeaders: {
+ 'api-key': azureOptions.azureOpenAIApiKey,
+ },
+ defaultQuery: {
+ 'api-version': azureOptions.azureOpenAIApiVersion,
+ },
+ });
+ });
+ });
+
+ describe('Custom Endpoint Initialize.js Simulation', () => {
+ it('should handle custom endpoint configuration like initialize.js', () => {
+ const endpoint = 'custom-openai';
+ const apiKey = 'custom-api-key-456';
+ const baseURL = 'https://api.custom-provider.com/v1';
+
+ // Simulate endpointConfig from custom initialize.js
+ const endpointConfig = {
+ apiKey: 'user_provided',
+ baseURL: baseURL,
+ headers: {
+ 'X-Custom-Provider': 'LibreChat',
+ 'User-Agent': 'LibreChat/1.0',
+ },
+ addParams: {
+ custom_parameter: 'custom_value',
+ temperature: 0.9,
+ },
+ dropParams: ['presence_penalty'],
+ titleConvo: true,
+ titleModel: 'gpt-3.5-turbo',
+ forcePrompt: false,
+ summaryModel: 'gpt-3.5-turbo',
+ modelDisplayLabel: 'Custom GPT-4',
+ titleMethod: 'completion',
+ contextStrategy: 'summarize',
+ directEndpoint: true,
+ titleMessageRole: 'user',
+ streamRate: 25,
+ };
+
+ const clientOptions = {
+ reverseProxyUrl: baseURL,
+ proxy: null,
+ headers: endpointConfig.headers,
+ addParams: endpointConfig.addParams,
+ dropParams: endpointConfig.dropParams,
+ customParams: {},
+ titleConvo: endpointConfig.titleConvo,
+ titleModel: endpointConfig.titleModel,
+ forcePrompt: endpointConfig.forcePrompt,
+ summaryModel: endpointConfig.summaryModel,
+ modelDisplayLabel: endpointConfig.modelDisplayLabel,
+ titleMethod: endpointConfig.titleMethod,
+ contextStrategy: endpointConfig.contextStrategy,
+ directEndpoint: endpointConfig.directEndpoint,
+ titleMessageRole: endpointConfig.titleMessageRole,
+ streamRate: endpointConfig.streamRate,
+ modelOptions: {
+ model: 'gpt-4-custom',
+ user: 'custom-user-789',
+ presence_penalty: 0.3, // Should be dropped
+ max_tokens: 3000,
+ },
+ };
+
+ const result = getOpenAIConfig(apiKey, clientOptions, endpoint);
+
+ expect(result.llmConfig).toMatchObject({
+ model: 'gpt-4-custom',
+ user: 'custom-user-789',
+ temperature: 0.9, // From addParams
+ maxTokens: 3000,
+ apiKey: apiKey,
+ });
+ expect((result.llmConfig as Record<string, unknown>).presence_penalty).toBeUndefined(); // Dropped
+ expect(result.llmConfig.modelKwargs).toMatchObject({
+ custom_parameter: 'custom_value',
+ });
+ expect(result.configOptions).toMatchObject({
+ baseURL: baseURL,
+ defaultHeaders: endpointConfig.headers,
+ fetch: expect.any(Function), // directEndpoint creates custom fetch
+ });
+ });
+
+ it('should handle OpenRouter configuration like custom initialize.js', () => {
+ const endpoint = 'openrouter';
+ const apiKey = 'sk-or-v1-custom-key';
+ const baseURL = 'https://openrouter.ai/api/v1';
+
+ const clientOptions = {
+ reverseProxyUrl: baseURL,
+ headers: {
+ 'HTTP-Referer': 'https://librechat.ai',
+ 'X-Title': 'LibreChat',
+ Authorization: `Bearer ${apiKey}`,
+ },
+ addParams: {
+ top_k: 50,
+ repetition_penalty: 1.1,
+ },
+ modelOptions: {
+ model: 'anthropic/claude-3-sonnet',
+ user: 'openrouter-user',
+ temperature: 0.7,
+ max_tokens: 4000,
+ reasoning_effort: ReasoningEffort.high,
+ reasoning_summary: ReasoningSummary.detailed,
+ },
+ };
+
+ const result = getOpenAIConfig(apiKey, clientOptions, endpoint);
+
+ expect(result.llmConfig).toMatchObject({
+ model: 'anthropic/claude-3-sonnet',
+ user: 'openrouter-user',
+ temperature: 0.7,
+ maxTokens: 4000,
+ include_reasoning: true, // OpenRouter specific
+ reasoning: {
+ effort: ReasoningEffort.high,
+ summary: ReasoningSummary.detailed,
+ },
+ apiKey: apiKey,
+ });
+ expect(result.llmConfig.modelKwargs).toMatchObject({
+ top_k: 50,
+ repetition_penalty: 1.1,
+ });
+ expect(result.configOptions?.defaultHeaders).toMatchObject({
+ 'HTTP-Referer': 'https://librechat.ai',
+ 'X-Title': 'LibreChat',
+ Authorization: `Bearer ${apiKey}`,
+ });
+ expect(result.provider).toBe('openrouter');
+ });
+ });
+
+ describe('Production-like Azure Scenarios', () => {
+ it('should handle complex Azure multi-group configuration', () => {
+ // Simulate a production Azure setup with multiple groups
+ const modelName = 'gpt-4-turbo';
+ const azureConfig = {
+ azureOpenAIApiKey: 'prod-key-multi',
+ azureOpenAIApiInstanceName: 'prod-east-instance',
+ azureOpenAIApiDeploymentName: 'gpt-4-turbo-prod',
+ azureOpenAIApiVersion: '2024-02-15-preview',
+ };
+
+ const clientOptions = {
+ reverseProxyUrl: 'https://prod-east-instance.openai.azure.com',
+ headers: {
+ 'X-Environment': 'production',
+ 'X-Region': 'us-east-1',
+ 'Content-Type': 'application/json',
+ },
+ azure: azureConfig,
+ addParams: {
+ temperature: 0.2, // Conservative for production
+ max_completion_tokens: 8192,
+ topP: 0.95, // Use camelCase for known param
+ frequencyPenalty: 0.0, // Use camelCase for known param
+ presencePenalty: 0.0, // Use camelCase for known param
+ seed: 12345, // For reproducibility
+ },
+ dropParams: [], // Don't drop any params in prod
+ modelOptions: {
+ model: modelName,
+ user: 'prod-user-session-abc123',
+ stream: true,
+ },
+ };
+
+ const result = getOpenAIConfig(mockApiKey, clientOptions);
+
+ expect(result.llmConfig).toMatchObject({
+ model: 'gpt-4-turbo-prod',
+ user: 'prod-user-session-abc123',
+ temperature: 0.2,
+ // Parameters from addParams are processed
+ seed: 12345,
+ stream: true,
+ azureOpenAIApiKey: 'prod-key-multi',
+ azureOpenAIApiInstanceName: 'prod-east-instance',
+ azureOpenAIApiDeploymentName: 'gpt-4-turbo-prod',
+ azureOpenAIApiVersion: '2024-02-15-preview',
+ });
+ // Check that camelCase conversions happened
+ expect(result.llmConfig.topP).toBe(0.95);
+ expect(result.llmConfig.frequencyPenalty).toBe(0.0);
+ expect(result.llmConfig.presencePenalty).toBe(0.0);
+ expect(result.llmConfig.modelKwargs).toMatchObject({
+ max_completion_tokens: 8192,
+ });
+ expect(result.configOptions?.baseURL).toBe('https://prod-east-instance.openai.azure.com');
+ });
+
+ it('should handle Azure with environment variable placeholders', () => {
+ const originalEnv = {
+ INSTANCE_NAME: process.env.INSTANCE_NAME,
+ DEPLOYMENT_NAME: process.env.DEPLOYMENT_NAME,
+ API_VERSION: process.env.API_VERSION,
+ };
+
+ // Set environment variables
+ process.env.INSTANCE_NAME = 'env-instance';
+ process.env.DEPLOYMENT_NAME = 'env-deployment';
+ process.env.API_VERSION = '2024-03-01-preview';
+
+ const clientOptions = {
+ reverseProxyUrl: 'https://${INSTANCE_NAME}.openai.azure.com/openai/v1',
+ azure: {
+ azureOpenAIApiKey: 'env-key',
+ azureOpenAIApiInstanceName: '${INSTANCE_NAME}',
+ azureOpenAIApiDeploymentName: '${DEPLOYMENT_NAME}',
+ azureOpenAIApiVersion: '${API_VERSION}',
+ },
+ modelOptions: {
+ model: 'gpt-4',
+ user: 'env-user',
+ },
+ };
+
+ const result = getOpenAIConfig(mockApiKey, clientOptions);
+
+ // The constructAzureURL should process placeholders (actual replacement depends on implementation)
+ expect((result.llmConfig as Record<string, unknown>).azureOpenAIBasePath).toBeDefined();
+ expect(result.llmConfig.model).toBe('${DEPLOYMENT_NAME}'); // Model becomes deployment name
+
+ // Cleanup
+ Object.entries(originalEnv).forEach(([key, value]) => {
+ if (value !== undefined) {
+ process.env[key] = value;
+ } else {
+ delete process.env[key];
+ }
+ });
+ });
+ });
+
+ describe('Error Handling and Edge Cases from Real Usage', () => {
+ it('should handle missing API key scenario', () => {
+ expect(() => {
+ getOpenAIConfig('', {
+ modelOptions: { model: 'gpt-4' },
+ });
+ }).not.toThrow(); // The function itself doesn't validate empty keys
+ });
+
+ it('should handle malformed Azure configuration gracefully', () => {
+ const clientOptions = {
+ azure: {
+ azureOpenAIApiKey: 'valid-key',
+ // Missing required fields
+ } as Partial<AzureOptions>,
+ modelOptions: {
+ model: 'gpt-4',
+ },
+ };
+
+ const result = getOpenAIConfig(mockApiKey, clientOptions);
+ expect(result.llmConfig).toBeDefined();
+ });
+
+ it('should handle large parameter sets without performance issues', () => {
+ const largeAddParams: Record<string, unknown> = {};
+ const largeModelKwargs: Record<string, unknown> = {};
+
+ // Create 50 unknown parameters (using names not in knownOpenAIParams)
+ for (let i = 0; i < 50; i++) {
+ largeAddParams[`unknown_param_${i}`] = 0.5;
+ }
+
+ // Create 50 more unknown parameters
+ for (let i = 0; i < 50; i++) {
+ largeAddParams[`custom_param_${i}`] = `value_${i}`;
+ largeModelKwargs[`unknown_param_${i}`] = 0.5;
+ largeModelKwargs[`custom_param_${i}`] = `value_${i}`;
+ }
+
+ const startTime = Date.now();
+ const result = getOpenAIConfig(mockApiKey, {
+ addParams: largeAddParams,
+ modelOptions: { model: 'gpt-4' },
+ });
+ const endTime = Date.now();
+
+ expect(endTime - startTime).toBeLessThan(100); // Should be fast
+ expect(result.llmConfig.modelKwargs).toEqual(largeModelKwargs);
+ });
+ });
+ });
});
diff --git a/packages/api/src/endpoints/openai/llm.ts b/packages/api/src/endpoints/openai/llm.ts
index 4cc2d81209..cce8d622a1 100644
--- a/packages/api/src/endpoints/openai/llm.ts
+++ b/packages/api/src/endpoints/openai/llm.ts
@@ -104,7 +104,14 @@ export function getOpenAIConfig(
addParams,
dropParams,
} = options;
- const { reasoning_effort, reasoning_summary, verbosity, ...modelOptions } = _modelOptions;
+ const {
+ reasoning_effort,
+ reasoning_summary,
+ verbosity,
+ frequency_penalty,
+ presence_penalty,
+ ...modelOptions
+ } = _modelOptions;
const llmConfig: Partial<t.ClientOptions> &
Partial<t.OpenAIParameters> &
Partial<AzureOpenAIInput> = Object.assign(
@@ -115,6 +122,13 @@ export function getOpenAIConfig(
modelOptions,
);
+ if (frequency_penalty != null) {
+ llmConfig.frequencyPenalty = frequency_penalty;
+ }
+ if (presence_penalty != null) {
+ llmConfig.presencePenalty = presence_penalty;
+ }
+
const modelKwargs: Record<string, unknown> = {};
let hasModelKwargs = false;
diff --git a/packages/api/src/types/openai.ts b/packages/api/src/types/openai.ts
index 8953283a39..387944c0d4 100644
--- a/packages/api/src/types/openai.ts
+++ b/packages/api/src/types/openai.ts
@@ -14,11 +14,11 @@ export type OpenAIParameters = z.infer<typeof openAISchema>;
export interface OpenAIConfigOptions {
modelOptions?: Partial<OpenAIParameters>;
directEndpoint?: boolean;
- reverseProxyUrl?: string;
+ reverseProxyUrl?: string | null;
defaultQuery?: Record<string, string | undefined>;
headers?: Record<string, string>;
- proxy?: string;
- azure?: AzureOptions;
+ proxy?: string | null;
+ azure?: false | AzureOptions;
streaming?: boolean;
addParams?: Record<string, unknown>;
dropParams?: string[];