librechat-data-provider 0.7.78 → 0.7.82

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librechat-data-provider",
-  "version": "0.7.78",
+  "version": "0.7.82",
   "description": "data services for librechat apps",
   "main": "dist/index.js",
   "module": "dist/index.es.js",
@@ -40,6 +40,7 @@
   "homepage": "https://librechat.ai",
   "dependencies": {
     "axios": "^1.8.2",
+    "dayjs": "^1.11.13",
     "js-yaml": "^4.1.0",
     "zod": "^3.22.4"
   },

package/specs/actions.spec.ts

@@ -206,6 +206,244 @@ describe('ActionRequest', () => {
         },
       });
     });
+
+    it('handles GET requests with header and query parameters', async () => {
+      mockedAxios.get.mockResolvedValue({ data: { success: true } });
+
+      const data: Record<string, unknown> = {
+        'api-version': '2025-01-01',
+        'some-header': 'header-var',
+      };
+
+      const loc: Record<string, 'query' | 'path' | 'header' | 'body'> = {
+        'api-version': 'query',
+        'some-header': 'header',
+      };
+
+      const actionRequest = new ActionRequest(
+        'https://example.com',
+        '/get',
+        'GET',
+        'testGET',
+        false,
+        '',
+        loc,
+      );
+      const executer = actionRequest.setParams(data);
+      const response = await executer.execute();
+      expect(mockedAxios.get).toHaveBeenCalled();
+
+      const [url, config] = mockedAxios.get.mock.calls[0];
+      expect(url).toBe('https://example.com/get');
+      expect(config?.headers).toEqual({
+        'some-header': 'header-var',
+      });
+      expect(config?.params).toEqual({
+        'api-version': '2025-01-01',
+      });
+      expect(response.data.success).toBe(true);
+    });
+
+    it('handles GET requests with header and path parameters', async () => {
+      mockedAxios.get.mockResolvedValue({ data: { success: true } });
+
+      const data: Record<string, unknown> = {
+        'user-id': '1',
+        'some-header': 'header-var',
+      };
+
+      const loc: Record<string, 'query' | 'path' | 'header' | 'body'> = {
+        'user-id': 'path',
+        'some-header': 'header',
+      };
+
+      const actionRequest = new ActionRequest(
+        'https://example.com',
+        '/getwithpath/{user-id}',
+        'GET',
+        'testGETwithpath',
+        false,
+        '',
+        loc,
+      );
+      const executer = actionRequest.setParams(data);
+      const response = await executer.execute();
+      expect(mockedAxios.get).toHaveBeenCalled();
+
+      const [url, config] = mockedAxios.get.mock.calls[0];
+      expect(url).toBe('https://example.com/getwithpath/1');
+      expect(config?.headers).toEqual({
+        'some-header': 'header-var',
+      });
+      expect(config?.params).toEqual({
+      });
+      expect(response.data.success).toBe(true);
+    });
+
+    it('handles POST requests with body, header and query parameters', async () => {
+      mockedAxios.post.mockResolvedValue({ data: { success: true } });
+
+      const data: Record<string, unknown> = {
+        'api-version': '2025-01-01',
+        'message': 'a body parameter',
+        'some-header': 'header-var',
+      };
+
+      const loc: Record<string, 'query' | 'path' | 'header' | 'body'> = {
+        'api-version': 'query',
+        'message': 'body',
+        'some-header': 'header',
+      };
+
+      const actionRequest = new ActionRequest(
+        'https://example.com',
+        '/post',
+        'POST',
+        'testPost',
+        false,
+        'application/json',
+        loc,
+      );
+      const executer = actionRequest.setParams(data);
+      const response = await executer.execute();
+      expect(mockedAxios.post).toHaveBeenCalled();
+
+      const [url, body, config] = mockedAxios.post.mock.calls[0];
+      expect(url).toBe('https://example.com/post');
+      expect(body).toEqual({ message: 'a body parameter' });
+      expect(config?.headers).toEqual({
+        'some-header': 'header-var',
+        'Content-Type': 'application/json',
+      });
+      expect(config?.params).toEqual({
+        'api-version': '2025-01-01',
+      });
+      expect(response.data.success).toBe(true);
+    });
+
+    it('handles PUT requests with body, header and query parameters', async () => {
+      mockedAxios.put.mockResolvedValue({ data: { success: true } });
+
+      const data: Record<string, unknown> = {
+        'api-version': '2025-01-01',
+        'message': 'a body parameter',
+        'some-header': 'header-var',
+      };
+
+      const loc: Record<string, 'query' | 'path' | 'header' | 'body'> = {
+        'api-version': 'query',
+        'message': 'body',
+        'some-header': 'header',
+      };
+
+      const actionRequest = new ActionRequest(
+        'https://example.com',
+        '/put',
+        'PUT',
+        'testPut',
+        false,
+        'application/json',
+        loc,
+      );
+      const executer = actionRequest.setParams(data);
+      const response = await executer.execute();
+      expect(mockedAxios.put).toHaveBeenCalled();
+
+      const [url, body, config] = mockedAxios.put.mock.calls[0];
+      expect(url).toBe('https://example.com/put');
+      expect(body).toEqual({ message: 'a body parameter' });
+      expect(config?.headers).toEqual({
+        'some-header': 'header-var',
+        'Content-Type': 'application/json',
+      });
+      expect(config?.params).toEqual({
+        'api-version': '2025-01-01',
+      });
+      expect(response.data.success).toBe(true);
+    });
+
+    it('handles PATCH requests with body, header and query parameters', async () => {
+      mockedAxios.patch.mockResolvedValue({ data: { success: true } });
+
+      const data: Record<string, unknown> = {
+        'api-version': '2025-01-01',
+        'message': 'a body parameter',
+        'some-header': 'header-var',
+      };
+
+      const loc: Record<string, 'query' | 'path' | 'header' | 'body'> = {
+        'api-version': 'query',
+        'message': 'body',
+        'some-header': 'header',
+      };
+
+      const actionRequest = new ActionRequest(
+        'https://example.com',
+        '/patch',
+        'PATCH',
+        'testPatch',
+        false,
+        'application/json',
+        loc,
+      );
+      const executer = actionRequest.setParams(data);
+      const response = await executer.execute();
+      expect(mockedAxios.patch).toHaveBeenCalled();
+
+      const [url, body, config] = mockedAxios.patch.mock.calls[0];
+      expect(url).toBe('https://example.com/patch');
+      expect(body).toEqual({ message: 'a body parameter' });
+      expect(config?.headers).toEqual({
+        'some-header': 'header-var',
+        'Content-Type': 'application/json',
+      });
+      expect(config?.params).toEqual({
+        'api-version': '2025-01-01',
+      });
+      expect(response.data.success).toBe(true);
+    });
+
+    it('handles DELETE requests with body, header and query parameters', async () => {
+      mockedAxios.delete.mockResolvedValue({ data: { success: true } });
+
+      const data: Record<string, unknown> = {
+        'api-version': '2025-01-01',
+        'message-id': '1',
+        'some-header': 'header-var',
+      };
+
+      const loc: Record<string, 'query' | 'path' | 'header' | 'body'> = {
+        'api-version': 'query',
+        'message-id': 'body',
+        'some-header': 'header',
+      };
+
+      const actionRequest = new ActionRequest(
+        'https://example.com',
+        '/delete',
+        'DELETE',
+        'testDelete',
+        false,
+        'application/json',
+        loc,
+      );
+      const executer = actionRequest.setParams(data);
+      const response = await executer.execute();
+      expect(mockedAxios.delete).toHaveBeenCalled();
+
+      const [url, config] = mockedAxios.delete.mock.calls[0];
+      expect(url).toBe('https://example.com/delete');
+      expect(config?.data).toEqual({ 'message-id': '1' });
+      expect(config?.headers).toEqual({
+        'some-header': 'header-var',
+        'Content-Type': 'application/json',
+      });
+      expect(config?.params).toEqual({
+        'api-version': '2025-01-01',
+      });
+      expect(response.data.success).toBe(true);
+    });
+
   });
 
   it('throws an error for unsupported HTTP method', async () => {

package/specs/mcp.spec.ts

@@ -1,4 +1,4 @@
-import { StdioOptionsSchema } from '../src/mcp';
+import { StdioOptionsSchema, processMCPEnv, MCPOptions } from '../src/mcp';
 
 describe('Environment Variable Extraction (MCP)', () => {
   const originalEnv = process.env;
@@ -49,4 +49,129 @@ describe('Environment Variable Extraction (MCP)', () => {
       expect(result.env).toBeUndefined();
     });
   });
+
+  describe('processMCPEnv', () => {
+    it('should create a deep clone of the input object', () => {
+      const originalObj: MCPOptions = {
+        command: 'node',
+        args: ['server.js'],
+        env: {
+          API_KEY: '${TEST_API_KEY}',
+          PLAIN_VALUE: 'plain-value',
+        },
+      };
+
+      const result = processMCPEnv(originalObj);
+
+      // Verify it's not the same object reference
+      expect(result).not.toBe(originalObj);
+
+      // Modify the result and ensure original is unchanged
+      if ('env' in result && result.env) {
+        result.env.API_KEY = 'modified-value';
+      }
+
+      expect(originalObj.env?.API_KEY).toBe('${TEST_API_KEY}');
+    });
+
+    it('should process environment variables in env field', () => {
+      const obj: MCPOptions = {
+        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 = processMCPEnv(obj);
+
+      expect('env' in result && 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 process user ID in headers field', () => {
+      const userId = 'test-user-123';
+      const obj: MCPOptions = {
+        type: 'sse',
+        url: 'https://example.com',
+        headers: {
+          Authorization: '${TEST_API_KEY}',
+          'User-Id': '{{LIBRECHAT_USER_ID}}',
+          'Content-Type': 'application/json',
+        },
+      };
+
+      const result = processMCPEnv(obj, userId);
+
+      expect('headers' in result && result.headers).toEqual({
+        Authorization: 'test-api-key-value',
+        'User-Id': 'test-user-123',
+        'Content-Type': 'application/json',
+      });
+    });
+
+    it('should handle null or undefined input', () => {
+      // @ts-ignore - Testing null/undefined handling
+      expect(processMCPEnv(null)).toBeNull();
+      // @ts-ignore - Testing null/undefined handling
+      expect(processMCPEnv(undefined)).toBeUndefined();
+    });
+
+    it('should not modify objects without env or headers', () => {
+      const obj: MCPOptions = {
+        command: 'node',
+        args: ['server.js'],
+        timeout: 5000,
+      };
+
+      const result = processMCPEnv(obj);
+
+      expect(result).toEqual(obj);
+      expect(result).not.toBe(obj); // Still a different object (deep clone)
+    });
+
+    it('should ensure different users with same starting config get separate values', () => {
+      // Create a single base configuration
+      const baseConfig: MCPOptions = {
+        type: 'sse',
+        url: 'https://example.com',
+        headers: {
+          'User-Id': '{{LIBRECHAT_USER_ID}}',
+          'API-Key': '${TEST_API_KEY}',
+        },
+      };
+
+      // Process for two different users
+      const user1Id = 'user-123';
+      const user2Id = 'user-456';
+
+      const resultUser1 = processMCPEnv(baseConfig, user1Id);
+      const resultUser2 = processMCPEnv(baseConfig, user2Id);
+
+      // Verify each has the correct user ID
+      expect('headers' in resultUser1 && resultUser1.headers?.['User-Id']).toBe(user1Id);
+      expect('headers' in resultUser2 && resultUser2.headers?.['User-Id']).toBe(user2Id);
+
+      // Verify they're different objects
+      expect(resultUser1).not.toBe(resultUser2);
+
+      // Modify one result and ensure it doesn't affect the other
+      if ('headers' in resultUser1 && resultUser1.headers) {
+        resultUser1.headers['User-Id'] = 'modified-user';
+      }
+
+      // Original config should be unchanged
+      expect(baseConfig.headers?.['User-Id']).toBe('{{LIBRECHAT_USER_ID}}');
+
+      // Second user's config should be unchanged
+      expect('headers' in resultUser2 && resultUser2.headers?.['User-Id']).toBe(user2Id);
+    });
+  });
 });

package/specs/parsers.spec.ts

@@ -0,0 +1,125 @@
+import { replaceSpecialVars } from '../src/parsers';
+import { specialVariables } from '../src/config';
+import type { TUser } from '../src/types';
+
+// Mock dayjs module with consistent date/time values regardless of environment
+jest.mock('dayjs', () => {
+  // Create a mock implementation that returns fixed values
+  const mockDayjs = () => ({
+    format: (format: string) => {
+      if (format === 'YYYY-MM-DD') {
+        return '2024-04-29';
+      }
+      if (format === 'YYYY-MM-DD HH:mm:ss') {
+        return '2024-04-29 12:34:56';
+      }
+      return format; // fallback
+    },
+    day: () => 1, // 1 = Monday
+    toISOString: () => '2024-04-29T16:34:56.000Z',
+  });
+
+  // Add any static methods needed
+  mockDayjs.extend = jest.fn();
+
+  return mockDayjs;
+});
+
+describe('replaceSpecialVars', () => {
+  // Create a partial user object for testing
+  const mockUser = {
+    name: 'Test User',
+    id: 'user123',
+  } as TUser;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should return the original text if text is empty', () => {
+    expect(replaceSpecialVars({ text: '' })).toBe('');
+    expect(replaceSpecialVars({ text: null as unknown as string })).toBe(null);
+    expect(replaceSpecialVars({ text: undefined as unknown as string })).toBe(undefined);
+  });
+
+  test('should replace {{current_date}} with the current date', () => {
+    const result = replaceSpecialVars({ text: 'Today is {{current_date}}' });
+    // dayjs().day() returns 1 for Monday (April 29, 2024 is a Monday)
+    expect(result).toBe('Today is 2024-04-29 (1)');
+  });
+
+  test('should replace {{current_datetime}} with the current datetime', () => {
+    const result = replaceSpecialVars({ text: 'Now is {{current_datetime}}' });
+    expect(result).toBe('Now is 2024-04-29 12:34:56 (1)');
+  });
+
+  test('should replace {{iso_datetime}} with the ISO datetime', () => {
+    const result = replaceSpecialVars({ text: 'ISO time: {{iso_datetime}}' });
+    expect(result).toBe('ISO time: 2024-04-29T16:34:56.000Z');
+  });
+
+  test('should replace {{current_user}} with the user name if provided', () => {
+    const result = replaceSpecialVars({
+      text: 'Hello {{current_user}}!',
+      user: mockUser,
+    });
+    expect(result).toBe('Hello Test User!');
+  });
+
+  test('should not replace {{current_user}} if user is not provided', () => {
+    const result = replaceSpecialVars({
+      text: 'Hello {{current_user}}!',
+    });
+    expect(result).toBe('Hello {{current_user}}!');
+  });
+
+  test('should not replace {{current_user}} if user has no name', () => {
+    const result = replaceSpecialVars({
+      text: 'Hello {{current_user}}!',
+      user: { id: 'user123' } as TUser,
+    });
+    expect(result).toBe('Hello {{current_user}}!');
+  });
+
+  test('should handle multiple replacements in the same text', () => {
+    const result = replaceSpecialVars({
+      text: 'Hello {{current_user}}! Today is {{current_date}} and the time is {{current_datetime}}. ISO: {{iso_datetime}}',
+      user: mockUser,
+    });
+    expect(result).toBe(
+      'Hello Test User! Today is 2024-04-29 (1) and the time is 2024-04-29 12:34:56 (1). ISO: 2024-04-29T16:34:56.000Z',
+    );
+  });
+
+  test('should be case-insensitive when replacing variables', () => {
+    const result = replaceSpecialVars({
+      text: 'Date: {{CURRENT_DATE}}, User: {{Current_User}}',
+      user: mockUser,
+    });
+    expect(result).toBe('Date: 2024-04-29 (1), User: Test User');
+  });
+
+  test('should confirm all specialVariables from config.ts get parsed', () => {
+    // Create a text that includes all special variables
+    const specialVarsText = Object.keys(specialVariables)
+      .map((key) => `{{${key}}}`)
+      .join(' ');
+
+    const result = replaceSpecialVars({
+      text: specialVarsText,
+      user: mockUser,
+    });
+
+    // Verify none of the original variable placeholders remain in the result
+    Object.keys(specialVariables).forEach((key) => {
+      const placeholder = `{{${key}}}`;
+      expect(result).not.toContain(placeholder);
+    });
+
+    // Verify the expected replacements
+    expect(result).toContain('2024-04-29 (1)'); // current_date
+    expect(result).toContain('2024-04-29 12:34:56 (1)'); // current_datetime
+    expect(result).toContain('2024-04-29T16:34:56.000Z'); // iso_datetime
+    expect(result).toContain('Test User'); // current_user
+  });
+});

