Skip to content

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

18.6 KB
Raw Blame
import { getConfigDefaults, RetentionMode } from 'librechat-data-provider';
import type { TCustomConfig } from 'librechat-data-provider';
import type { AppConfig } from '~/types';
import { loadDefaultInterface, deriveSpecInterface } from './interface';

describe('loadDefaultInterface', () => {
  it('uses the schema default for URL auto-submit when not configured', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.autoSubmitFromUrl).toBe(true);
  });

  it('uses the schema default for code highlight throttling when not configured', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.codeHighlightThrottleMs).toBe(300);
  });

  it('preserves a configured code highlight throttle interval', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        codeHighlightThrottleMs: 100,
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.codeHighlightThrottleMs).toBe(100);
  });

  it('uses the schema default for the agent selector list cap when not configured', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.agentSelectorLimit).toBe(10);
  });

  it('forwards a configured agent selector list cap to the served interface', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        agentSelectorLimit: 4,
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.agentSelectorLimit).toBe(4);
  });

  it('uses and preserves the schema default for queued-turn reconciliation', async () => {
    const configDefaults = getConfigDefaults();
    const defaultInterface = await loadDefaultInterface({
      config: {},
      configDefaults,
    });
    expect(defaultInterface?.queuedTurnReconciliationTimeoutMs).toBe(60_000);

    const configuredInterface = await loadDefaultInterface({
      config: { interface: { queuedTurnReconciliationTimeoutMs: 180_000 } },
      configDefaults,
    });
    expect(configuredInterface?.queuedTurnReconciliationTimeoutMs).toBe(180_000);
  });

  it('allows the mascot by default and preserves an explicit opt-out', async () => {
    const configDefaults = getConfigDefaults();
    const defaultInterface = await loadDefaultInterface({ config: {}, configDefaults });
    expect(defaultInterface?.mascot).toBe(true);

    const disabledInterface = await loadDefaultInterface({
      config: { interface: { mascot: false } },
      configDefaults,
    });
    expect(disabledInterface?.mascot).toBe(false);
  });

  it('uses and preserves the schema default for the queued-send lock expiry', async () => {
    const configDefaults = getConfigDefaults();
    const defaultInterface = await loadDefaultInterface({
      config: {},
      configDefaults,
    });
    expect(defaultInterface?.queuedSendLockTimeoutMs).toBe(60_000);

    const configuredInterface = await loadDefaultInterface({
      config: { interface: { queuedSendLockTimeoutMs: 15_000 } },
      configDefaults,
    });
    expect(configuredInterface?.queuedSendLockTimeoutMs).toBe(15_000);
  });

  it('uses and preserves the schema default for the composer recent-files limit', async () => {
    const configDefaults = getConfigDefaults();
    const defaultInterface = await loadDefaultInterface({
      config: {},
      configDefaults,
    });
    expect(defaultInterface?.composerRecentFiles).toBe(5);

    const configuredInterface = await loadDefaultInterface({
      config: { interface: { composerRecentFiles: 10 } },
      configDefaults,
    });
    expect(configuredInterface?.composerRecentFiles).toBe(10);
  });

  it('uses and preserves the schema defaults for the client history cache', async () => {
    const configDefaults = getConfigDefaults();
    const defaultInterface = await loadDefaultInterface({
      config: {},
      configDefaults,
    });
    expect(defaultInterface?.historyCacheTtlMs).toBe(60_000);
    expect(defaultInterface?.historyCacheRecent).toBe(1);
    expect(defaultInterface?.historyCacheMaxBytes).toBe(8 * 1024 * 1024);

    const configuredInterface = await loadDefaultInterface({
      config: {
        interface: { historyCacheTtlMs: 0, historyCacheRecent: 3, historyCacheMaxBytes: 0 },
      },
      configDefaults,
    });
    expect(configuredInterface?.historyCacheTtlMs).toBe(0);
    expect(configuredInterface?.historyCacheRecent).toBe(3);
    expect(configuredInterface?.historyCacheMaxBytes).toBe(0);
  });

  it('uses and preserves the schema default for steer arm confirmation', async () => {
    const configDefaults = getConfigDefaults();
    const interfaceDefaults = {
      ...configDefaults.interface,
      steerArmConfirmationTimeoutMs: 10_000,
    };
    const defaults = { ...configDefaults, interface: interfaceDefaults };
    const defaultInterface = await loadDefaultInterface({
      config: {},
      configDefaults: defaults,
    });
    expect(defaultInterface?.steerArmConfirmationTimeoutMs).toBe(10_000);

    const configuredInterface = await loadDefaultInterface({
      config: { interface: { steerArmConfirmationTimeoutMs: 30_000 } },
      configDefaults: defaults,
    });
    expect(configuredInterface?.steerArmConfirmationTimeoutMs).toBe(30_000);
  });

  it('preserves disabled URL auto-submit config', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        autoSubmitFromUrl: false,
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.autoSubmitFromUrl).toBe(false);
  });

  it('keeps the colour-mode URL handoff off unless configured', async () => {
    const unset = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });
    const enabled = await loadDefaultInterface({
      config: { interface: { colorModeFromUrl: true } },
      configDefaults: getConfigDefaults(),
    });

    expect(unset?.colorModeFromUrl).toBe(false);
    expect(enabled?.colorModeFromUrl).toBe(true);
  });

  it('preserves a disabled build info flag', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        buildInfo: false,
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.buildInfo).toBe(false);
  });

  it('uses the schema default for build info when not configured', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.buildInfo).toBe(true);
  });

  it('carries a disabled artifact undocking flag to the clients', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        artifactUndocking: false,
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.artifactUndocking).toBe(false);
  });

  it('uses the schema default for artifact undocking when not configured', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.artifactUndocking).toBe(true);
  });

  it('carries a disabled analytics consent prompt to the clients', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: { interface: { analyticsConsent: false } },
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.analyticsConsent).toBe(false);
  });

  it('leaves analytics consent unset so clients keep asking', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig).not.toHaveProperty('analyticsConsent');
  });

  it('preserves enabled build info config', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        buildInfo: true,
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.buildInfo).toBe(true);
  });

  it('enables response feedback by default', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.feedback).toBe(true);
  });

  it('preserves a disabled response feedback flag', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        feedback: false,
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.feedback).toBe(false);
  });

  it('disables context cost by default', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.contextCost).toBe(false);
  });

  it('preserves a disabled context cost flag', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        contextCost: false,
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.contextCost).toBe(false);
  });

  it('preserves enabled context cost config', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        contextCost: true,
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.contextCost).toBe(true);
  });

  it('passes through a configured display currency', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        currency: { code: 'EUR', rate: 0.92 },
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.currency).toEqual({ code: 'EUR', rate: 0.92 });
  });

  it('omits currency when it is not configured', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.currency).toBeUndefined();
  });

  it('preserves enabled URL auto-submit config', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        autoSubmitFromUrl: true,
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.autoSubmitFromUrl).toBe(true);
  });

  it('preserves the configured chat retention periods', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        temporaryChatRetention: 24,
        generalChatRetention: 2160,
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.temporaryChatRetention).toBe(24);
    expect(interfaceConfig?.generalChatRetention).toBe(2160);
  });

  it('omits temporary chat retention when it is not explicitly configured', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig).not.toHaveProperty('temporaryChatRetention');
    expect(interfaceConfig).not.toHaveProperty('generalChatRetention');
  });

  it('preserves the configured agent file retention exemption', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        retentionMode: RetentionMode.ALL,
        retainAgentFiles: true,
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.retentionMode).toBe(RetentionMode.ALL);
    expect(interfaceConfig?.retainAgentFiles).toBe(true);
  });

  it('passes through configured default pinned tools', async () => {
    const config: Partial<TCustomConfig> = {
      interface: {
        defaultPinnedTools: ['artifacts', 'execute_code', 'mcp'],
      },
    };

    const interfaceConfig = await loadDefaultInterface({
      config,
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.defaultPinnedTools).toEqual(['artifacts', 'execute_code', 'mcp']);
  });

  it('omits default pinned tools when not explicitly configured', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig).not.toHaveProperty('defaultPinnedTools');
  });

  it('passes the trace viewer section through unchanged', async () => {
    const traceViewer = { enabled: true, showInputOutput: false, maxRecords: 200 };
    const interfaceConfig = await loadDefaultInterface({
      config: { interface: { traceViewer } },
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.traceViewer).toEqual(traceViewer);
  });

  it('leaves the trace viewer unset when not configured', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.traceViewer).toBeUndefined();
  });

  it('passes a bundled theme name through unchanged', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: { interface: { theme: 'clickhouse' } },
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.theme).toBe('clickhouse');
  });

  it('passes an inline theme definition through unchanged', async () => {
    const theme = {
      version: 1 as const,
      name: 'acme',
      modes: {
        light: { colors: { 'rgb-surface-primary': '255 255 255' } },
        dark: { appearance: { controlRadius: '0.25rem' } },
      },
    };
    const interfaceConfig = await loadDefaultInterface({
      config: { interface: { theme } },
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig?.theme).toEqual(theme);
  });

  it('leaves the theme unset when not configured', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });

    expect(interfaceConfig).not.toHaveProperty('theme');
  });
});

