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 type { AppConfig } from '@librechat/data-schemas';
/** A minimal AppConfig stub carrying only the langfuse.promptSync fields the
* lock-lease and page-cap readers consult. */
function langfuseAppConfig(promptSync: Record<string, unknown>): AppConfig {
return { langfuse: { promptSync } } as unknown as AppConfig;
}
const envKeys = [
'LANGFUSE_PUBLIC_KEY',
'LANGFUSE_SECRET_KEY',
'LANGFUSE_TRACING_ENABLED',
'LANGFUSE_SAMPLE_RATE',
'LANGFUSE_FANOUT_ENABLED',
'LANGFUSE_FANOUT_COLLECTOR_URL',
'LANGFUSE_FANOUT_TENANT_EXPORT_DISABLED',
'TENANT_ISOLATION_STRICT',
'LANGFUSE_PROMPT_SYNC_AVAILABLE',
'LANGFUSE_PROMPT_SYNC_TIMEOUT_MS',
];
function clearEnv() {
for (const key of envKeys) {
delete process.env[key];
}
}
describe('Langfuse policy', () => {
beforeEach(clearEnv);
afterEach(clearEnv);
it('offers connection settings by default in single-tenant deployments', async () => {
const { isLangfuseConnectionAvailable } = await import('./policy');
expect(isLangfuseConnectionAvailable()).toBe(true);
});
it('hides single-tenant settings when environment credentials own the connection', async () => {
process.env.LANGFUSE_PUBLIC_KEY = 'pk-env';
process.env.LANGFUSE_SECRET_KEY = 'sk-env';
const { isLangfuseConnectionAvailable } = await import('./policy');
expect(isLangfuseConnectionAvailable()).toBe(false);
});
it('does not hide settings for incomplete environment credentials', async () => {
process.env.LANGFUSE_PUBLIC_KEY = 'pk-env';
const { isLangfuseConnectionAvailable } = await import('./policy');
expect(isLangfuseConnectionAvailable()).toBe(true);
});
it('requires fanout in strict multi-tenant deployments', async () => {
process.env.TENANT_ISOLATION_STRICT = 'true';
const { isLangfuseConnectionAvailable } = await import('./policy');
expect(isLangfuseConnectionAvailable()).toBe(false);
process.env.LANGFUSE_FANOUT_ENABLED = 'true';
process.env.LANGFUSE_FANOUT_COLLECTOR_URL = 'http://collector:4318';
expect(isLangfuseConnectionAvailable()).toBe(true);
});
it('uses explicit fanout routing without requiring strict tenant isolation', async () => {
process.env.LANGFUSE_PUBLIC_KEY = 'pk-central';
process.env.LANGFUSE_SECRET_KEY = 'sk-central';
process.env.LANGFUSE_FANOUT_ENABLED = 'true';
process.env.LANGFUSE_FANOUT_COLLECTOR_URL = 'http://collector:4318';
const { isLangfuseConnectionAvailable, usesLangfuseMultiTenantRouting } = await import(
'./policy'
);
expect(usesLangfuseMultiTenantRouting()).toBe(true);
expect(isLangfuseConnectionAvailable()).toBe(true);
});
it('hides fanout connection settings when tenant export is emergency-disabled', async () => {
process.env.LANGFUSE_FANOUT_ENABLED = 'true';
process.env.LANGFUSE_FANOUT_COLLECTOR_URL = 'http://collector:4318';
process.env.LANGFUSE_FANOUT_TENANT_EXPORT_DISABLED = 'true';
const { isLangfuseConnectionAvailable, isLangfuseFanoutEnabled } = await import('./policy');
expect(isLangfuseFanoutEnabled()).toBe(true);
expect(isLangfuseConnectionAvailable()).toBe(false);
});
it('does not apply the fanout emergency switch to single-tenant connections', async () => {
process.env.LANGFUSE_FANOUT_TENANT_EXPORT_DISABLED = 'true';
const { isLangfuseConnectionAvailable } = await import('./policy');
expect(isLangfuseConnectionAvailable()).toBe(true);
});
it.each(['false', '0', 'no', 'off'])(
'hides settings when tracing is disabled with %s',
async (value) => {
process.env.LANGFUSE_TRACING_ENABLED = value;
const { isLangfuseConnectionAvailable } = await import('./policy');
expect(isLangfuseConnectionAvailable()).toBe(false);
},
);
it('hides settings when the sample rate is zero', async () => {
process.env.LANGFUSE_SAMPLE_RATE = '0';
const { isLangfuseConnectionAvailable } = await import('./policy');
expect(isLangfuseConnectionAvailable()).toBe(false);
});
it('samples traces deterministically at fractional sample rates', async () => {
process.env.LANGFUSE_SAMPLE_RATE = '0.5';
const { isLangfuseTraceSampled } = await import('./policy');
expect(isLangfuseTraceSampled('86d413435f8b0d7f32d4d010ce769e2e')).toBe(true);
expect(isLangfuseTraceSampled('658f74b0a232417fc3e6e4d9ef5f563a')).toBe(false);
});
it('clamps numeric sample rates and preserves tracing for invalid values', async () => {
const { getLangfuseSampleRate } = await import('./policy');
process.env.LANGFUSE_SAMPLE_RATE = '-1';
expect(getLangfuseSampleRate()).toBe(0);
process.env.LANGFUSE_SAMPLE_RATE = '2';
expect(getLangfuseSampleRate()).toBe(1);
process.env.LANGFUSE_SAMPLE_RATE = 'invalid';
expect(getLangfuseSampleRate()).toBe(1);
});
it('hides Langfuse prompt sync by default', async () => {
const { isLangfusePromptSyncAvailable } = await import('./policy');
expect(isLangfusePromptSyncAvailable()).toBe(false);
});
it('makes Langfuse prompt sync available when the environment switch is on', async () => {
process.env.LANGFUSE_PROMPT_SYNC_AVAILABLE = 'true';
const { isLangfusePromptSyncAvailable } = await import('./policy');
expect(isLangfusePromptSyncAvailable()).toBe(true);
});
it('hides Langfuse prompt sync when the environment switch is explicitly off', async () => {
process.env.LANGFUSE_PROMPT_SYNC_AVAILABLE = 'false';
const { isLangfusePromptSyncAvailable } = await import('./policy');
expect(isLangfusePromptSyncAvailable()).toBe(false);
});
it('defaults the Langfuse prompt sync timeout to 10 seconds', async () => {
const { getLangfusePromptSyncTimeoutMs } = await import('./policy');
expect(getLangfusePromptSyncTimeoutMs()).toBe(10000);
});
it('uses a configured Langfuse prompt sync timeout', async () => {
process.env.LANGFUSE_PROMPT_SYNC_TIMEOUT_MS = '5000';
const { getLangfusePromptSyncTimeoutMs } = await import('./policy');
expect(getLangfusePromptSyncTimeoutMs()).toBe(5000);
});
it('clamps the Langfuse prompt sync timeout to 1000-60000', async () => {
const { getLangfusePromptSyncTimeoutMs } = await import('./policy');
process.env.LANGFUSE_PROMPT_SYNC_TIMEOUT_MS = '1';
expect(getLangfusePromptSyncTimeoutMs()).toBe(1000);
process.env.LANGFUSE_PROMPT_SYNC_TIMEOUT_MS = '1000000';
expect(getLangfusePromptSyncTimeoutMs()).toBe(60000);
});
it('falls back to the default Langfuse prompt sync timeout for non-numeric values', async () => {
process.env.LANGFUSE_PROMPT_SYNC_TIMEOUT_MS = 'invalid';
const { getLangfusePromptSyncTimeoutMs } = await import('./policy');
expect(getLangfusePromptSyncTimeoutMs()).toBe(10000);
});
it('defaults the Langfuse prompt sync lock lease to 300000ms when unset', async () => {
const { getLangfusePromptSyncLockLeaseMs } = await import('./policy');
expect(getLangfusePromptSyncLockLeaseMs(undefined)).toBe(300000);
expect(getLangfusePromptSyncLockLeaseMs(langfuseAppConfig({}))).toBe(300000);
});
it('uses a configured Langfuse prompt sync lock lease', async () => {
const { getLangfusePromptSyncLockLeaseMs } = await import('./policy');
expect(getLangfusePromptSyncLockLeaseMs(langfuseAppConfig({ lockLeaseMs: 120000 }))).toBe(
120000,
);
});
it('clamps the Langfuse prompt sync lock lease to 60000-3600000', async () => {
const { getLangfusePromptSyncLockLeaseMs } = await import('./policy');
expect(getLangfusePromptSyncLockLeaseMs(langfuseAppConfig({ lockLeaseMs: 1 }))).toBe(60000);
expect(getLangfusePromptSyncLockLeaseMs(langfuseAppConfig({ lockLeaseMs: 10000000 }))).toBe(
3600000,
);
});
it('defaults the Langfuse prompt sync page cap to 50 when unset', async () => {
const { getLangfusePromptSyncMaxPages } = await import('./policy');
expect(getLangfusePromptSyncMaxPages(undefined)).toBe(50);
expect(getLangfusePromptSyncMaxPages(langfuseAppConfig({}))).toBe(50);
});
it('uses a configured Langfuse prompt sync page cap', async () => {
const { getLangfusePromptSyncMaxPages } = await import('./policy');
expect(getLangfusePromptSyncMaxPages(langfuseAppConfig({ maxPages: 5 }))).toBe(5);
});
it('clamps the Langfuse prompt sync page cap to 1-1000', async () => {
const { getLangfusePromptSyncMaxPages } = await import('./policy');
expect(getLangfusePromptSyncMaxPages(langfuseAppConfig({ maxPages: 0 }))).toBe(1);
expect(getLangfusePromptSyncMaxPages(langfuseAppConfig({ maxPages: 100000 }))).toBe(1000);
});
});
describe('Langfuse settings availability', () => {
beforeEach(clearEnv);
afterEach(clearEnv);
it.each([
['environment credentials', { LANGFUSE_PUBLIC_KEY: 'pk-env', LANGFUSE_SECRET_KEY: 'sk-env' }],
['tracing disabled', { LANGFUSE_TRACING_ENABLED: 'false' }],
['zero sampling', { LANGFUSE_SAMPLE_RATE: '0' }],
['strict tenants without fanout', { TENANT_ISOLATION_STRICT: 'true' }],
[
'tenant export disabled',
{
LANGFUSE_FANOUT_ENABLED: 'true',
LANGFUSE_FANOUT_COLLECTOR_URL: 'http://collector:4318',
LANGFUSE_FANOUT_TENANT_EXPORT_DISABLED: 'true',
},
],
])('offers prompt settings with %s without enabling connection editing', async (_mode, env) => {
Object.assign(process.env, env);
const { isLangfuseSettingsAvailable, isLangfuseConnectionAvailable } = await import('./policy');
expect(isLangfuseSettingsAvailable()).toBe(false);
process.env.LANGFUSE_PROMPT_SYNC_AVAILABLE = 'true';
expect(isLangfuseSettingsAvailable()).toBe(true);
expect(isLangfuseConnectionAvailable()).toBe(false);
});
it('offers connection settings while prompt sync is unavailable', async () => {
const { isLangfuseSettingsAvailable, isLangfusePromptSyncAvailable } = await import('./policy');
expect(isLangfuseSettingsAvailable()).toBe(true);
expect(isLangfusePromptSyncAvailable()).toBe(false);
});
});