Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import { RUM_COLLECTOR_ACK_HEADER } from 'librechat-data-provider';
jest.mock('~/app/metrics', () => ({
recordRumProxyRequest: jest.fn(),
}));
import express from 'express';
import request from 'supertest';
import { createServer } from 'node:http';
import { logger } from '@librechat/data-schemas';
import type { Server } from 'node:http';
import { recordRumProxyRequest } from '~/app/metrics';
import {
getRumProxyBodyLimit,
getRumProxyClientUrl,
getRumProxyTimeoutMs,
getRumProxyTargetBaseUrl,
isRumProxyEnabled,
proxyRumRequest,
resolveRumProxyTarget,
isRumClientLogsEnabled,
isRumLogsEndpointEnabled,
requireRumLogsEnabled,
requireRumProxyEnabled,
excludeRumBodyParser,
} from './proxy';
const PROTOBUF_HEADERS = { 'content-type': 'application/x-protobuf' };
const makeResponse = () => {
const res = {
set: jest.fn(),
send: jest.fn(),
status: jest.fn(),
json: jest.fn(),
};
res.status.mockReturnValue(res);
return res;
};
describe('RUM proxy configuration', () => {
const originalEnv = process.env;
beforeEach(() => {
process.env = { ...originalEnv };
jest.mocked(recordRumProxyRequest).mockClear();
});
afterEach(() => {
process.env = originalEnv;
});
it('uses the fixed LibreChat RUM proxy URL and default body limit', () => {
delete process.env.RUM_PROXY_BODY_LIMIT;
delete process.env.RUM_PROXY_TIMEOUT_MS;
expect(getRumProxyClientUrl()).toBe('/api/rum');
expect(getRumProxyBodyLimit()).toBe('3mb');
expect(getRumProxyTimeoutMs()).toBe(10000);
});
it('uses a positive custom collector timeout', () => {
process.env.RUM_PROXY_TIMEOUT_MS = '2500';
expect(getRumProxyTimeoutMs()).toBe(2500);
process.env.RUM_PROXY_TIMEOUT_MS = '-1';
expect(getRumProxyTimeoutMs()).toBe(10000);
});
it('resolves OTLP paths against the configured collector base URL', () => {
process.env.RUM_ENABLED = 'true';
process.env.RUM_AUTH_MODE = 'proxy';
process.env.RUM_PROXY_TARGET_URL = 'http://otel-collector:4318';
expect(isRumProxyEnabled()).toBe(true);
expect(resolveRumProxyTarget('/v1/traces')).toBe('http://otel-collector:4318/v1/traces');
expect(resolveRumProxyTarget('/v1/logs')).toBe('http://otel-collector:4318/v1/logs');
expect(resolveRumProxyTarget('/v1/metrics')).toBeUndefined();
});
it('does not enable proxy mode when RUM is disabled', () => {
process.env.RUM_ENABLED = 'false';
process.env.RUM_AUTH_MODE = 'proxy';
process.env.RUM_PROXY_TARGET_URL = 'http://otel-collector:4318';
expect(isRumProxyEnabled()).toBe(false);
delete process.env.RUM_ENABLED;
expect(isRumProxyEnabled()).toBe(false);
});
it('keeps client logs opt-in and limited to proxy mode', () => {
process.env.RUM_ENABLED = 'true';
process.env.RUM_AUTH_MODE = 'proxy';
process.env.RUM_PROXY_TARGET_URL = 'http://otel-collector:4318';
delete process.env.RUM_CLIENT_LOGS;
expect(isRumClientLogsEnabled()).toBe(false);
process.env.RUM_CLIENT_LOGS = '';
expect(isRumClientLogsEnabled()).toBe(false);
process.env.RUM_CLIENT_LOGS = 'false';
expect(isRumClientLogsEnabled()).toBe(false);
process.env.RUM_CLIENT_LOGS = 'true';
expect(isRumClientLogsEnabled()).toBe(true);
process.env.RUM_CLIENT_LOGS = 'true';
process.env.RUM_AUTH_MODE = 'publicToken';
expect(isRumClientLogsEnabled()).toBe(false);
});
it.each([
[{}, false],
[{ RUM_CLIENT_LOGS: 'true' }, true],
[{ RUM_CONSOLE_CAPTURE: 'true' }, true],
[{ RUM_DISABLE_REPLAY: 'false' }, true],
[{ RUM_DISABLE_REPLAY: 'true', RUM_CLIENT_LOGS: 'false' }, false],
])('accepts OTLP logs only when a browser log source is enabled (%p)', (env, expected) => {
process.env.RUM_ENABLED = 'true';
process.env.RUM_AUTH_MODE = 'proxy';
process.env.RUM_PROXY_TARGET_URL = 'http://otel-collector:4318';
delete process.env.RUM_CLIENT_LOGS;
delete process.env.RUM_CONSOLE_CAPTURE;
delete process.env.RUM_DISABLE_REPLAY;
Object.assign(process.env, env);
expect(isRumLogsEndpointEnabled()).toBe(expected);
process.env.RUM_AUTH_MODE = 'publicToken';
expect(isRumLogsEndpointEnabled()).toBe(false);
});
it.each([undefined, 'text/plain', 'multipart/form-data; boundary=x', 'application/xml'])(
'refuses %p payloads with 415 before contacting the collector',
async (contentType) => {
process.env.RUM_ENABLED = 'true';
process.env.RUM_AUTH_MODE = 'proxy';
process.env.RUM_PROXY_TARGET_URL = 'http://otel-collector:4318';
const fetchMock = jest.spyOn(global, 'fetch');
const res = makeResponse();
await proxyRumRequest(
{
path: '/v1/logs',
body: Buffer.from('payload'),
headers: contentType ? { 'content-type': contentType } : {},
} as never,
res as never,
);
expect(res.status).toHaveBeenCalledWith(415);
expect(fetchMock).not.toHaveBeenCalled();
expect(recordRumProxyRequest).toHaveBeenCalledWith('logs', 'unsupported_media_type');
fetchMock.mockRestore();
},
);
it('rejects unsafe collector target URLs', () => {
process.env.RUM_PROXY_TARGET_URL = 'https://user:[email protected]';
expect(getRumProxyTargetBaseUrl()).toBeUndefined();
process.env.RUM_PROXY_TARGET_URL = 'file:///tmp/collector';
expect(getRumProxyTargetBaseUrl()).toBeUndefined();
});
it('forwards OTLP requests without forwarding app authorization', async () => {
process.env.RUM_ENABLED = 'true';
process.env.RUM_AUTH_MODE = 'proxy';
process.env.RUM_PROXY_TARGET_URL = 'http://otel-collector:4318';
const fetchMock = jest.spyOn(global, 'fetch').mockResolvedValue(
new Response('ok', {
status: 202,
headers: { 'content-type': 'application/json' },
}),
);
const res = makeResponse();
await proxyRumRequest(
{
path: '/v1/traces',
body: { resourceSpans: [] },
headers: {
accept: 'application/json',
authorization: 'Bearer app-token',
'content-type': 'application/json',
},
} as never,
res as never,
);
expect(fetchMock).toHaveBeenCalledWith('http://otel-collector:4318/v1/traces', {
method: 'POST',
redirect: 'follow',
headers: {
accept: 'application/json',
'content-type': 'application/json',
},
body: JSON.stringify({ resourceSpans: [] }),
signal: expect.any(AbortSignal),
});
expect(res.set).toHaveBeenCalledWith('content-type', 'application/json');
expect(res.status).toHaveBeenCalledWith(202);
expect(res.send).toHaveBeenCalledWith(Buffer.from('ok'));
expect(recordRumProxyRequest).toHaveBeenCalledWith('traces', 'success');
fetchMock.mockRestore();
});
it('returns 400 for missing payloads and 404 for unsupported OTLP paths', async () => {
process.env.RUM_ENABLED = 'true';
process.env.RUM_AUTH_MODE = 'proxy';
process.env.RUM_PROXY_TARGET_URL = 'http://otel-collector:4318';
const missingBodyRes = makeResponse();
const unsupportedPathRes = makeResponse();
await proxyRumRequest(
{ path: '/v1/traces', headers: { 'content-type': 'application/x-protobuf' } } as never,
missingBodyRes as never,
);
await proxyRumRequest(
{ path: '/v1/metrics', body: Buffer.from('payload'), headers: {} } as never,
unsupportedPathRes as never,
);
expect(missingBodyRes.status).toHaveBeenCalledWith(400);
expect(unsupportedPathRes.status).toHaveBeenCalledWith(404);
expect(recordRumProxyRequest).toHaveBeenCalledWith('traces', 'bad_request');
expect(recordRumProxyRequest).toHaveBeenCalledWith('unknown', 'not_configured');
});
it('returns 502 when the collector request fails', async () => {
process.env.RUM_ENABLED = 'true';
process.env.RUM_AUTH_MODE = 'proxy';
process.env.RUM_PROXY_TARGET_URL = 'http://otel-collector:4318';
const fetchMock = jest.spyOn(global, 'fetch').mockRejectedValue(new Error('collector down'));
const res = makeResponse();
await proxyRumRequest(
{ path: '/v1/traces', body: Buffer.from('payload'), headers: PROTOBUF_HEADERS } as never,
res as never,
);
expect(res.status).toHaveBeenCalledWith(502);
expect(recordRumProxyRequest).toHaveBeenCalledWith('traces', 'collector_error');
fetchMock.mockRestore();
});
it('records collector error status classes', async () => {
process.env.RUM_ENABLED = 'true';
process.env.RUM_AUTH_MODE = 'proxy';
process.env.RUM_PROXY_TARGET_URL = 'http://otel-collector:4318';
const fetchMock = jest
.spyOn(global, 'fetch')
.mockResolvedValue(new Response('nope', { status: 503 }));
const res = makeResponse();
await proxyRumRequest(
{ path: '/v1/logs', body: Buffer.from([10, 0]), headers: PROTOBUF_HEADERS } as never,
res as never,
);
expect(res.status).toHaveBeenCalledWith(503);
expect(recordRumProxyRequest).toHaveBeenCalledWith('logs', 'collector_5xx');
fetchMock.mockRestore();
});
});
describe('RUM HTTP boundary', () => {
const originalEnv = process.env;
beforeEach(() => {
process.env = {
...originalEnv,
RUM_ENABLED: 'true',
RUM_AUTH_MODE: 'proxy',
RUM_PROXY_TARGET_URL: 'http://otel-collector:4318',
};
});
afterEach(() => {
process.env = originalEnv;
});
it('maps disabled proxy and log-source policy to 404 in typed middleware', async () => {
delete process.env.RUM_CLIENT_LOGS;
delete process.env.RUM_CONSOLE_CAPTURE;
delete process.env.RUM_DISABLE_REPLAY;
const app = express();
app.post('/traces', requireRumProxyEnabled, (_req, res) => {
res.status(202).end();
});
app.post('/logs', requireRumLogsEnabled, requireRumProxyEnabled, (_req, res) => {
res.status(202).end();
});
expect((await request(app).post('/traces')).status).toBe(202);
expect((await request(app).post('/logs')).status).toBe(404);
process.env.RUM_CLIENT_LOGS = 'true';
expect((await request(app).post('/logs')).status).toBe(202);
process.env.RUM_ENABLED = 'false';
expect((await request(app).post('/traces')).status).toBe(404);
});
it('defers JSON parsing to the authenticated, rate-limited RUM route without changing other routes', async () => {
const parser = jest.fn(express.json({ limit: '3mb' }));
const app = express();
app.use(excludeRumBodyParser(parser));
app.post(
'/api/rum/v1/logs',
(req, res, next) => {
expect(req.body).toBeUndefined();
if (!req.headers.authorization) {
res.status(204).end();
return;
}
if (req.headers['x-budget'] === 'exhausted') {
res.status(429).end();
return;
}
next();
},
express.json({ limit: '1kb' }),
(req, res) => {
res.json(req.body);
},
);
app.post('/api/rumor', (req, res) => {
res.json(req.body);
});
const body = 'not valid JSON';
expect(
(
await request(app)
.post('/api/rum/v1/logs')
.set('Content-Type', 'application/json')
.send(body)
).status,
).toBe(204);
expect(
(
await request(app)
.post('/api/rum/v1/logs')
.set('authorization', 'Bearer test')
.set('x-budget', 'exhausted')
.set('Content-Type', 'application/json')
.send(body.repeat(1000))
).status,
).toBe(429);
expect(
(
await request(app)
.post('/API/RUM/v1/logs')
.set('Content-Type', 'application/json')
.send(body)
).status,
).toBe(204);
expect(parser).not.toHaveBeenCalled();
expect(
(
await request(app)
.post('/api/rum/v1/logs')
.set('authorization', 'Bearer test')
.set('Content-Type', 'application/json')
.send(body)
).status,
).toBe(400);
expect(
(
await request(app)
.post('/api/rum/v1/logs')
.set('authorization', 'Bearer test')
.send({ records: [] })
).body,
).toEqual({ records: [] });
expect(
(
await request(app)
.post('/api/rum/v1/logs')
.set('authorization', 'Bearer test')
.send({ text: 'x'.repeat(2000) })
).status,
).toBe(413);
expect((await request(app).post('/api/rumor').send({ parsed: true })).body).toEqual({
parsed: true,
});
expect(parser).toHaveBeenCalledTimes(1);
});
});
describe('RUM proxy upstream HTTP contract', () => {
const originalEnv = process.env;
let collector: Server;
let collectorUrl: string;
beforeEach(async () => {
process.env = { ...originalEnv };
process.env.RUM_ENABLED = 'true';
process.env.RUM_SESSION_REPLAY_ENABLED = 'true';
jest.mocked(recordRumProxyRequest).mockClear();
collector = createServer();
await new Promise<void>((resolve) => collector.listen(0, '127.0.0.1', resolve));
const address = collector.address();
if (!address || typeof address === 'string') {
throw new Error('Expected a TCP collector address');
}
collectorUrl = `http://127.0.0.1:${address.port}`;
process.env.RUM_PROXY_TARGET_URL = collectorUrl;
});
afterEach(async () => {
process.env = originalEnv;
collector.closeAllConnections();
await new Promise<void>((resolve, reject) =>
collector.close((error) => (error ? reject(error) : resolve())),
);
});
function createProxy(authorization?: string) {
const app = express();
app.use(express.raw({ type: '*/*' }));
app.post('/v1/:signal', (req, res) => proxyRumRequest(req, res, authorization));
return app;
}
it('drops stale replay batches without collector acknowledgement while ordinary logs stay enabled', async () => {
process.env.RUM_SESSION_REPLAY_ENABLED = 'false';
process.env.RUM_CLIENT_LOGS = 'true';
const collectorRequest = jest.fn();
collector.on('request', collectorRequest);
const response = await request(createProxy())
.post('/v1/logs')
.send({
resourceLogs: [
{
scopeLogs: [
{
logRecords: [
{
attributes: [{ key: 'rr-web.event', value: { intValue: '2' } }],
body: { stringValue: 'private-recording' },
},
],
},
],
},
],
});
expect(response.status).toBe(204);
expect(response.headers[RUM_COLLECTOR_ACK_HEADER]).toBeUndefined();
expect(collectorRequest).not.toHaveBeenCalled();
expect(recordRumProxyRequest).toHaveBeenCalledWith('logs', 'replay_disabled');
});
it('strips replay records from a mixed batch before contacting the collector', async () => {
process.env.RUM_SESSION_REPLAY_ENABLED = 'false';
process.env.RUM_CONSOLE_CAPTURE = 'true';
let received = '';
collector.on('request', (req, res) => {
req.on('data', (chunk: Buffer) => {
received += chunk.toString();
});
req.on('end', () => {
res.writeHead(202);
res.end();
});
});
const response = await request(createProxy())
.post('/v1/logs')
.send({
resourceLogs: [
{
scopeLogs: [
{
logRecords: [
{ body: { stringValue: 'ordinary-error' } },
{
attributes: [{ key: 'rr-web.event', value: { intValue: '2' } }],
body: { stringValue: 'private-recording' },
},
],
},
],
},
],
});
expect(response.status).toBe(202);
expect(received).toContain('ordinary-error');
expect(received).not.toContain('private-recording');
expect(response.headers[RUM_COLLECTOR_ACK_HEADER]).toBe('true');
});
it('rejects malformed binary logs while replay is off without contacting the collector', async () => {
process.env.RUM_SESSION_REPLAY_ENABLED = 'false';
const collectorRequest = jest.fn();
collector.on('request', collectorRequest);
const response = await request(createProxy())
.post('/v1/logs')
.set('Content-Type', 'application/x-protobuf')
.send(Buffer.from([10, 255]));
expect(response.status).toBe(400);
expect(collectorRequest).not.toHaveBeenCalled();
});
it.each(['traces', 'logs'])(
'sends only server credentials and intact %s payloads',
async (signal) => {
const payload = Buffer.from([0x0a, 0x02, 0x00, 0xff]);
const received: {
authorization?: string;
cookie?: string;
apiKey?: string;
path?: string;
body: Buffer;
} = {
body: Buffer.alloc(0),
};
collector.on('request', (req, res) => {
received.authorization = req.headers.authorization;
received.cookie = req.headers.cookie;
received.apiKey = req.headers['x-api-key']?.toString();
received.path = req.url;
req.on('data', (chunk: Buffer) => {
received.body = Buffer.concat([received.body, chunk]);
});
req.on('end', () => {
res.writeHead(202, { 'content-type': 'application/x-protobuf' });
res.end(Buffer.from([0x00]));
});
});
const response = await request(createProxy(' clickstack-ingestion-key '))
.post(`/v1/${signal}`)
.set('Content-Type', 'application/x-protobuf')
.set('Authorization', 'Bearer librechat-session-token')
.set('Cookie', 'refreshToken=private-cookie')
.set('X-Api-Key', 'browser-supplied-key')
.send(payload);
expect(response.status).toBe(202);
expect(received).toEqual({
authorization: 'clickstack-ingestion-key',
cookie: undefined,
apiKey: undefined,
path: `/v1/${signal}`,
body: payload,
});
expect(recordRumProxyRequest).toHaveBeenCalledWith(signal, 'success');
},
);
it('marks a successful collector 204 so clients can distinguish it from an auth drop', async () => {
collector.on('request', (_req, res) => {
res.writeHead(204);
res.end();
});
const app = express();
app.use(express.json());
app.post('/v1/logs', (req, res) => proxyRumRequest(req, res));
const response = await request(app).post('/v1/logs').send({ resourceLogs: [] });
expect(response.status).toBe(204);
expect(response.headers[RUM_COLLECTOR_ACK_HEADER]).toBe('true');
});
it('forwards OTLP/JSON log records unchanged after the app JSON parser and never logs them', async () => {
const records = {
resourceLogs: [
{
resource: {
attributes: [{ key: 'service.name', value: { stringValue: 'librechat-web' } }],
},
scopeLogs: [
{
scope: { name: 'librechat.client', version: '1' },
logRecords: [
{
timeUnixNano: '1790000000000000000',
severityNumber: 17,
severityText: 'ERROR',
body: { stringValue: 'payload-marker' },
attributes: [{ key: 'log.repeat_count', value: { intValue: '3' } }],
traceId: 'a'.repeat(32),
spanId: 'b'.repeat(16),
},
],
},
],
},
],
};
let receivedBody = '';
let receivedType: string | undefined;
collector.on('request', (req, res) => {
receivedType = req.headers['content-type'];
req.on('data', (chunk: Buffer) => {
receivedBody += chunk.toString();
});
req.on('end', () => {
res.writeHead(200, { 'content-type': 'application/json' });
res.end('{}');
});
});
const logSpy = jest.spyOn(logger, 'warn');
const app = express();
app.use(express.json({ limit: '3mb' }));
app.post('/v1/:signal', (req, res) => proxyRumRequest(req, res));
const response = await request(app)
.post('/v1/logs')
.set('Content-Type', 'application/json')
.send(JSON.stringify(records));
expect(response.status).toBe(200);
expect(receivedType).toBe('application/json');
expect(JSON.parse(receivedBody)).toEqual(records);
expect(JSON.stringify(logSpy.mock.calls)).not.toContain('payload-marker');
logSpy.mockRestore();
});
it.each([undefined, '', ' '])(
'preserves unauthenticated collectors with authorization %p',
async (authorization) => {
let receivedAuthorization: string | undefined;
collector.on('request', (req, res) => {
receivedAuthorization = req.headers.authorization;
req.resume();
res.writeHead(200);
res.end('{}');
});
const response = await request(createProxy(authorization))
.post('/v1/logs')
.set('Authorization', 'Bearer app-token')
.set('Content-Type', 'application/json')
.send('{}');
expect(response.status).toBe(200);
expect(receivedAuthorization).toBeUndefined();
},
);
it.each([301, 302, 303, 307, 308])(
'does not follow a credentialed %s redirect, even on the same origin',
async (status) => {
const paths: string[] = [];
collector.on('request', (req, res) => {
paths.push(req.url ?? '');
req.resume();
res.writeHead(status, { location: `${collectorUrl}/redirect-target` });
res.end();
});
const response = await request(createProxy('clickstack-ingestion-key'))
.post('/v1/traces')
.set('Content-Type', 'application/json')
.send('{}');
expect(response.status).toBe(502);
expect(paths).toEqual(['/v1/traces']);
expect(response.headers.location).toBeUndefined();
expect(recordRumProxyRequest).toHaveBeenCalledWith('traces', 'collector_error');
},
);
it.each(['private-key\r\ninjected: value', 'private-key-😀'])(
'rejects invalid credentials without leaking them',
async (authorization) => {
const fetchSpy = jest.spyOn(global, 'fetch');
const logSpy = jest.spyOn(logger, 'warn');
const response = await request(createProxy(authorization))
.post('/v1/traces')
.set('Content-Type', 'application/json')
.send('{}');
expect(response.status).toBe(502);
expect(fetchSpy).not.toHaveBeenCalled();
expect(logSpy).toHaveBeenCalledWith('[rumProxy] Failed to proxy RUM telemetry', {
error: 'Invalid RUM proxy authorization header',
target: `${collectorUrl}/v1/traces`,
});
expect(response.text).not.toContain('private-key');
expect(JSON.stringify(logSpy.mock.calls)).not.toContain('private-key');
},
);
});