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
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🔧 fix: Remove Bedrock Config Transform introduced in #9931 (#10628)
Danny Avila35319c135459
diff --git a/api/server/services/Endpoints/bedrock/options.js b/api/server/services/Endpoints/bedrock/options.jsindex 4da13a9ffa..0d02d09b07 100644--- a/api/server/services/Endpoints/bedrock/options.js+++ b/api/server/services/Endpoints/bedrock/options.js@@ -1,4 +1,3 @@-const { resolveHeaders } = require('@librechat/api');const { HttpsProxyAgent } = require('https-proxy-agent');const {AuthType,@@ -89,14 +88,6 @@ const getOptions = async ({ req, overrideModel, endpointOption }) => {llmConfig.endpointHost = BEDROCK_REVERSE_PROXY;}- if (llmConfig.additionalModelRequestFields) {- llmConfig.additionalModelRequestFields = resolveHeaders({- headers: llmConfig.additionalModelRequestFields,- user: req.user,- body: req.body,- });- }-return {/** @type {BedrockClientOptions} */llmConfig,diff --git a/packages/api/src/utils/env.spec.ts b/packages/api/src/utils/env.spec.tsindex 7ef42e893e..e7515de2c3 100644--- a/packages/api/src/utils/env.spec.ts+++ b/packages/api/src/utils/env.spec.ts@@ -1,6 +1,8 @@-import { resolveHeaders, processMCPEnv } from './env';import { TokenExchangeMethodEnum } from 'librechat-data-provider';-import type { TUser, MCPOptions } from 'librechat-data-provider';+import { resolveHeaders, resolveNestedObject, processMCPEnv } from './env';+import type { MCPOptions } from 'librechat-data-provider';+import type { IUser } from '@librechat/data-schemas';+import { Types } from 'mongoose';function isStdioOptions(options: MCPOptions): options is Extract<MCPOptions, { type?: 'stdio' }> {return !options.type || options.type === 'stdio';@@ -13,19 +15,21 @@ function isStreamableHTTPOptions(}/** Helper function to create test user objects */-function createTestUser(overrides: Partial<TUser> = {}): TUser {+function createTestUser(overrides: Partial<IUser> = {}): IUser {return {- id: 'test-user-id',+ _id: new Types.ObjectId(),+ id: new Types.ObjectId().toString(),username: 'testuser',email: '[email protected]',name: 'Test User',avatar: 'https://example.com/avatar.png',provider: 'email',role: 'user',- createdAt: new Date('2021-01-01').toISOString(),- updatedAt: new Date('2021-01-01').toISOString(),+ createdAt: new Date('2021-01-01'),+ updatedAt: new Date('2021-01-01'),+ emailVerified: true,...overrides,- };+ } as IUser;}describe('resolveHeaders', () => {@@ -445,6 +449,428 @@ describe('resolveHeaders', () => {const result = resolveHeaders({ headers, body });expect(result['X-Conversation']).toBe('conv-123');});++ describe('non-string header values (type guard tests)', () => {+ it('should handle numeric header values without crashing', () => {+ const headers = {+ 'X-Number': 12345 as unknown as string,+ 'X-String': 'normal-string',+ };+ const result = resolveHeaders({ headers });+ expect(result['X-Number']).toBe('12345');+ expect(result['X-String']).toBe('normal-string');+ });++ it('should handle boolean header values without crashing', () => {+ const headers = {+ 'X-Boolean-True': true as unknown as string,+ 'X-Boolean-False': false as unknown as string,+ 'X-String': 'normal-string',+ };+ const result = resolveHeaders({ headers });+ expect(result['X-Boolean-True']).toBe('true');+ expect(result['X-Boolean-False']).toBe('false');+ expect(result['X-String']).toBe('normal-string');+ });++ it('should handle null and undefined header values', () => {+ const headers = {+ 'X-Null': null as unknown as string,+ 'X-Undefined': undefined as unknown as string,+ 'X-String': 'normal-string',+ };+ const result = resolveHeaders({ headers });+ expect(result['X-Null']).toBe('null');+ expect(result['X-Undefined']).toBe('undefined');+ expect(result['X-String']).toBe('normal-string');+ });++ it('should handle numeric values with placeholders', () => {+ const user = { id: 'user-123' };+ const headers = {+ 'X-Number': 42 as unknown as string,+ 'X-String-With-Placeholder': '{{LIBRECHAT_USER_ID}}',+ };+ const result = resolveHeaders({ headers, user });+ expect(result['X-Number']).toBe('42');+ expect(result['X-String-With-Placeholder']).toBe('user-123');+ });++ it('should handle objects in header values', () => {+ const headers = {+ 'X-Object': { nested: 'value' } as unknown as string,+ 'X-String': 'normal-string',+ };+ const result = resolveHeaders({ headers });+ expect(result['X-Object']).toBe('[object Object]');+ expect(result['X-String']).toBe('normal-string');+ });++ it('should handle arrays in header values', () => {+ const headers = {+ 'X-Array': ['value1', 'value2'] as unknown as string,+ 'X-String': 'normal-string',+ };+ const result = resolveHeaders({ headers });+ expect(result['X-Array']).toBe('value1,value2');+ expect(result['X-String']).toBe('normal-string');+ });++ it('should handle numeric values with env variables', () => {+ process.env.TEST_API_KEY = 'test-api-key-value';+ const headers = {+ 'X-Number': 12345 as unknown as string,+ 'X-Env': '${TEST_API_KEY}',+ };+ const result = resolveHeaders({ headers });+ expect(result['X-Number']).toBe('12345');+ expect(result['X-Env']).toBe('test-api-key-value');+ delete process.env.TEST_API_KEY;+ });++ it('should handle numeric values with body placeholders', () => {+ const body = {+ conversationId: 'conv-123',+ parentMessageId: 'parent-456',+ messageId: 'msg-789',+ };+ const headers = {+ 'X-Number': 999 as unknown as string,+ 'X-Conv': '{{LIBRECHAT_BODY_CONVERSATIONID}}',+ };+ const result = resolveHeaders({ headers, body });+ expect(result['X-Number']).toBe('999');+ expect(result['X-Conv']).toBe('conv-123');+ });++ it('should handle mixed type headers with user and custom vars', () => {+ const user = { id: 'user-123', email: '[email protected]' };+ const customUserVars = { CUSTOM_TOKEN: 'secret-token' };+ const headers = {+ 'X-Number': 42 as unknown as string,+ 'X-Boolean': true as unknown as string,+ 'X-User-Id': '{{LIBRECHAT_USER_ID}}',+ 'X-Custom': '{{CUSTOM_TOKEN}}',+ 'X-String': 'normal',+ };+ const result = resolveHeaders({ headers, user, customUserVars });+ expect(result['X-Number']).toBe('42');+ expect(result['X-Boolean']).toBe('true');+ expect(result['X-User-Id']).toBe('user-123');+ expect(result['X-Custom']).toBe('secret-token');+ expect(result['X-String']).toBe('normal');+ });++ it('should not crash when calling includes on non-string body field values', () => {+ const body = {+ conversationId: 12345 as unknown as string,+ parentMessageId: 'parent-456',+ messageId: 'msg-789',+ };+ const headers = {+ 'X-Conv-Id': '{{LIBRECHAT_BODY_CONVERSATIONID}}',+ 'X-Number': 999 as unknown as string,+ };+ expect(() => resolveHeaders({ headers, body })).not.toThrow();+ const result = resolveHeaders({ headers, body });+ expect(result['X-Number']).toBe('999');+ });+ });+});++describe('resolveNestedObject', () => {+ beforeEach(() => {+ process.env.TEST_API_KEY = 'test-api-key-value';+ process.env.ANOTHER_SECRET = 'another-secret-value';+ });++ afterEach(() => {+ delete process.env.TEST_API_KEY;+ delete process.env.ANOTHER_SECRET;+ });++ it('should preserve nested object structure', () => {+ const obj = {+ thinking: {+ type: 'enabled',+ budget_tokens: 2000,+ },+ anthropic_beta: ['output-128k-2025-02-19'],+ max_tokens: 4096,+ temperature: 0.7,+ };++ const result = resolveNestedObject({ obj });++ expect(result).toEqual({+ thinking: {+ type: 'enabled',+ budget_tokens: 2000,+ },+ anthropic_beta: ['output-128k-2025-02-19'],+ max_tokens: 4096,+ temperature: 0.7,+ });+ });++ it('should process placeholders in string values while preserving structure', () => {+ const user = { id: 'user-123', email: '[email protected]' };+ const obj = {+ thinking: {+ type: 'enabled',+ budget_tokens: 2000,+ user_context: '{{LIBRECHAT_USER_ID}}',+ },+ anthropic_beta: ['output-128k-2025-02-19'],+ api_key: '${TEST_API_KEY}',+ max_tokens: 4096,+ };++ const result = resolveNestedObject({ obj, user });++ expect(result).toEqual({+ thinking: {+ type: 'enabled',+ budget_tokens: 2000,+ user_context: 'user-123',+ },+ anthropic_beta: ['output-128k-2025-02-19'],+ api_key: 'test-api-key-value',+ max_tokens: 4096,+ });+ });++ it('should process strings in arrays', () => {+ const user = { id: 'user-123' };+ const obj = {+ headers: ['Authorization: Bearer ${TEST_API_KEY}', 'X-User-Id: {{LIBRECHAT_USER_ID}}'],+ values: [1, 2, 3],+ mixed: ['string', 42, true, '{{LIBRECHAT_USER_ID}}'],+ };++ const result = resolveNestedObject({ obj, user });++ expect(result).toEqual({+ headers: ['Authorization: Bearer test-api-key-value', 'X-User-Id: user-123'],+ values: [1, 2, 3],+ mixed: ['string', 42, true, 'user-123'],+ });+ });++ it('should handle deeply nested structures', () => {+ const user = { id: 'user-123' };+ const obj = {+ level1: {+ level2: {+ level3: {+ user_id: '{{LIBRECHAT_USER_ID}}',+ settings: {+ api_key: '${TEST_API_KEY}',+ enabled: true,+ },+ },+ },+ },+ };++ const result = resolveNestedObject({ obj, user });++ expect(result).toEqual({+ level1: {+ level2: {+ level3: {+ user_id: 'user-123',+ settings: {+ api_key: 'test-api-key-value',+ enabled: true,+ },+ },+ },+ },+ });+ });++ it('should preserve all primitive types', () => {+ const obj = {+ string: 'text',+ number: 42,+ float: 3.14,+ boolean_true: true,+ boolean_false: false,+ null_value: null,+ undefined_value: undefined,+ };++ const result = resolveNestedObject({ obj });++ expect(result).toEqual(obj);+ });++ it('should handle empty objects and arrays', () => {+ const obj = {+ empty_object: {},+ empty_array: [],+ nested: {+ also_empty: {},+ },+ };++ const result = resolveNestedObject({ obj });++ expect(result).toEqual(obj);+ });++ it('should handle body placeholders in nested objects', () => {+ const body = {+ conversationId: 'conv-123',+ parentMessageId: 'parent-456',+ messageId: 'msg-789',+ };+ const obj = {+ metadata: {+ conversation: '{{LIBRECHAT_BODY_CONVERSATIONID}}',+ parent: '{{LIBRECHAT_BODY_PARENTMESSAGEID}}',+ count: 5,+ },+ };++ const result = resolveNestedObject({ obj, body });++ expect(result).toEqual({+ metadata: {+ conversation: 'conv-123',+ parent: 'parent-456',+ count: 5,+ },+ });+ });++ it('should handle custom user variables in nested objects', () => {+ const customUserVars = {+ CUSTOM_TOKEN: 'secret-token',+ REGION: 'us-west-1',+ };+ const obj = {+ auth: {+ token: '{{CUSTOM_TOKEN}}',+ region: '{{REGION}}',+ timeout: 3000,+ },+ };++ const result = resolveNestedObject({ obj, customUserVars });++ expect(result).toEqual({+ auth: {+ token: 'secret-token',+ region: 'us-west-1',+ timeout: 3000,+ },+ });+ });++ it('should handle mixed placeholders in nested objects', () => {+ const user = { id: 'user-123', email: '[email protected]' };+ const customUserVars = { CUSTOM_VAR: 'custom-value' };+ const body = { conversationId: 'conv-456' };++ const obj = {+ config: {+ user_id: '{{LIBRECHAT_USER_ID}}',+ custom: '{{CUSTOM_VAR}}',+ api_key: '${TEST_API_KEY}',+ conversation: '{{LIBRECHAT_BODY_CONVERSATIONID}}',+ nested: {+ email: '{{LIBRECHAT_USER_EMAIL}}',+ port: 8080,+ },+ },+ };++ const result = resolveNestedObject({ obj, user, customUserVars, body });++ expect(result).toEqual({+ config: {+ user_id: 'user-123',+ custom: 'custom-value',+ api_key: 'test-api-key-value',+ conversation: 'conv-456',+ nested: {+ email: '[email protected]',+ port: 8080,+ },+ },+ });+ });++ it('should handle Bedrock additionalModelRequestFields example', () => {+ const obj = {+ thinking: {+ type: 'enabled',+ budget_tokens: 2000,+ },+ anthropic_beta: ['output-128k-2025-02-19'],+ };++ const result = resolveNestedObject({ obj });++ expect(result).toEqual({+ thinking: {+ type: 'enabled',+ budget_tokens: 2000,+ },+ anthropic_beta: ['output-128k-2025-02-19'],+ });++ expect(typeof result.thinking).toBe('object');+ expect(Array.isArray(result.anthropic_beta)).toBe(true);+ expect(result.thinking).not.toBe('[object Object]');+ });++ it('should return undefined when obj is undefined', () => {+ const result = resolveNestedObject({ obj: undefined });+ expect(result).toBeUndefined();+ });++ it('should return null when obj is null', () => {+ const result = resolveNestedObject({ obj: null });+ expect(result).toBeNull();+ });++ it('should handle arrays of objects', () => {+ const user = { id: 'user-123' };+ const obj = {+ items: [+ { name: 'item1', user: '{{LIBRECHAT_USER_ID}}', count: 1 },+ { name: 'item2', user: '{{LIBRECHAT_USER_ID}}', count: 2 },+ ],+ };++ const result = resolveNestedObject({ obj, user });++ expect(result).toEqual({+ items: [+ { name: 'item1', user: 'user-123', count: 1 },+ { name: 'item2', user: 'user-123', count: 2 },+ ],+ });+ });++ it('should not modify the original object', () => {+ const user = { id: 'user-123' };+ const originalObj = {+ thinking: {+ type: 'enabled',+ budget_tokens: 2000,+ user_id: '{{LIBRECHAT_USER_ID}}',+ },+ };++ const result = resolveNestedObject({ obj: originalObj, user });++ expect(result.thinking.user_id).toBe('user-123');+ expect(originalObj.thinking.user_id).toBe('{{LIBRECHAT_USER_ID}}');+ });});describe('processMCPEnv', () => {@@ -774,4 +1200,181 @@ describe('processMCPEnv', () => {throw new Error('Expected stdio options');}});++ describe('non-string values (type guard tests)', () => {+ it('should handle numeric values in env without crashing', () => {+ const options: MCPOptions = {+ type: 'stdio',+ command: 'mcp-server',+ args: [],+ env: {+ PORT: 8080 as unknown as string,+ TIMEOUT: 30000 as unknown as string,+ API_KEY: '${TEST_API_KEY}',+ },+ };++ const result = processMCPEnv({ options });++ if (isStdioOptions(result)) {+ expect(result.env?.PORT).toBe('8080');+ expect(result.env?.TIMEOUT).toBe('30000');+ expect(result.env?.API_KEY).toBe('test-api-key-value');+ }+ });++ it('should handle boolean values in env without crashing', () => {+ const options: MCPOptions = {+ type: 'stdio',+ command: 'mcp-server',+ args: [],+ env: {+ DEBUG: true as unknown as string,+ PRODUCTION: false as unknown as string,+ API_KEY: '${TEST_API_KEY}',+ },+ };++ const result = processMCPEnv({ options });++ if (isStdioOptions(result)) {+ expect(result.env?.DEBUG).toBe('true');+ expect(result.env?.PRODUCTION).toBe('false');+ expect(result.env?.API_KEY).toBe('test-api-key-value');+ }+ });++ it('should handle numeric values in args without crashing', () => {+ const options: MCPOptions = {+ type: 'stdio',+ command: 'mcp-server',+ args: ['--port', 8080 as unknown as string, '--timeout', 30000 as unknown as string],+ };++ const result = processMCPEnv({ options });++ if (isStdioOptions(result)) {+ expect(result.args).toEqual(['--port', '8080', '--timeout', '30000']);+ }+ });++ it('should handle null and undefined values in env', () => {+ const options: MCPOptions = {+ type: 'stdio',+ command: 'mcp-server',+ args: [],+ env: {+ NULL_VALUE: null as unknown as string,+ UNDEFINED_VALUE: undefined as unknown as string,+ NORMAL_VALUE: 'normal',+ },+ };++ const result = processMCPEnv({ options });++ if (isStdioOptions(result)) {+ expect(result.env?.NULL_VALUE).toBe('null');+ expect(result.env?.UNDEFINED_VALUE).toBe('undefined');+ expect(result.env?.NORMAL_VALUE).toBe('normal');+ }+ });++ it('should handle numeric values in headers without crashing', () => {+ const options: MCPOptions = {+ type: 'streamable-http',+ url: 'https://api.example.com',+ headers: {+ 'X-Timeout': 5000 as unknown as string,+ 'X-Retry-Count': 3 as unknown as string,+ 'Content-Type': 'application/json',+ },+ };++ const result = processMCPEnv({ options });++ if (isStreamableHTTPOptions(result)) {+ expect(result.headers?.['X-Timeout']).toBe('5000');+ expect(result.headers?.['X-Retry-Count']).toBe('3');+ expect(result.headers?.['Content-Type']).toBe('application/json');+ }+ });++ it('should handle numeric URL values', () => {+ const options: MCPOptions = {+ type: 'websocket',+ url: 12345 as unknown as string,+ };++ const result = processMCPEnv({ options });++ expect((result as unknown as { url?: string }).url).toBe('12345');+ });++ it('should handle mixed numeric and placeholder values', () => {+ const user = createTestUser({ id: 'user-123' });+ const options: MCPOptions = {+ type: 'stdio',+ command: 'mcp-server',+ args: [],+ env: {+ PORT: 8080 as unknown as string,+ USER_ID: '{{LIBRECHAT_USER_ID}}',+ API_KEY: '${TEST_API_KEY}',+ },+ };++ const result = processMCPEnv({ options, user });++ if (isStdioOptions(result)) {+ expect(result.env?.PORT).toBe('8080');+ expect(result.env?.USER_ID).toBe('user-123');+ expect(result.env?.API_KEY).toBe('test-api-key-value');+ }+ });++ it('should handle objects and arrays in env values', () => {+ const options: MCPOptions = {+ type: 'stdio',+ command: 'mcp-server',+ args: [],+ env: {+ OBJECT_VALUE: { nested: 'value' } as unknown as string,+ ARRAY_VALUE: ['item1', 'item2'] as unknown as string,+ STRING_VALUE: 'normal',+ },+ };++ const result = processMCPEnv({ options });++ if (isStdioOptions(result)) {+ expect(result.env?.OBJECT_VALUE).toBe('[object Object]');+ expect(result.env?.ARRAY_VALUE).toBe('item1,item2');+ expect(result.env?.STRING_VALUE).toBe('normal');+ }+ });++ it('should not crash with numeric body field values', () => {+ const body = {+ conversationId: 12345 as unknown as string,+ parentMessageId: 'parent-456',+ messageId: 'msg-789',+ };+ const options: MCPOptions = {+ type: 'stdio',+ command: 'mcp-server',+ args: [],+ env: {+ CONV_ID: '{{LIBRECHAT_BODY_CONVERSATIONID}}',+ PORT: 8080 as unknown as string,+ },+ };++ expect(() => processMCPEnv({ options, body })).not.toThrow();+ const result = processMCPEnv({ options, body });++ if (isStdioOptions(result)) {+ expect(result.env?.PORT).toBe('8080');+ }+ });+ });});diff --git a/packages/api/src/utils/env.ts b/packages/api/src/utils/env.tsindex 86e60cfce9..3a22d897e6 100644--- a/packages/api/src/utils/env.ts+++ b/packages/api/src/utils/env.ts@@ -78,7 +78,8 @@ function processUserPlaceholders(value: string, user?: IUser): string {for (const field of ALLOWED_USER_FIELDS) {const placeholder = `{{LIBRECHAT_USER_${field.toUpperCase()}}}`;- if (!value.includes(placeholder)) {++ if (typeof value !== 'string' || !value.includes(placeholder)) {continue;}@@ -111,6 +112,11 @@ function processUserPlaceholders(value: string, user?: IUser): string {* @returns The processed string with placeholders replaced*/function processBodyPlaceholders(value: string, body: RequestBody): string {+ // Type guard: ensure value is a string+ if (typeof value !== 'string') {+ return value;+ }+for (const field of ALLOWED_BODY_FIELDS) {const placeholder = `{{LIBRECHAT_BODY_${field.toUpperCase()}}}`;if (!value.includes(placeholder)) {@@ -144,6 +150,11 @@ function processSingleValue({user?: IUser;body?: RequestBody;}): string {+ // Type guard: ensure we're working with a string+ if (typeof originalValue !== 'string') {+ return String(originalValue);+ }+let value = originalValue;if (customUserVars) {@@ -243,6 +254,74 @@ export function processMCPEnv(params: {return newObj;}+/**+ * Recursively processes a value, replacing placeholders in strings while preserving structure+ * @param value - The value to process (can be string, number, boolean, array, object, etc.)+ * @param options - Processing options+ * @returns The processed value with the same structure+ */+function processValue(+ value: unknown,+ options: {+ customUserVars?: Record<string, string>;+ user?: IUser;+ body?: RequestBody;+ },+): unknown {+ if (typeof value === 'string') {+ return processSingleValue({+ originalValue: value,+ customUserVars: options.customUserVars,+ user: options.user,+ body: options.body,+ });+ }++ if (Array.isArray(value)) {+ return value.map((item) => processValue(item, options));+ }++ if (value !== null && typeof value === 'object') {+ const processed: Record<string, unknown> = {};+ for (const [key, val] of Object.entries(value)) {+ processed[key] = processValue(val, options);+ }+ return processed;+ }++ return value;+}++/**+ * Recursively resolves placeholders in a nested object structure while preserving types.+ * Only processes string values - leaves numbers, booleans, arrays, and nested objects intact.+ *+ * @param options - Configuration object+ * @param options.obj - The object to process+ * @param options.user - Optional user object for replacing user field placeholders+ * @param options.body - Optional request body object for replacing body field placeholders+ * @param options.customUserVars - Optional custom user variables to replace placeholders+ * @returns The processed object with placeholders replaced in string values+ */+export function resolveNestedObject<T = unknown>(options?: {+ obj: T | undefined;+ user?: Partial<IUser> | { id: string };+ body?: RequestBody;+ customUserVars?: Record<string, string>;+}): T {+ const { obj, user, body, customUserVars } = options ?? {};++ if (!obj) {+ return obj as T;+ }++ return processValue(obj, {+ customUserVars,+ user: user as IUser,+ body,+ }) as T;+}+/*** Resolves header values by replacing user placeholders, body variables, custom variables, and environment variables.*diff --git a/packages/api/src/utils/oidc.ts b/packages/api/src/utils/oidc.tsindex 9c0ac478fd..b8d4fdac42 100644--- a/packages/api/src/utils/oidc.ts+++ b/packages/api/src/utils/oidc.ts@@ -77,10 +77,6 @@ export function extractOpenIDTokenInfo(user: IUser | null | undefined): OpenIDTotokenInfo.accessToken = tokens.access_token;tokenInfo.idToken = tokens.id_token;tokenInfo.expiresAt = tokens.expires_at;- } else {- logger.warn(- '[extractOpenIDTokenInfo] No federatedTokens or openidTokens found in user object',- );}tokenInfo.userId = user.openidId || user.id;