describe('running chat rename deployment fence', () => {
  it.each([
    [undefined, true],
    [false, false],
    [true, true],
  ])('resolves runningChatRename %s to %s', async (configured, expected) => {
    const configDefaults = getConfigDefaults();
    const interfaceConfig = await loadDefaultInterface({
      config: { interface: configured === undefined ? {} : { runningChatRename: configured } },
      configDefaults,
    });
    expect(interfaceConfig?.runningChatRename).toBe(expected);
  });
});

describe('welcome screen heading and footer', () => {
  it('keeps the entity heading and the full footer by default', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: {},
      configDefaults: getConfigDefaults(),
    });
    expect(interfaceConfig?.landingHeading).toBe('entity');
    expect(interfaceConfig?.landingFooter).toBe(true);
  });

  it('copies the configured settings through', async () => {
    const interfaceConfig = await loadDefaultInterface({
      config: { interface: { landingHeading: 'greeting', landingFooter: false } },
      configDefaults: getConfigDefaults(),
    });
    expect(interfaceConfig?.landingHeading).toBe('greeting');
    expect(interfaceConfig?.landingFooter).toBe(false);
  });
});

describe('deriveSpecInterface', () => {
  const defaults = getConfigDefaults().interface;
  const specs = (list: unknown[], addedEndpoints?: string[]) =>
    ({ list, ...(addedEndpoints && { addedEndpoints }) }) as AppConfig['modelSpecs'];
  const spec = { name: 's', label: 'S', preset: { endpoint: 'openAI' } };
  const served = { modelSelect: true, parameters: true, presets: true, prompts: true };

  it('turns the spec-dependent controls off for served specs, the selector kept for addedEndpoints', () => {
    expect(deriveSpecInterface(served, undefined, specs([spec]), { defaults })).toEqual({
      modelSelect: false,
      parameters: false,
      presets: false,
      prompts: true,
    });
    expect(
      deriveSpecInterface(served, undefined, specs([spec], ['openAI']), { defaults })?.modelSelect,
    ).toBe(true);
  });

  it('turns them back on when no spec is served, a control left unset included', () => {
    const off = { modelSelect: false, parameters: false };
    const on = {
      modelSelect: defaults.modelSelect,
      parameters: defaults.parameters,
      presets: defaults.presets,
    };
    expect(deriveSpecInterface(off, undefined, specs([]), { defaults })).toEqual(on);
    expect(deriveSpecInterface(off, undefined, undefined, { defaults })).toEqual(on);
  });

  it('keeps what librechat.yaml or an override sets, and derives only the fields asked for', () => {
    const explicit = { parameters: true, presets: false };
    expect(deriveSpecInterface(served, explicit, specs([spec]), { defaults })).toEqual({
      ...served,
      modelSelect: false,
      presets: false,
    });
    expect(
      deriveSpecInterface(served, undefined, specs([spec]), { defaults, fields: ['parameters'] }),
    ).toEqual({ ...served, parameters: false });
    const settled = { modelSelect: false, parameters: false, presets: false };
    expect(deriveSpecInterface(settled, undefined, specs([spec]), { defaults })).toBe(settled);
  });

  it('derives them into a config whose interface a layer tombstoned, where none would read as off', () => {
    expect(deriveSpecInterface(undefined, undefined, undefined, { defaults })).toEqual({
      modelSelect: defaults.modelSelect,
      parameters: defaults.parameters,
      presets: defaults.presets,
    });
    expect(
      deriveSpecInterface(undefined, { parameters: true }, specs([spec]), { defaults }),
    ).toEqual({ modelSelect: false, parameters: true, presets: false });
    expect(
      deriveSpecInterface(undefined, undefined, specs([spec]), { defaults, fields: ['presets'] }),
    ).toEqual({ presets: false });
    expect(deriveSpecInterface(undefined, undefined, undefined, { defaults, fields: [] })).toBe(
      undefined,
    );
  });
});