librechat-data-provider 0.8.402 → 0.8.404

package/specs/azure.spec.ts

@@ -1,844 +0,0 @@
-import type { TAzureGroups } from '../src/config';
-import { validateAzureGroups, mapModelToAzureConfig, mapGroupToAzureConfig } from '../src/azure';
-
-describe('validateAzureGroups', () => {
-  it('should validate a correct configuration', () => {
-    const configs = [
-      {
-        group: 'us-east',
-        apiKey: 'prod-1234',
-        instanceName: 'prod-instance',
-        deploymentName: 'v1-deployment',
-        version: '2023-12-31',
-        baseURL: 'https://prod.example.com',
-        additionalHeaders: {
-          'X-Custom-Header': 'value',
-        },
-        models: {
-          'gpt-4-turbo': {
-            deploymentName: 'gpt-4-turbo-deployment',
-            version: '2023-11-06',
-          },
-        },
-      },
-    ];
-    const { isValid, modelNames, modelGroupMap, groupMap } = validateAzureGroups(configs);
-    expect(isValid).toBe(true);
-    expect(modelNames).toEqual(['gpt-4-turbo']);
-
-    const { azureOptions, baseURL, headers } = mapModelToAzureConfig({
-      modelName: 'gpt-4-turbo',
-      modelGroupMap,
-      groupMap,
-    });
-    expect(azureOptions).toEqual({
-      azureOpenAIApiKey: 'prod-1234',
-      azureOpenAIApiInstanceName: 'prod-instance',
-      azureOpenAIApiDeploymentName: 'gpt-4-turbo-deployment',
-      azureOpenAIApiVersion: '2023-11-06',
-    });
-    expect(baseURL).toBe('https://prod.example.com');
-    expect(headers).toEqual({
-      'X-Custom-Header': 'value',
-    });
-  });
-
-  it('should return invalid for a configuration missing deploymentName at the model level where required', () => {
-    const configs = [
-      {
-        group: 'us-west',
-        apiKey: 'us-west-key-5678',
-        instanceName: 'us-west-instance',
-        models: {
-          'gpt-5': {
-            version: '2023-12-01', // Missing deploymentName
-          },
-        },
-      },
-    ];
-    const { isValid, errors } = validateAzureGroups(configs);
-    expect(isValid).toBe(false);
-    expect(errors.length).toBe(1);
-  });
-
-  it('should return invalid for a configuration with a boolean model where group lacks deploymentName and version', () => {
-    const configs = [
-      {
-        group: 'sweden-central',
-        apiKey: 'sweden-central-9012',
-        instanceName: 'sweden-central-instance',
-        models: {
-          'gpt-35-turbo': true, // The group lacks deploymentName and version
-        },
-      },
-    ];
-    const { isValid, errors } = validateAzureGroups(configs);
-    expect(isValid).toBe(false);
-    expect(errors.length).toBe(1);
-  });
-
-  it('should allow a boolean model when group has both deploymentName and version', () => {
-    const configs = [
-      {
-        group: 'japan-east',
-        apiKey: 'japan-east-3456',
-        instanceName: 'japan-east-instance',
-        deploymentName: 'default-deployment',
-        version: '2023-04-01',
-        models: {
-          'gpt-5-turbo': true,
-        },
-      },
-    ];
-    const { isValid, modelNames, modelGroupMap, groupMap } = validateAzureGroups(configs);
-    expect(isValid).toBe(true);
-    const modelGroup = modelGroupMap['gpt-5-turbo'];
-    expect(modelGroup).toBeDefined();
-    expect(modelGroup?.group).toBe('japan-east');
-    expect(groupMap[modelGroup?.group ?? '']).toBeDefined();
-    expect(modelNames).toContain('gpt-5-turbo');
-    const { azureOptions } = mapModelToAzureConfig({
-      modelName: 'gpt-5-turbo',
-      modelGroupMap,
-      groupMap,
-    });
-    expect(azureOptions).toEqual({
-      azureOpenAIApiKey: 'japan-east-3456',
-      azureOpenAIApiInstanceName: 'japan-east-instance',
-      azureOpenAIApiDeploymentName: 'default-deployment',
-      azureOpenAIApiVersion: '2023-04-01',
-    });
-  });
-
-  it('should validate correctly when optional fields are missing', () => {
-    const configs = [
-      {
-        group: 'canada-central',
-        apiKey: 'canada-key',
-        instanceName: 'canada-instance',
-        models: {
-          'gpt-6': {
-            deploymentName: 'gpt-6-deployment',
-            version: '2023-01-01',
-          },
-        },
-      },
-    ];
-    const { isValid, modelNames, modelGroupMap, groupMap } = validateAzureGroups(configs);
-    expect(isValid).toBe(true);
-    expect(modelNames).toEqual(['gpt-6']);
-    const { azureOptions } = mapModelToAzureConfig({ modelName: 'gpt-6', modelGroupMap, groupMap });
-    expect(azureOptions).toEqual({
-      azureOpenAIApiKey: 'canada-key',
-      azureOpenAIApiInstanceName: 'canada-instance',
-      azureOpenAIApiDeploymentName: 'gpt-6-deployment',
-      azureOpenAIApiVersion: '2023-01-01',
-    });
-  });
-
-  it('should return invalid for configurations with incorrect types', () => {
-    const configs = [
-      {
-        group: 123, // incorrect type
-        apiKey: 'key123',
-        instanceName: 'instance123',
-        models: {
-          'gpt-7': true,
-        },
-      },
-    ];
-    // @ts-expect-error This error is expected because the 'group' property should be a string.
-    const { isValid, errors } = validateAzureGroups(configs);
-    expect(isValid).toBe(false);
-    expect(errors.length).toBe(1);
-  });
-
-  it('should correctly handle a mix of valid and invalid model configurations', () => {
-    const configs = [
-      {
-        group: 'australia-southeast',
-        apiKey: 'australia-key',
-        instanceName: 'australia-instance',
-        models: {
-          'valid-model': {
-            deploymentName: 'valid-deployment',
-            version: '2023-02-02',
-          },
-          'invalid-model': true, // Invalid because the group lacks deploymentName and version
-        },
-      },
-    ];
-    const { isValid, modelNames, errors } = validateAzureGroups(configs);
-    expect(isValid).toBe(false);
-    expect(modelNames).toEqual(expect.arrayContaining(['valid-model', 'invalid-model']));
-    expect(errors.length).toBe(1);
-  });
-
-  it('should return invalid for configuration missing required fields at the group level', () => {
-    const configs = [
-      {
-        group: 'brazil-south',
-        apiKey: 'brazil-key',
-        // Missing instanceName
-        models: {
-          'gpt-8': {
-            deploymentName: 'gpt-8-deployment',
-            version: '2023-03-03',
-          },
-        },
-      },
-    ];
-    const { isValid, errors } = validateAzureGroups(configs);
-    expect(isValid).toBe(false);
-    expect(errors.length).toBe(1);
-  });
-});
-
-describe('validateAzureGroups for Serverless Configurations', () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    jest.resetModules();
-    process.env = { ...originalEnv };
-  });
-
-  afterAll(() => {
-    process.env = originalEnv;
-  });
-
-  it('should validate a correct serverless configuration', () => {
-    const configs = [
-      {
-        group: 'serverless-group',
-        apiKey: '${SERVERLESS_API_KEY}',
-        baseURL: 'https://serverless.example.com/v1/completions',
-        serverless: true,
-        models: {
-          'model-serverless': true,
-        },
-      },
-    ];
-
-    const { isValid, errors } = validateAzureGroups(configs);
-
-    expect(isValid).toBe(true);
-    expect(errors.length).toBe(0);
-  });
-
-  it('should return invalid for a serverless configuration missing baseURL', () => {
-    const configs = [
-      {
-        group: 'serverless-group',
-        apiKey: '${SERVERLESS_API_KEY}',
-        serverless: true,
-        models: {
-          'model-serverless': true,
-        },
-      },
-    ];
-
-    const { isValid, errors } = validateAzureGroups(configs);
-    expect(isValid).toBe(false);
-    expect(errors).toEqual(
-      expect.arrayContaining([
-        expect.stringContaining(
-          'Group "serverless-group" is serverless but missing mandatory "baseURL."',
-        ),
-      ]),
-    );
-  });
-
-  it('should throw an error when environment variable for apiKey is not set', () => {
-    process.env.SERVERLESS_API_KEY = '';
-
-    expect(() => {
-      mapModelToAzureConfig({
-        modelName: 'model-serverless',
-        modelGroupMap: {
-          'model-serverless': {
-            group: 'serverless-group',
-          },
-        },
-        groupMap: {
-          'serverless-group': {
-            apiKey: '${SERVERLESS_API_KEY}',
-            baseURL: 'https://serverless.example.com/v1/completions',
-            serverless: true,
-            models: { 'model-serverless': true },
-          },
-        },
-      });
-    }).toThrow('Azure configuration environment variable "${SERVERLESS_API_KEY}" was not found.');
-  });
-
-  it('should correctly extract environment variables and prepare serverless config', () => {
-    process.env.SERVERLESS_API_KEY = 'abc123';
-
-    const { azureOptions, baseURL, serverless } = mapModelToAzureConfig({
-      modelName: 'model-serverless',
-      modelGroupMap: {
-        'model-serverless': {
-          group: 'serverless-group',
-        },
-      },
-      groupMap: {
-        'serverless-group': {
-          apiKey: '${SERVERLESS_API_KEY}',
-          baseURL: 'https://serverless.example.com/v1/completions',
-          serverless: true,
-          models: { 'model-serverless': true },
-        },
-      },
-    });
-
-    expect(azureOptions.azureOpenAIApiKey).toEqual('abc123');
-    expect(baseURL).toEqual('https://serverless.example.com/v1/completions');
-    expect(serverless).toBe(true);
-  });
-
-  it('should ensure serverless flag triggers appropriate validations and mappings', () => {
-    const configs = [
-      {
-        group: 'serverless-group-2',
-        apiKey: '${NEW_SERVERLESS_API_KEY}',
-        baseURL: 'https://new-serverless.example.com/v1/completions',
-        serverless: true,
-        models: {
-          'new-model-serverless': true,
-        },
-      },
-    ];
-
-    process.env.NEW_SERVERLESS_API_KEY = 'def456';
-
-    const { isValid, errors, modelGroupMap, groupMap } = validateAzureGroups(configs);
-    expect(isValid).toBe(true);
-    expect(errors.length).toBe(0);
-
-    const { azureOptions, baseURL, serverless } = mapModelToAzureConfig({
-      modelName: 'new-model-serverless',
-      modelGroupMap,
-      groupMap,
-    });
-
-    expect(azureOptions).toEqual({
-      azureOpenAIApiKey: 'def456',
-      azureOpenAIApiVersion: '',
-    });
-    expect(baseURL).toEqual('https://new-serverless.example.com/v1/completions');
-    expect(serverless).toBe(true);
-  });
-});
-
-describe('validateAzureGroups with modelGroupMap and groupMap', () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    jest.resetModules();
-    process.env = { ...originalEnv };
-  });
-
-  afterAll(() => {
-    process.env = originalEnv;
-  });
-
-  it('should provide a valid modelGroupMap and groupMap for a correct configuration', () => {
-    const validConfigs: TAzureGroups = [
-      {
-        group: 'us-east',
-        apiKey: 'prod-1234',
-        instanceName: 'prod-instance',
-        deploymentName: 'v1-deployment',
-        version: '2023-12-31',
-        baseURL: 'https://prod.example.com',
-        additionalHeaders: {
-          'X-Custom-Header': 'value',
-        },
-        models: {
-          'gpt-4-turbo': {
-            deploymentName: 'gpt-4-turbo-deployment',
-            version: '2023-11-06',
-          },
-        },
-      },
-      {
-        group: 'us-west',
-        apiKey: 'prod-12345',
-        instanceName: 'prod-instance',
-        deploymentName: 'v1-deployment',
-        version: '2023-12-31',
-        baseURL: 'https://prod.example.com',
-        additionalHeaders: {
-          'X-Custom-Header': 'value',
-        },
-        models: {
-          'gpt-5-turbo': {
-            deploymentName: 'gpt-5-turbo-deployment',
-            version: '2023-11-06',
-          },
-        },
-      },
-    ];
-    const { isValid, modelGroupMap, groupMap } = validateAzureGroups(validConfigs);
-    expect(isValid).toBe(true);
-    expect(modelGroupMap['gpt-4-turbo']).toBeDefined();
-    expect(modelGroupMap['gpt-4-turbo']?.group).toBe('us-east');
-    expect(groupMap['us-east']).toBeDefined();
-    expect(groupMap['us-east']?.apiKey).toBe('prod-1234');
-    expect(groupMap['us-east']?.models['gpt-4-turbo']).toBeDefined();
-    const { azureOptions, baseURL, headers } = mapModelToAzureConfig({
-      modelName: 'gpt-4-turbo',
-      modelGroupMap,
-      groupMap,
-    });
-    expect(azureOptions).toEqual({
-      azureOpenAIApiKey: 'prod-1234',
-      azureOpenAIApiInstanceName: 'prod-instance',
-      azureOpenAIApiDeploymentName: 'gpt-4-turbo-deployment',
-      azureOpenAIApiVersion: '2023-11-06',
-    });
-    expect(baseURL).toBe('https://prod.example.com');
-    expect(headers).toEqual({
-      'X-Custom-Header': 'value',
-    });
-  });
-
-  it('should not allow duplicate group names', () => {
-    const duplicateGroups: TAzureGroups = [
-      {
-        group: 'us-east',
-        apiKey: 'prod-1234',
-        instanceName: 'prod-instance',
-        deploymentName: 'v1-deployment',
-        version: '2023-12-31',
-        baseURL: 'https://prod.example.com',
-        additionalHeaders: {
-          'X-Custom-Header': 'value',
-        },
-        models: {
-          'gpt-4-turbo': {
-            deploymentName: 'gpt-4-turbo-deployment',
-            version: '2023-11-06',
-          },
-        },
-      },
-      {
-        group: 'us-east',
-        apiKey: 'prod-1234',
-        instanceName: 'prod-instance',
-        deploymentName: 'v1-deployment',
-        version: '2023-12-31',
-        baseURL: 'https://prod.example.com',
-        additionalHeaders: {
-          'X-Custom-Header': 'value',
-        },
-        models: {
-          'gpt-5-turbo': {
-            deploymentName: 'gpt-4-turbo-deployment',
-            version: '2023-11-06',
-          },
-        },
-      },
-    ];
-    const { isValid } = validateAzureGroups(duplicateGroups);
-    expect(isValid).toBe(false);
-  });
-  it('should not allow duplicate models across groups', () => {
-    const duplicateGroups: TAzureGroups = [
-      {
-        group: 'us-east',
-        apiKey: 'prod-1234',
-        instanceName: 'prod-instance',
-        deploymentName: 'v1-deployment',
-        version: '2023-12-31',
-        baseURL: 'https://prod.example.com',
-        additionalHeaders: {
-          'X-Custom-Header': 'value',
-        },
-        models: {
-          'gpt-4-turbo': {
-            deploymentName: 'gpt-4-turbo-deployment',
-            version: '2023-11-06',
-          },
-        },
-      },
-      {
-        group: 'us-west',
-        apiKey: 'prod-1234',
-        instanceName: 'prod-instance',
-        deploymentName: 'v1-deployment',
-        version: '2023-12-31',
-        baseURL: 'https://prod.example.com',
-        additionalHeaders: {
-          'X-Custom-Header': 'value',
-        },
-        models: {
-          'gpt-4-turbo': {
-            deploymentName: 'gpt-4-turbo-deployment',
-            version: '2023-11-06',
-          },
-        },
-      },
-    ];
-    const { isValid } = validateAzureGroups(duplicateGroups);
-    expect(isValid).toBe(false);
-  });
-
-  it('should throw an error if environment variables are set but not configured', () => {
-    const validConfigs: TAzureGroups = [
-      {
-        group: 'librechat-westus',
-        apiKey: '${WESTUS_API_KEY}',
-        instanceName: 'librechat-westus',
-        version: '2023-12-01-preview',
-        models: {
-          'gpt-4-vision-preview': {
-            deploymentName: 'gpt-4-vision-preview',
-            version: '2024-02-15-preview',
-          },
-          'gpt-3.5-turbo': {
-            deploymentName: 'gpt-35-turbo',
-          },
-          'gpt-3.5-turbo-1106': {
-            deploymentName: 'gpt-35-turbo-1106',
-          },
-          'gpt-4': {
-            deploymentName: 'gpt-4',
-          },
-          'gpt-4-1106-preview': {
-            deploymentName: 'gpt-4-1106-preview',
-          },
-        },
-      },
-      {
-        group: 'librechat-eastus',
-        apiKey: '${EASTUS_API_KEY}',
-        instanceName: 'librechat-eastus',
-        deploymentName: 'gpt-4-turbo',
-        version: '2024-02-15-preview',
-        models: {
-          'gpt-4-turbo': true,
-        },
-      },
-    ];
-    const { isValid, modelGroupMap, groupMap } = validateAzureGroups(validConfigs);
-    expect(isValid).toBe(true);
-    expect(() =>
-      mapModelToAzureConfig({ modelName: 'gpt-4-turbo', modelGroupMap, groupMap }),
-    ).toThrow();
-  });
-
-  it('should list all expected models in both modelGroupMap and groupMap', () => {
-    process.env.WESTUS_API_KEY = 'westus-key';
-    process.env.EASTUS_API_KEY = 'eastus-key';
-    process.env.AZURE_MISTRAL_API_KEY = 'mistral-key';
-    process.env.AZURE_LLAMA2_70B_API_KEY = 'llama-key';
-
-    const validConfigs: TAzureGroups = [
-      {
-        group: 'librechat-westus',
-        apiKey: '${WESTUS_API_KEY}',
-        instanceName: 'librechat-westus',
-        version: '2023-12-01-preview',
-        models: {
-          'gpt-4-vision-preview': {
-            deploymentName: 'gpt-4-vision-preview',
-            version: '2024-02-15-preview',
-          },
-          'gpt-3.5-turbo': {
-            deploymentName: 'gpt-35-turbo',
-          },
-          'gpt-3.5-turbo-1106': {
-            deploymentName: 'gpt-35-turbo-1106',
-          },
-          'gpt-4': {
-            deploymentName: 'gpt-4',
-          },
-          'gpt-4-1106-preview': {
-            deploymentName: 'gpt-4-1106-preview',
-          },
-        },
-      },
-      {
-        group: 'librechat-eastus',
-        apiKey: '${EASTUS_API_KEY}',
-        instanceName: 'librechat-eastus',
-        deploymentName: 'gpt-4-turbo',
-        version: '2024-02-15-preview',
-        models: {
-          'gpt-4-turbo': true,
-        },
-        baseURL: 'https://eastus.example.com',
-        additionalHeaders: {
-          'x-api-key': 'x-api-key-value',
-        },
-      },
-      {
-        group: 'mistral-inference',
-        apiKey: '${AZURE_MISTRAL_API_KEY}',
-        baseURL:
-          'https://Mistral-large-vnpet-serverless.region.inference.ai.azure.com/v1/chat/completions',
-        serverless: true,
-        models: {
-          'mistral-large': true,
-        },
-      },
-      {
-        group: 'llama-70b-chat',
-        apiKey: '${AZURE_LLAMA2_70B_API_KEY}',
-        baseURL:
-          'https://Llama-2-70b-chat-qmvyb-serverless.region.inference.ai.azure.com/v1/chat/completions',
-        serverless: true,
-        models: {
-          'llama-70b-chat': true,
-        },
-      },
-    ];
-    const { isValid, modelGroupMap, groupMap, modelNames } = validateAzureGroups(validConfigs);
-    expect(isValid).toBe(true);
-    expect(modelNames).toEqual([
-      'gpt-4-vision-preview',
-      'gpt-3.5-turbo',
-      'gpt-3.5-turbo-1106',
-      'gpt-4',
-      'gpt-4-1106-preview',
-      'gpt-4-turbo',
-      'mistral-large',
-      'llama-70b-chat',
-    ]);
-
-    // Check modelGroupMap
-    modelNames.forEach((modelName) => {
-      expect(modelGroupMap[modelName]).toBeDefined();
-    });
-
-    // Check groupMap for 'librechat-westus'
-    expect(groupMap).toHaveProperty('librechat-westus');
-    expect(groupMap['librechat-westus']).toEqual(
-      expect.objectContaining({
-        apiKey: '${WESTUS_API_KEY}',
-        instanceName: 'librechat-westus',
-        version: '2023-12-01-preview',
-        models: expect.objectContaining({
-          'gpt-4-vision-preview': expect.any(Object),
-          'gpt-3.5-turbo': expect.any(Object),
-          'gpt-3.5-turbo-1106': expect.any(Object),
-          'gpt-4': expect.any(Object),
-          'gpt-4-1106-preview': expect.any(Object),
-        }),
-      }),
-    );
-
-    // Check groupMap for 'librechat-eastus'
-    expect(groupMap).toHaveProperty('librechat-eastus');
-    expect(groupMap['librechat-eastus']).toEqual(
-      expect.objectContaining({
-        apiKey: '${EASTUS_API_KEY}',
-        instanceName: 'librechat-eastus',
-        deploymentName: 'gpt-4-turbo',
-        version: '2024-02-15-preview',
-        models: expect.objectContaining({
-          'gpt-4-turbo': true,
-        }),
-      }),
-    );
-
-    // Check groupMap for 'mistral-inference'
-    expect(groupMap).toHaveProperty('mistral-inference');
-    expect(groupMap['mistral-inference']).toEqual(
-      expect.objectContaining({
-        apiKey: '${AZURE_MISTRAL_API_KEY}',
-        baseURL:
-          'https://Mistral-large-vnpet-serverless.region.inference.ai.azure.com/v1/chat/completions',
-        serverless: true,
-        models: expect.objectContaining({
-          'mistral-large': true,
-        }),
-      }),
-    );
-
-    // Check groupMap for 'llama-70b-chat'
-    expect(groupMap).toHaveProperty('llama-70b-chat');
-    expect(groupMap['llama-70b-chat']).toEqual(
-      expect.objectContaining({
-        apiKey: '${AZURE_LLAMA2_70B_API_KEY}',
-        baseURL:
-          'https://Llama-2-70b-chat-qmvyb-serverless.region.inference.ai.azure.com/v1/chat/completions',
-        serverless: true,
-        models: expect.objectContaining({
-          'llama-70b-chat': true,
-        }),
-      }),
-    );
-
-    const { azureOptions: azureOptions1 } = mapModelToAzureConfig({
-      modelName: 'gpt-4-vision-preview',
-      modelGroupMap,
-      groupMap,
-    });
-    expect(azureOptions1).toEqual({
-      azureOpenAIApiKey: 'westus-key',
-      azureOpenAIApiInstanceName: 'librechat-westus',
-      azureOpenAIApiDeploymentName: 'gpt-4-vision-preview',
-      azureOpenAIApiVersion: '2024-02-15-preview',
-    });
-
-    const {
-      azureOptions: azureOptions2,
-      baseURL,
-      headers,
-    } = mapModelToAzureConfig({
-      modelName: 'gpt-4-turbo',
-      modelGroupMap,
-      groupMap,
-    });
-    expect(azureOptions2).toEqual({
-      azureOpenAIApiKey: 'eastus-key',
-      azureOpenAIApiInstanceName: 'librechat-eastus',
-      azureOpenAIApiDeploymentName: 'gpt-4-turbo',
-      azureOpenAIApiVersion: '2024-02-15-preview',
-    });
-    expect(baseURL).toBe('https://eastus.example.com');
-    expect(headers).toEqual({
-      'x-api-key': 'x-api-key-value',
-    });
-
-    const { azureOptions: azureOptions3 } = mapModelToAzureConfig({
-      modelName: 'gpt-4',
-      modelGroupMap,
-      groupMap,
-    });
-    expect(azureOptions3).toEqual({
-      azureOpenAIApiKey: 'westus-key',
-      azureOpenAIApiInstanceName: 'librechat-westus',
-      azureOpenAIApiDeploymentName: 'gpt-4',
-      azureOpenAIApiVersion: '2023-12-01-preview',
-    });
-
-    const { azureOptions: azureOptions4 } = mapModelToAzureConfig({
-      modelName: 'gpt-3.5-turbo',
-      modelGroupMap,
-      groupMap,
-    });
-    expect(azureOptions4).toEqual({
-      azureOpenAIApiKey: 'westus-key',
-      azureOpenAIApiInstanceName: 'librechat-westus',
-      azureOpenAIApiDeploymentName: 'gpt-35-turbo',
-      azureOpenAIApiVersion: '2023-12-01-preview',
-    });
-
-    const { azureOptions: azureOptions5 } = mapModelToAzureConfig({
-      modelName: 'gpt-3.5-turbo-1106',
-      modelGroupMap,
-      groupMap,
-    });
-    expect(azureOptions5).toEqual({
-      azureOpenAIApiKey: 'westus-key',
-      azureOpenAIApiInstanceName: 'librechat-westus',
-      azureOpenAIApiDeploymentName: 'gpt-35-turbo-1106',
-      azureOpenAIApiVersion: '2023-12-01-preview',
-    });
-
-    const { azureOptions: azureOptions6 } = mapModelToAzureConfig({
-      modelName: 'gpt-4-1106-preview',
-      modelGroupMap,
-      groupMap,
-    });
-    expect(azureOptions6).toEqual({
-      azureOpenAIApiKey: 'westus-key',
-      azureOpenAIApiInstanceName: 'librechat-westus',
-      azureOpenAIApiDeploymentName: 'gpt-4-1106-preview',
-      azureOpenAIApiVersion: '2023-12-01-preview',
-    });
-
-    const {
-      azureOptions: azureOptions7,
-      serverless: serverlessMistral,
-      baseURL: mistralEndpoint,
-    } = mapModelToAzureConfig({
-      modelName: 'mistral-large',
-      modelGroupMap,
-      groupMap,
-    });
-    expect(serverlessMistral).toBe(true);
-    expect(mistralEndpoint).toBe(
-      'https://Mistral-large-vnpet-serverless.region.inference.ai.azure.com/v1/chat/completions',
-    );
-    expect(azureOptions7).toEqual({
-      azureOpenAIApiKey: 'mistral-key',
-      azureOpenAIApiVersion: '',
-    });
-
-    const {
-      azureOptions: azureOptions8,
-      serverless: serverlessLlama,
-      baseURL: llamaEndpoint,
-    } = mapModelToAzureConfig({
-      modelName: 'llama-70b-chat',
-      modelGroupMap,
-      groupMap,
-    });
-    expect(serverlessLlama).toBe(true);
-    expect(llamaEndpoint).toBe(
-      'https://Llama-2-70b-chat-qmvyb-serverless.region.inference.ai.azure.com/v1/chat/completions',
-    );
-    expect(azureOptions8).toEqual({
-      azureOpenAIApiKey: 'llama-key',
-      azureOpenAIApiVersion: '',
-    });
-  });
-});
-
-describe('mapGroupToAzureConfig', () => {
-  // Test setup for a basic config with 2 groups
-  const groupMap = {
-    group1: {
-      apiKey: 'key-for-group1',
-      instanceName: 'instance-group1',
-      models: {
-        model1: { deploymentName: 'deployment1', version: '1.0' },
-      },
-    },
-    group2: {
-      apiKey: 'key-for-group2',
-      instanceName: 'instance-group2',
-      serverless: true,
-      baseURL: 'https://group2.example.com',
-      models: {
-        model2: true, // demonstrating a boolean style model configuration
-      },
-    },
-  };
-
-  it('should successfully map non-serverless group configuration', () => {
-    const groupName = 'group1';
-    const result = mapGroupToAzureConfig({ groupName, groupMap });
-    expect(result).toEqual({
-      azureOptions: expect.objectContaining({
-        azureOpenAIApiKey: 'key-for-group1',
-        azureOpenAIApiInstanceName: 'instance-group1',
-        azureOpenAIApiDeploymentName: expect.any(String),
-        azureOpenAIApiVersion: expect.any(String),
-      }),
-    });
-  });
-
-  it('should successfully map serverless group configuration', () => {
-    const groupName = 'group2';
-    const result = mapGroupToAzureConfig({ groupName, groupMap });
-    expect(result).toEqual({
-      azureOptions: expect.objectContaining({
-        azureOpenAIApiKey: 'key-for-group2',
-      }),
-      baseURL: 'https://group2.example.com',
-      serverless: true,
-    });
-  });
-
-  it('should throw error for nonexistent group name', () => {
-    const groupName = 'nonexistent-group';
-    expect(() => {
-      mapGroupToAzureConfig({ groupName, groupMap });
-    }).toThrow(`Group named "${groupName}" not found in configuration.`);
-  });
-});