librechat-data-provider 0.7.82 → 0.7.85

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "librechat-data-provider",
-  "version": "0.7.82",
+  "version": "0.7.85",
   "description": "data services for librechat apps",
   "main": "dist/index.js",
   "module": "dist/index.es.js",
@@ -48,6 +48,7 @@
     "@babel/preset-env": "^7.21.5",
     "@babel/preset-react": "^7.18.6",
     "@babel/preset-typescript": "^7.21.0",
+    "@langchain/core": "^0.3.57",
     "@rollup/plugin-alias": "^5.1.0",
     "@rollup/plugin-commonjs": "^25.0.2",
     "@rollup/plugin-json": "^6.1.0",
@@ -58,6 +59,7 @@
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.3.0",
     "@types/react": "^18.2.18",
+    "@types/winston": "^2.4.4",
     "jest": "^29.5.0",
     "jest-junit": "^16.0.0",
     "openai": "^4.76.3",

package/specs/bedrock.spec.ts

@@ -0,0 +1,114 @@
+import { bedrockInputParser } from '../src/bedrock';
+import type { BedrockConverseInput } from '../src/bedrock';
+
+describe('bedrockInputParser', () => {
+  describe('Model Matching for Reasoning Configuration', () => {
+    test('should match anthropic.claude-3-7-sonnet model', () => {
+      const input = {
+        model: 'anthropic.claude-3-7-sonnet',
+      };
+      const result = bedrockInputParser.parse(input) as BedrockConverseInput;
+      const additionalFields = result.additionalModelRequestFields as Record<string, unknown>;
+      expect(additionalFields.thinking).toBe(true);
+      expect(additionalFields.thinkingBudget).toBe(2000);
+      expect(additionalFields.anthropic_beta).toEqual(['output-128k-2025-02-19']);
+    });
+
+    test('should match anthropic.claude-sonnet-4 model', () => {
+      const input = {
+        model: 'anthropic.claude-sonnet-4',
+      };
+      const result = bedrockInputParser.parse(input) as BedrockConverseInput;
+      const additionalFields = result.additionalModelRequestFields as Record<string, unknown>;
+      expect(additionalFields.thinking).toBe(true);
+      expect(additionalFields.thinkingBudget).toBe(2000);
+      expect(additionalFields.anthropic_beta).toEqual(['output-128k-2025-02-19']);
+    });
+
+    test('should match anthropic.claude-opus-5 model', () => {
+      const input = {
+        model: 'anthropic.claude-opus-5',
+      };
+      const result = bedrockInputParser.parse(input) as BedrockConverseInput;
+      const additionalFields = result.additionalModelRequestFields as Record<string, unknown>;
+      expect(additionalFields.thinking).toBe(true);
+      expect(additionalFields.thinkingBudget).toBe(2000);
+      expect(additionalFields.anthropic_beta).toEqual(['output-128k-2025-02-19']);
+    });
+
+    test('should match anthropic.claude-haiku-6 model', () => {
+      const input = {
+        model: 'anthropic.claude-haiku-6',
+      };
+      const result = bedrockInputParser.parse(input) as BedrockConverseInput;
+      const additionalFields = result.additionalModelRequestFields as Record<string, unknown>;
+      expect(additionalFields.thinking).toBe(true);
+      expect(additionalFields.thinkingBudget).toBe(2000);
+      expect(additionalFields.anthropic_beta).toEqual(['output-128k-2025-02-19']);
+    });
+
+    test('should match anthropic.claude-4-sonnet model', () => {
+      const input = {
+        model: 'anthropic.claude-4-sonnet',
+      };
+      const result = bedrockInputParser.parse(input) as BedrockConverseInput;
+      const additionalFields = result.additionalModelRequestFields as Record<string, unknown>;
+      expect(additionalFields.thinking).toBe(true);
+      expect(additionalFields.thinkingBudget).toBe(2000);
+      expect(additionalFields.anthropic_beta).toEqual(['output-128k-2025-02-19']);
+    });
+
+    test('should match anthropic.claude-4.5-sonnet model', () => {
+      const input = {
+        model: 'anthropic.claude-4.5-sonnet',
+      };
+      const result = bedrockInputParser.parse(input) as BedrockConverseInput;
+      const additionalFields = result.additionalModelRequestFields as Record<string, unknown>;
+      expect(additionalFields.thinking).toBe(true);
+      expect(additionalFields.thinkingBudget).toBe(2000);
+      expect(additionalFields.anthropic_beta).toEqual(['output-128k-2025-02-19']);
+    });
+
+    test('should match anthropic.claude-4-7-sonnet model', () => {
+      const input = {
+        model: 'anthropic.claude-4-7-sonnet',
+      };
+      const result = bedrockInputParser.parse(input) as BedrockConverseInput;
+      const additionalFields = result.additionalModelRequestFields as Record<string, unknown>;
+      expect(additionalFields.thinking).toBe(true);
+      expect(additionalFields.thinkingBudget).toBe(2000);
+      expect(additionalFields.anthropic_beta).toEqual(['output-128k-2025-02-19']);
+    });
+
+    test('should not match non-Claude models', () => {
+      const input = {
+        model: 'some-other-model',
+      };
+      const result = bedrockInputParser.parse(input) as BedrockConverseInput;
+      expect(result.additionalModelRequestFields).toBeUndefined();
+    });
+
+    test('should respect explicit thinking configuration', () => {
+      const input = {
+        model: 'anthropic.claude-sonnet-4',
+        thinking: false,
+      };
+      const result = bedrockInputParser.parse(input) as BedrockConverseInput;
+      const additionalFields = result.additionalModelRequestFields as Record<string, unknown>;
+      expect(additionalFields.thinking).toBeUndefined();
+      expect(additionalFields.thinkingBudget).toBeUndefined();
+    });
+
+    test('should respect custom thinking budget', () => {
+      const input = {
+        model: 'anthropic.claude-sonnet-4',
+        thinking: true,
+        thinkingBudget: 3000,
+      };
+      const result = bedrockInputParser.parse(input) as BedrockConverseInput;
+      const additionalFields = result.additionalModelRequestFields as Record<string, unknown>;
+      expect(additionalFields.thinking).toBe(true);
+      expect(additionalFields.thinkingBudget).toBe(3000);
+    });
+  });
+});

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');
+    });
   });
 });