librechat-data-provider 0.7.82 → 0.7.83

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librechat-data-provider",
-  "version": "0.7.82",
+  "version": "0.7.83",
   "description": "data services for librechat apps",
   "main": "dist/index.js",
   "module": "dist/index.es.js",

package/specs/mcp.spec.ts

@@ -1,4 +1,4 @@
-import { StdioOptionsSchema, processMCPEnv, MCPOptions } from '../src/mcp';
+import { StdioOptionsSchema, StreamableHTTPOptionsSchema, processMCPEnv, MCPOptions } from '../src/mcp';
 
 describe('Environment Variable Extraction (MCP)', () => {
   const originalEnv = process.env;
@@ -50,6 +50,74 @@ describe('Environment Variable Extraction (MCP)', () => {
     });
   });
 
+  describe('StreamableHTTPOptionsSchema', () => {
+    it('should validate a valid streamable-http configuration', () => {
+      const options = {
+        type: 'streamable-http',
+        url: 'https://example.com/api',
+        headers: {
+          Authorization: 'Bearer token',
+          'Content-Type': 'application/json',
+        },
+      };
+
+      const result = StreamableHTTPOptionsSchema.parse(options);
+
+      expect(result).toEqual(options);
+    });
+
+    it('should reject websocket URLs', () => {
+      const options = {
+        type: 'streamable-http',
+        url: 'ws://example.com/socket',
+      };
+
+      expect(() => StreamableHTTPOptionsSchema.parse(options)).toThrow();
+    });
+
+    it('should reject secure websocket URLs', () => {
+      const options = {
+        type: 'streamable-http',
+        url: 'wss://example.com/socket',
+      };
+
+      expect(() => StreamableHTTPOptionsSchema.parse(options)).toThrow();
+    });
+
+    it('should require type field to be set explicitly', () => {
+      const options = {
+        url: 'https://example.com/api',
+      };
+
+      // Type is now required, so parsing should fail
+      expect(() => StreamableHTTPOptionsSchema.parse(options)).toThrow();
+      
+      // With type provided, it should pass
+      const validOptions = {
+        type: 'streamable-http' as const,
+        url: 'https://example.com/api',
+      };
+      
+      const result = StreamableHTTPOptionsSchema.parse(validOptions);
+      expect(result.type).toBe('streamable-http');
+    });
+
+    it('should validate headers as record of strings', () => {
+      const options = {
+        type: 'streamable-http',
+        url: 'https://example.com/api',
+        headers: {
+          'X-API-Key': '123456',
+          'User-Agent': 'MCP Client',
+        },
+      };
+
+      const result = StreamableHTTPOptionsSchema.parse(options);
+      
+      expect(result.headers).toEqual(options.headers);
+    });
+  });
+
   describe('processMCPEnv', () => {
     it('should create a deep clone of the input object', () => {
       const originalObj: MCPOptions = {
@@ -173,5 +241,37 @@ describe('Environment Variable Extraction (MCP)', () => {
       // Second user's config should be unchanged
       expect('headers' in resultUser2 && resultUser2.headers?.['User-Id']).toBe(user2Id);
     });
+
+    it('should process headers in streamable-http options', () => {
+      const userId = 'test-user-123';
+      const obj: MCPOptions = {
+        type: 'streamable-http',
+        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 maintain streamable-http type in processed options', () => {
+      const obj: MCPOptions = {
+        type: 'streamable-http',
+        url: 'https://example.com/api',
+      };
+
+      const result = processMCPEnv(obj);
+
+      expect(result.type).toBe('streamable-http');
+    });
   });
 });

package/src/config.ts

@@ -52,6 +52,7 @@ export const excludedKeys = new Set([
   'model',
   'files',
   'spec',
+  'disableParams',
 ]);
 
 export enum SettingsViews {
@@ -505,10 +506,28 @@ export const intefaceSchema = z
 export type TInterfaceConfig = z.infer<typeof intefaceSchema>;
 export type TBalanceConfig = z.infer<typeof balanceSchema>;
 
+export const turnstileOptionsSchema = z
+  .object({
+    language: z.string().default('auto'),
+    size: z.enum(['normal', 'compact', 'flexible', 'invisible']).default('normal'),
+  })
+  .default({
+    language: 'auto',
+    size: 'normal',
+  });
+
+export const turnstileSchema = z.object({
+  siteKey: z.string(),
+  options: turnstileOptionsSchema.optional(),
+});
+
+export type TTurnstileConfig = z.infer<typeof turnstileSchema>;
+
 export type TStartupConfig = {
   appTitle: string;
   socialLogins?: string[];
   interface?: TInterfaceConfig;
+  turnstile?: TTurnstileConfig;
   balance?: TBalanceConfig;
   discordLoginEnabled: boolean;
   facebookLoginEnabled: boolean;
@@ -578,6 +597,7 @@ export const configSchema = z.object({
   filteredTools: z.array(z.string()).optional(),
   mcpServers: MCPServersSchema.optional(),
   interface: intefaceSchema,
+  turnstile: turnstileSchema.optional(),
   fileStrategy: fileSourceSchema.default(FileSources.local),
   actions: z
     .object({

package/src/generate.ts

@@ -358,7 +358,7 @@ export function validateSettingDefinitions(settings: SettingsConfiguration): voi
         // continue;
       }
       setting.includeInput =
-        setting.type === SettingTypes.Number ? setting.includeInput ?? true : false; // Default to true if type is number
+        setting.type === SettingTypes.Number ? (setting.includeInput ?? true) : false; // Default to true if type is number
     }
 
     if (setting.component === ComponentTypes.Slider && setting.type === SettingTypes.Number) {
@@ -445,7 +445,8 @@ export function validateSettingDefinitions(settings: SettingsConfiguration): voi
 
     // Validate optionType and conversation schema
     if (setting.optionType !== OptionTypes.Custom) {
-      const conversationSchema = tConversationSchema.shape[setting.key as keyof TConversation];
+      const conversationSchema =
+        tConversationSchema.shape[setting.key as keyof Omit<TConversation, 'disableParams'>];
       if (!conversationSchema) {
         errors.push({
           code: ZodIssueCode.custom,

package/src/mcp.ts

@@ -82,10 +82,28 @@ export const SSEOptionsSchema = BaseOptionsSchema.extend({
     ),
 });
 
+export const StreamableHTTPOptionsSchema = BaseOptionsSchema.extend({
+  type: z.literal('streamable-http'),
+  headers: z.record(z.string(), z.string()).optional(),
+  url: z
+    .string()
+    .url()
+    .refine(
+      (val) => {
+        const protocol = new URL(val).protocol;
+        return protocol !== 'ws:' && protocol !== 'wss:';
+      },
+      {
+        message: 'Streamable HTTP URL must not start with ws:// or wss://',
+      },
+    ),
+});
+
 export const MCPOptionsSchema = z.union([
   StdioOptionsSchema,
   WebSocketOptionsSchema,
   SSEOptionsSchema,
+  StreamableHTTPOptionsSchema,
 ]);
 
 export const MCPServersSchema = z.record(z.string(), MCPOptionsSchema);

package/src/schemas.ts

@@ -745,6 +745,7 @@ export type TSetOption = (
 
 export type TConversation = z.infer<typeof tConversationSchema> & {
   presetOverride?: Partial<TPreset>;
+  disableParams?: boolean;
 };
 
 export const tSharedLinkSchema = z.object({