librechat-data-provider 0.7.4 → 0.7.7

package/specs/azure.spec.ts

@@ -94,8 +94,8 @@ describe('validateAzureGroups', () => {
     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(modelGroup?.group).toBe('japan-east');
+    expect(groupMap[modelGroup?.group ?? '']).toBeDefined();
     expect(modelNames).toContain('gpt-5-turbo');
     const { azureOptions } = mapModelToAzureConfig({
       modelName: 'gpt-5-turbo',
@@ -323,6 +323,7 @@ describe('validateAzureGroups for Serverless Configurations', () => {
 
     expect(azureOptions).toEqual({
       azureOpenAIApiKey: 'def456',
+      azureOpenAIApiVersion: '',
     });
     expect(baseURL).toEqual('https://new-serverless.example.com/v1/completions');
     expect(serverless).toBe(true);
@@ -381,10 +382,10 @@ describe('validateAzureGroups with modelGroupMap and groupMap', () => {
     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(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();
+    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,
@@ -765,6 +766,7 @@ describe('validateAzureGroups with modelGroupMap and groupMap', () => {
     );
     expect(azureOptions7).toEqual({
       azureOpenAIApiKey: 'mistral-key',
+      azureOpenAIApiVersion: '',
     });
 
     const {
@@ -782,6 +784,7 @@ describe('validateAzureGroups with modelGroupMap and groupMap', () => {
     );
     expect(azureOptions8).toEqual({
       azureOpenAIApiKey: 'llama-key',
+      azureOpenAIApiVersion: '',
     });
   });
 });

package/specs/filetypes.spec.ts

@@ -14,13 +14,7 @@ import {
 } from '../src/file-config';
 
 describe('MIME Type Regex Patterns', () => {
-  const unsupportedMimeTypes = [
-    'text/x-unknown',
-    'application/unknown',
-    'image/bmp',
-    'image/svg',
-    'audio/mp3',
-  ];
+  const unsupportedMimeTypes = ['text/x-unknown', 'application/unknown', 'image/bmp', 'audio/mp3'];
 
   // Testing general supported MIME types
   fullMimeTypesList.forEach((mimeType) => {

package/specs/mcp.spec.ts

@@ -0,0 +1,52 @@
+import { StdioOptionsSchema } from '../src/mcp';
+
+describe('Environment Variable Extraction (MCP)', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = {
+      ...originalEnv,
+      TEST_API_KEY: 'test-api-key-value',
+      ANOTHER_SECRET: 'another-secret-value',
+    };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('StdioOptionsSchema', () => {
+    it('should transform environment variables in the env field', () => {
+      const options = {
+        command: 'node',
+        args: ['server.js'],
+        env: {
+          API_KEY: '${TEST_API_KEY}',
+          ANOTHER_KEY: '${ANOTHER_SECRET}',
+          PLAIN_VALUE: 'plain-value',
+          NON_EXISTENT: '${NON_EXISTENT_VAR}',
+        },
+      };
+
+      const result = StdioOptionsSchema.parse(options);
+
+      expect(result.env).toEqual({
+        API_KEY: 'test-api-key-value',
+        ANOTHER_KEY: 'another-secret-value',
+        PLAIN_VALUE: 'plain-value',
+        NON_EXISTENT: '${NON_EXISTENT_VAR}',
+      });
+    });
+
+    it('should handle undefined env field', () => {
+      const options = {
+        command: 'node',
+        args: ['server.js'],
+      };
+
+      const result = StdioOptionsSchema.parse(options);
+
+      expect(result.env).toBeUndefined();
+    });
+  });
+});

package/specs/openapiSpecs.ts

@@ -348,3 +348,130 @@ components:
         message:
           type: string
           description: Confirmation of successful save or error message.`;
+
+export const swapidev = `
+openapi: 3.0.3
+info:
+  title: Star Wars API
+  description: This is a simple API that provides information about the Star Wars universe.
+  version: 1.0.0
+servers:
+  - url: https://swapi.dev
+
+paths:
+  /api/people:
+    get:
+      summary: List all people
+      operationId: getPeople
+      tags:
+        - People
+      responses:
+        '200':
+          description: A list of people
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  count:
+                    type: integer
+                    example: 82
+                  next:
+                    type: string
+                    nullable: true
+                    example: https://swapi.dev/api/people/?page=2
+                  previous:
+                    type: string
+                    nullable: true
+                    example: null
+                  results:
+                    type: array
+                    items:
+                      $ref: '#/components/schemas/Person'
+
+  /api/people/{id}:
+    get:
+      summary: Get a person by ID
+      operationId: getPersonById
+      tags:
+        - People
+      parameters:
+        - name: id
+          in: path
+          required: true
+          description: The ID of the person to retrieve
+          schema:
+            type: string
+      responses:
+        '200':
+          description: A single person
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Person'
+        '404':
+          description: Person not found
+
+components:
+  schemas:
+    Person:
+      type: object
+      properties:
+        name:
+          type: string
+          example: Luke Skywalker
+        height:
+          type: string
+          example: "172"
+        mass:
+          type: string
+          example: "77"
+        hair_color:
+          type: string
+          example: blond
+        skin_color:
+          type: string
+          example: fair
+        eye_color:
+          type: string
+          example: blue
+        birth_year:
+          type: string
+          example: "19BBY"
+        gender:
+          type: string
+          example: male
+        homeworld:
+          type: string
+          example: https://swapi.dev/api/planets/1/
+        films:
+          type: array
+          items:
+            type: string
+            example: https://swapi.dev/api/films/1/
+        species:
+          type: array
+          items:
+            type: string
+            example: https://swapi.dev/api/species/1/
+        vehicles:
+          type: array
+          items:
+            type: string
+            example: https://swapi.dev/api/vehicles/14/
+        starships:
+          type: array
+          items:
+            type: string
+            example: https://swapi.dev/api/starships/12/
+        created:
+          type: string
+          format: date-time
+          example: 2014-12-09T13:50:51.644000Z
+        edited:
+          type: string
+          format: date-time
+          example: 2014-12-20T21:17:56.891000Z
+        url:
+          type: string
+          example: https://swapi.dev/api/people/1/`;

package/specs/utils.spec.ts

@@ -0,0 +1,129 @@
+import { extractEnvVariable } from '../src/utils';
+
+describe('Environment Variable Extraction', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = {
+      ...originalEnv,
+      TEST_API_KEY: 'test-api-key-value',
+      ANOTHER_SECRET: 'another-secret-value',
+    };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('extractEnvVariable (original tests)', () => {
+    test('should return the value of the environment variable', () => {
+      process.env.TEST_VAR = 'test_value';
+      expect(extractEnvVariable('${TEST_VAR}')).toBe('test_value');
+    });
+
+    test('should return the original string if the envrionment variable is not defined correctly', () => {
+      process.env.TEST_VAR = 'test_value';
+      expect(extractEnvVariable('${ TEST_VAR }')).toBe('${ TEST_VAR }');
+    });
+
+    test('should return the original string if environment variable is not set', () => {
+      expect(extractEnvVariable('${NON_EXISTENT_VAR}')).toBe('${NON_EXISTENT_VAR}');
+    });
+
+    test('should return the original string if it does not contain an environment variable', () => {
+      expect(extractEnvVariable('some_string')).toBe('some_string');
+    });
+
+    test('should handle empty strings', () => {
+      expect(extractEnvVariable('')).toBe('');
+    });
+
+    test('should handle strings without variable format', () => {
+      expect(extractEnvVariable('no_var_here')).toBe('no_var_here');
+    });
+
+    /** No longer the expected behavior; keeping for reference */
+    test.skip('should not process multiple variable formats', () => {
+      process.env.FIRST_VAR = 'first';
+      process.env.SECOND_VAR = 'second';
+      expect(extractEnvVariable('${FIRST_VAR} and ${SECOND_VAR}')).toBe(
+        '${FIRST_VAR} and ${SECOND_VAR}',
+      );
+    });
+  });
+
+  describe('extractEnvVariable function', () => {
+    it('should extract environment variables from exact matches', () => {
+      expect(extractEnvVariable('${TEST_API_KEY}')).toBe('test-api-key-value');
+      expect(extractEnvVariable('${ANOTHER_SECRET}')).toBe('another-secret-value');
+    });
+
+    it('should extract environment variables from strings with prefixes', () => {
+      expect(extractEnvVariable('prefix-${TEST_API_KEY}')).toBe('prefix-test-api-key-value');
+    });
+
+    it('should extract environment variables from strings with suffixes', () => {
+      expect(extractEnvVariable('${TEST_API_KEY}-suffix')).toBe('test-api-key-value-suffix');
+    });
+
+    it('should extract environment variables from strings with both prefixes and suffixes', () => {
+      expect(extractEnvVariable('prefix-${TEST_API_KEY}-suffix')).toBe(
+        'prefix-test-api-key-value-suffix',
+      );
+    });
+
+    it('should not match invalid patterns', () => {
+      expect(extractEnvVariable('$TEST_API_KEY')).toBe('$TEST_API_KEY');
+      expect(extractEnvVariable('{TEST_API_KEY}')).toBe('{TEST_API_KEY}');
+      expect(extractEnvVariable('TEST_API_KEY')).toBe('TEST_API_KEY');
+    });
+  });
+
+  describe('extractEnvVariable', () => {
+    it('should extract environment variable values', () => {
+      expect(extractEnvVariable('${TEST_API_KEY}')).toBe('test-api-key-value');
+      expect(extractEnvVariable('${ANOTHER_SECRET}')).toBe('another-secret-value');
+    });
+
+    it('should return the original string if environment variable is not found', () => {
+      expect(extractEnvVariable('${NON_EXISTENT_VAR}')).toBe('${NON_EXISTENT_VAR}');
+    });
+
+    it('should return the original string if no environment variable pattern is found', () => {
+      expect(extractEnvVariable('plain-string')).toBe('plain-string');
+    });
+  });
+
+  describe('extractEnvVariable space trimming', () => {
+    beforeEach(() => {
+      process.env.HELLO = 'world';
+      process.env.USER = 'testuser';
+    });
+
+    it('should extract the value when string contains only an environment variable with surrounding whitespace', () => {
+      expect(extractEnvVariable('        ${HELLO}        ')).toBe('world');
+      expect(extractEnvVariable('  ${HELLO}  ')).toBe('world');
+      expect(extractEnvVariable('\t${HELLO}\n')).toBe('world');
+    });
+
+    it('should preserve content when variable is part of a larger string', () => {
+      expect(extractEnvVariable('Hello ${USER}!')).toBe('Hello testuser!');
+      expect(extractEnvVariable('  Hello ${USER}!  ')).toBe('Hello testuser!');
+    });
+
+    it('should not handle multiple variables', () => {
+      expect(extractEnvVariable('${HELLO} ${USER}')).toBe('${HELLO} ${USER}');
+      expect(extractEnvVariable('  ${HELLO}   ${USER}  ')).toBe('${HELLO}   ${USER}');
+    });
+
+    it('should handle undefined variables', () => {
+      expect(extractEnvVariable('        ${UNDEFINED_VAR}        ')).toBe('${UNDEFINED_VAR}');
+    });
+
+    it('should handle mixed content correctly', () => {
+      expect(extractEnvVariable('Welcome, ${USER}!\nYour message: ${HELLO}')).toBe(
+        'Welcome, testuser!\nYour message: world',
+      );
+    });
+  });
+});