package/src/actions.ts

@@ -167,12 +167,13 @@ class RequestConfig {
     readonly operation: string,
     readonly isConsequential: boolean,
     readonly contentType: string,
+    readonly parameterLocations?: Record<string, 'query' | 'path' | 'header' | 'body'>,
   ) {}
 }
 
 class RequestExecutor {
   path: string;
-  params?: object;
+  params?: Record<string, unknown>;
   private operationHash?: string;
   private authHeaders: Record<string, string> = {};
   private authToken?: string;
@@ -181,15 +182,28 @@ class RequestExecutor {
     this.path = config.basePath;
   }
 
-  setParams(params: object) {
+  setParams(params: Record<string, unknown>) {
     this.operationHash = sha1(JSON.stringify(params));
-    this.params = Object.assign({}, params);
-
-    for (const [key, value] of Object.entries(params)) {
-      const paramPattern = `{${key}}`;
-      if (this.path.includes(paramPattern)) {
-        this.path = this.path.replace(paramPattern, encodeURIComponent(value as string));
-        delete (this.params as Record<string, unknown>)[key];
+    this.params = { ...params } as Record<string, unknown>;
+    if (this.config.parameterLocations) {
+      //Substituting “Path” Parameters:
+      for (const [key, value] of Object.entries(params)) {
+        if (this.config.parameterLocations[key] === 'path') {
+          const paramPattern = `{${key}}`;
+          if (this.path.includes(paramPattern)) {
+            this.path = this.path.replace(paramPattern, encodeURIComponent(String(value)));
+            delete this.params[key];
+          }
+        }
+      }
+    } else {
+      // Fallback: if no locations are defined, perform path substitution for all keys.
+      for (const [key, value] of Object.entries(params)) {
+        const paramPattern = `{${key}}`;
+        if (this.path.includes(paramPattern)) {
+          this.path = this.path.replace(paramPattern, encodeURIComponent(String(value)));
+          delete this.params[key];
+        }
       }
     }
     return this;
@@ -275,23 +289,46 @@ class RequestExecutor {
 
   async execute() {
     const url = createURL(this.config.domain, this.path);
-    const headers = {
+    const headers: Record<string, string> = {
       ...this.authHeaders,
-      'Content-Type': this.config.contentType,
+      ...(this.config.contentType ? { 'Content-Type': this.config.contentType } : {}),
     };
-
     const method = this.config.method.toLowerCase();
     const axios = _axios.create();
+
+    // Initialize separate containers for query and body parameters.
+    const queryParams: Record<string, unknown> = {};
+    const bodyParams: Record<string, unknown> = {};
+
+    if (this.config.parameterLocations && this.params) {
+      for (const key of Object.keys(this.params)) {
+        // Determine parameter placement; default to "query" for GET and "body" for others.
+        const loc: 'query' | 'path' | 'header' | 'body' = this.config.parameterLocations[key] || (method === 'get' ? 'query' : 'body');
+
+        const val = this.params[key];
+        if (loc === 'query') {
+          queryParams[key] = val;
+        } else if (loc === 'header') {
+          headers[key] = String(val);
+        } else if (loc === 'body') {
+          bodyParams[key] = val;
+        }
+      }
+    } else if (this.params) {
+      Object.assign(queryParams, this.params);
+      Object.assign(bodyParams, this.params);
+    }
+
     if (method === 'get') {
-      return axios.get(url, { headers, params: this.params });
+      return axios.get(url, { headers, params: queryParams });
     } else if (method === 'post') {
-      return axios.post(url, this.params, { headers });
+      return axios.post(url, bodyParams, { headers, params: queryParams });
     } else if (method === 'put') {
-      return axios.put(url, this.params, { headers });
+      return axios.put(url, bodyParams, { headers, params: queryParams });
     } else if (method === 'delete') {
-      return axios.delete(url, { headers, data: this.params });
+      return axios.delete(url, { headers, data: bodyParams, params: queryParams });
     } else if (method === 'patch') {
-      return axios.patch(url, this.params, { headers });
+      return axios.patch(url, bodyParams, { headers, params: queryParams });
     } else {
       throw new Error(`Unsupported HTTP method: ${method}`);
     }
@@ -312,8 +349,9 @@ export class ActionRequest {
     operation: string,
     isConsequential: boolean,
     contentType: string,
+    parameterLocations?: Record<string, 'query' | 'path' | 'header' | 'body'>,
   ) {
-    this.config = new RequestConfig(domain, path, method, operation, isConsequential, contentType);
+    this.config = new RequestConfig(domain, path, method, operation, isConsequential, contentType, parameterLocations);
   }
 
   // Add getters to maintain backward compatibility
@@ -341,7 +379,7 @@ export class ActionRequest {
   }
 
   // Maintain backward compatibility by delegating to a new executor
-  setParams(params: object) {
+  setParams(params: Record<string, unknown>) {
     const executor = this.createExecutor();
     executor.setParams(params);
     return executor;
@@ -406,6 +444,7 @@ export function openapiToFunction(
   // Iterate over each path and method in the OpenAPI spec
   for (const [path, methods] of Object.entries(openapiSpec.paths)) {
     for (const [method, operation] of Object.entries(methods as OpenAPIV3.PathsObject)) {
+      const paramLocations: Record<string, 'query' | 'path' | 'header' | 'body'> = {};
       const operationObj = operation as OpenAPIV3.OperationObject & {
         'x-openai-isConsequential'?: boolean;
       } & {
@@ -445,6 +484,14 @@ export function openapiToFunction(
           if (resolvedParam.required) {
             parametersSchema.required.push(paramName);
           }
+          // Record the parameter location from the OpenAPI "in" field.
+          paramLocations[paramName] =
+          (resolvedParam.in === 'query' ||
+           resolvedParam.in === 'path' ||
+           resolvedParam.in === 'header' ||
+           resolvedParam.in === 'body')
+            ? resolvedParam.in
+            : 'query';
         }
       }
 
@@ -464,6 +511,12 @@ export function openapiToFunction(
         if (resolvedSchema.required) {
           parametersSchema.required.push(...resolvedSchema.required);
         }
+        // Mark requestBody properties as belonging to the "body"
+        if (resolvedSchema.properties) {
+          for (const key in resolvedSchema.properties) {
+            paramLocations[key] = 'body';
+          }
+        }
       }
 
       const functionSignature = new FunctionSignature(
@@ -481,6 +534,7 @@ export function openapiToFunction(
         operationId,
         !!(operationObj['x-openai-isConsequential'] ?? false),
         operationObj.requestBody ? 'application/json' : '',
+        paramLocations,
       );
 
       requestBuilders[operationId] = actionRequest;