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

24.2 KB
Raw Blame
import { Types } from 'mongoose';
import {
  AuthType,
  AgentCapabilities,
  EModelEndpoint,
  PrincipalType,
  defaultAgentCapabilities,
} from 'librechat-data-provider';

import type { AppConfig, IConfig } from '@librechat/data-schemas';
import type { AppConfigServiceDeps } from '~/app/service';
import type { EndpointsConfigDeps } from './endpoints';
import type { ServerRequest } from '~/types';

import { createEndpointsConfigService } from './endpoints';
import { createAppConfigService } from '~/app/service';

function appConfig(partial: Record<string, unknown>): AppConfig {
  return partial as unknown as AppConfig;
}

function configDoc(partial: Record<string, unknown>): IConfig {
  return partial as unknown as IConfig;
}

function createAppConfigCache() {
  const store = new Map<string, unknown>();
  return {
    get: jest.fn((key: string) => Promise.resolve(store.get(key))),
    set: jest.fn((key: string, value: unknown) => {
      store.set(key, value);
      return Promise.resolve(undefined);
    }),
    delete: jest.fn((key: string) => {
      store.delete(key);
      return Promise.resolve(true);
    }),
  };
}

type ConfigPrincipals = NonNullable<Parameters<AppConfigServiceDeps['getApplicableConfigs']>[0]>;

function createMockDeps(overrides: Partial<EndpointsConfigDeps> = {}): EndpointsConfigDeps {
  return {
    getAppConfig: jest.fn().mockResolvedValue(appConfig({ endpoints: {} })),
    loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
      [EModelEndpoint.openAI]: { userProvide: false, order: 0 },
    }),
    loadCustomEndpointsConfig: jest.fn().mockReturnValue(undefined),
    ...overrides,
  };
}

type TestRequestOverrides = {
  body?: Partial<ServerRequest['body']>;
  config?: AppConfig;
  user?: { id?: string; role?: string; tenantId?: string };
};

function fakeReq(overrides: TestRequestOverrides = {}): ServerRequest {
  return { user: { id: 'u1', role: 'USER' }, ...overrides } as ServerRequest;
}

describe('createEndpointsConfigService', () => {
  describe('getEndpointsConfig', () => {
    it('merges default and custom endpoints', async () => {
      const deps = createMockDeps({
        loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
          [EModelEndpoint.openAI]: { userProvide: false, order: 0 },
        }),
        loadCustomEndpointsConfig: jest.fn().mockReturnValue({
          myCustom: { userProvide: true },
        }),
      });
      const { getEndpointsConfig } = createEndpointsConfigService(deps);
      const result = await getEndpointsConfig(fakeReq());

      expect(result?.[EModelEndpoint.openAI]).toBeDefined();
      expect(result?.myCustom).toBeDefined();
    });

    it('adds azureOpenAI when configured', async () => {
      const deps = createMockDeps({
        getAppConfig: jest.fn().mockResolvedValue(
          appConfig({
            endpoints: { [EModelEndpoint.azureOpenAI]: { modelNames: ['gpt-4'] } },
          }),
        ),
      });
      const { getEndpointsConfig } = createEndpointsConfigService(deps);
      const result = await getEndpointsConfig(fakeReq());

      expect(result?.[EModelEndpoint.azureOpenAI]).toEqual(
        expect.objectContaining({ userProvide: false }),
      );
    });

    it('adds azureAssistants when azure has assistants config', async () => {
      const deps = createMockDeps({
        getAppConfig: jest.fn().mockResolvedValue(
          appConfig({
            endpoints: { [EModelEndpoint.azureOpenAI]: { assistants: true } },
          }),
        ),
      });
      const { getEndpointsConfig } = createEndpointsConfigService(deps);
      const result = await getEndpointsConfig(fakeReq());

      expect(result?.[EModelEndpoint.azureAssistants]).toEqual(
        expect.objectContaining({ userProvide: false }),
      );
    });

    it('enables anthropic when vertex AI is configured', async () => {
      const deps = createMockDeps({
        getAppConfig: jest.fn().mockResolvedValue(
          appConfig({
            endpoints: { [EModelEndpoint.anthropic]: { vertexConfig: { enabled: true } } },
          }),
        ),
      });
      const { getEndpointsConfig } = createEndpointsConfigService(deps);
      const result = await getEndpointsConfig(fakeReq());

      expect(result?.[EModelEndpoint.anthropic]).toEqual(
        expect.objectContaining({ userProvide: false }),
      );
    });

    it('merges assistants config with version coercion', async () => {
      const deps = createMockDeps({
        loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
          [EModelEndpoint.assistants]: { userProvide: false, order: 0 },
        }),
        getAppConfig: jest.fn().mockResolvedValue(
          appConfig({
            endpoints: {
              [EModelEndpoint.assistants]: {
                disableBuilder: true,
                capabilities: [AgentCapabilities.execute_code],
                version: 2,
              },
            },
          }),
        ),
      });
      const { getEndpointsConfig } = createEndpointsConfigService(deps);
      const result = await getEndpointsConfig(fakeReq());
      const assistants = result?.[EModelEndpoint.assistants];

      expect(assistants?.version).toBe('2');
      expect(assistants?.disableBuilder).toBe(true);
      expect(assistants?.capabilities).toEqual([AgentCapabilities.execute_code]);
    });

    it('merges agents config with allowedProviders', async () => {
      const deps = createMockDeps({
        loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
          [EModelEndpoint.agents]: { userProvide: false, order: 0 },
        }),
        getAppConfig: jest.fn().mockResolvedValue(
          appConfig({
            endpoints: {
              [EModelEndpoint.agents]: {
                allowedProviders: ['openAI', 'anthropic'],
                capabilities: [AgentCapabilities.execute_code],
                maxSubagents: 20,
              },
            },
          }),
        ),
      });
      const { getEndpointsConfig } = createEndpointsConfigService(deps);
      const result = await getEndpointsConfig(fakeReq());

      expect(result?.[EModelEndpoint.agents]?.allowedProviders).toEqual(['openAI', 'anthropic']);
      expect(result?.[EModelEndpoint.agents]?.maxSubagents).toBe(20);
    });

    it.each([true, false])(
      'exposes file sharing policy to the agent builder when enabled=%s',
      async (enabled) => {
        const fileSharing = {
          enabled,
          allowSiblingSharing: false,
          maxFiles: 100,
          ttlMs: 3_600_000,
        };
        const deps = createMockDeps({
          loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
            [EModelEndpoint.agents]: { userProvide: false, order: 0 },
          }),
          getAppConfig: jest
            .fn()
            .mockResolvedValue(
              appConfig({ endpoints: { [EModelEndpoint.agents]: { fileSharing } } }),
            ),
        });
        const { getEndpointsConfig } = createEndpointsConfigService(deps);
        const result = await getEndpointsConfig(fakeReq());

        expect(result?.[EModelEndpoint.agents]?.fileSharing).toEqual(fileSharing);
      },
    );

    describe('linkedInstructions.langfuse.enabled', () => {
      it('defaults to false when omitted from the agents config', async () => {
        const deps = createMockDeps({
          loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
            [EModelEndpoint.agents]: { userProvide: false, order: 0 },
          }),
          getAppConfig: jest
            .fn()
            .mockResolvedValue(appConfig({ endpoints: { [EModelEndpoint.agents]: {} } })),
        });
        const { getEndpointsConfig } = createEndpointsConfigService(deps);
        const result = await getEndpointsConfig(fakeReq());

        expect(result?.[EModelEndpoint.agents]?.linkedInstructions).toEqual({
          langfuse: { enabled: false },
        });
      });

      it.each([true, false])(
        'copies the switch through as configured (enabled=%s)',
        async (enabled) => {
          const deps = createMockDeps({
            loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
              [EModelEndpoint.agents]: { userProvide: false, order: 0 },
            }),
            getAppConfig: jest.fn().mockResolvedValue(
              appConfig({
                endpoints: {
                  [EModelEndpoint.agents]: {
                    linkedInstructions: {
                      timeoutMs: 5_000,
                      native: { cacheTtlMs: 60_000 },
                      langfuse: { enabled },
                    },
                  },
                },
              }),
            ),
          });
          const { getEndpointsConfig } = createEndpointsConfigService(deps);
          const result = await getEndpointsConfig(fakeReq());

          expect(result?.[EModelEndpoint.agents]?.linkedInstructions).toEqual({
            langfuse: { enabled },
          });
        },
      );
    });

    it('exposes the deployment stateful environment allowlist', async () => {
      const deps = createMockDeps({
        loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
          [EModelEndpoint.agents]: { userProvide: false, order: 0 },
        }),
        getAppConfig: jest.fn().mockResolvedValue(
          appConfig({
            endpoints: {
              [EModelEndpoint.agents]: {
                toolApproval: { enabled: false },
                statefulCodeSessions: {
                  allowedEnvironments: ['user', 'agent-user'],
                  environments: [
                    {
                      id: 'attached-vm',
                      name: 'Attached VM',
                      type: 'attached',
                      baseURL: 'https://internal-code.example.com/v1',
                      workerId: 'private-worker-route',
                      pairing: {
                        workerId: 'private-worker-route',
                        tokenEnv: 'CODE_BRIDGE_ADMIN_TOKEN',
                      },
                      configSchema: {
                        permissions: {
                          commandExecution: { allowed: ['ask', 'deny'], default: 'ask' },
                        },
                      },
                      default: true,
                    },
                  ],
                },
              },
            },
          }),
        ),
      });
      const { getEndpointsConfig } = createEndpointsConfigService(deps);

      const result = await getEndpointsConfig(fakeReq());

      expect(result?.[EModelEndpoint.agents]?.statefulCodeSessions).toEqual({
        allowedEnvironments: ['user', 'agent-user'],
        allowEnvironmentSelection: true,
        maxEnvironmentChoices: 32,
        approvalsEnabled: false,
        approvalModes: [],
        environments: [
          {
            id: 'attached-vm',
            name: 'Attached VM',
            type: 'attached',
            default: true,
            configSchema: {
              permissions: {
                commandExecution: { allowed: ['ask', 'deny'], default: 'ask' },
              },
            },
          },
        ],
      });
    });

    it('does not expose a pairing-only control plane as an execution environment', async () => {
      const deps = createMockDeps({
        loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
          [EModelEndpoint.agents]: { userProvide: false, order: 0 },
        }),
        getAppConfig: jest.fn().mockResolvedValue(
          appConfig({
            endpoints: {
              [EModelEndpoint.agents]: {
                statefulCodeSessions: {
                  allowedEnvironments: ['user'],
                  environments: [
                    {
                      id: 'self-service',
                      name: 'Self-service',
                      type: 'attached',
                      baseURL: 'https://internal-code.example.com/v1',
                      pairing: {
                        allowPrincipalWorkers: true,
                        tokenEnv: 'CODE_BRIDGE_ADMIN_TOKEN',
                      },
                    },
                  ],
                },
              },
            },
          }),
        ),
      });
      const { getEndpointsConfig } = createEndpointsConfigService(deps);

      const result = await getEndpointsConfig(fakeReq());

      expect(result?.[EModelEndpoint.agents]?.statefulCodeSessions).toEqual({
        allowedEnvironments: ['user'],
        allowEnvironmentSelection: true,
        maxEnvironmentChoices: 32,
        approvalsEnabled: true,
        approvalModes: ['ask', 'acceptEdits', 'fullAccess'],
        environments: [],
      });
    });

    it.each([
      [undefined, true],
      [true, true],
      [false, undefined],
    ])(
      'advertises machine selection unless the deployment turns it off (configured: %p)',
      async (allowEnvironmentSelection, advertised) => {
        const deps = createMockDeps({
          loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
            [EModelEndpoint.agents]: { userProvide: false, order: 0 },
          }),
          getAppConfig: jest.fn().mockResolvedValue(
            appConfig({
              endpoints: {
                [EModelEndpoint.agents]: {
                  statefulCodeSessions: {
                    ...(allowEnvironmentSelection === undefined
                      ? {}
                      : { allowEnvironmentSelection }),
                  },
                },
              },
            }),
          ),
        });
        const { getEndpointsConfig } = createEndpointsConfigService(deps);
        const result = await getEndpointsConfig(fakeReq());
        const advertisedConfig = result?.[EModelEndpoint.agents]?.statefulCodeSessions;
        expect(advertisedConfig?.allowEnvironmentSelection).toBe(advertised);
        expect(advertisedConfig?.maxEnvironmentChoices).toBe(advertised ? 32 : undefined);
      },
    );

    it('does not advertise machine selection when the decision protocol is off', async () => {
      process.env.CODE_ENVIRONMENT_DECISION_VERSION = '0';
      try {
        const deps = createMockDeps({
          loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
            [EModelEndpoint.agents]: { userProvide: false, order: 0 },
          }),
          getAppConfig: jest.fn().mockResolvedValue(
            appConfig({
              endpoints: { [EModelEndpoint.agents]: { statefulCodeSessions: {} } },
            }),
          ),
        });
        const { getEndpointsConfig } = createEndpointsConfigService(deps);
        const result = await getEndpointsConfig(fakeReq());
        expect(
          result?.[EModelEndpoint.agents]?.statefulCodeSessions?.allowEnvironmentSelection,
        ).toBeUndefined();
      } finally {
        delete process.env.CODE_ENVIRONMENT_DECISION_VERSION;
      }
    });

    it.each([
      [{ enabled: true }, ['ask']],
      [{ enabled: true, mode: 'default' }, ['ask']],
      [{ enabled: true, mode: 'dontAsk' }, ['ask']],
      [{ enabled: true, mode: 'bypass' }, ['ask', 'acceptEdits', 'fullAccess']],
    ])('exposes approval modes allowed by endpoint policy %p', async (toolApproval, expected) => {
      const deps = createMockDeps({
        loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
          [EModelEndpoint.agents]: { userProvide: false, order: 0 },
        }),
        getAppConfig: jest.fn().mockResolvedValue(
          appConfig({
            endpoints: {
              [EModelEndpoint.agents]: {
                toolApproval,
                statefulCodeSessions: {
                  allowedEnvironments: ['user'],
                  environments: [],
                },
              },
            },
          }),
        ),
      });
      const { getEndpointsConfig } = createEndpointsConfigService(deps);

      const result = await getEndpointsConfig(fakeReq());

      expect(result?.[EModelEndpoint.agents]?.statefulCodeSessions?.approvalModes).toEqual(
        expected,
      );
    });

    it('merges bedrock availableRegions', async () => {
      const deps = createMockDeps({
        loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
          [EModelEndpoint.bedrock]: { userProvide: false, order: 0 },
        }),
        getAppConfig: jest.fn().mockResolvedValue(
          appConfig({
            endpoints: {
              [EModelEndpoint.bedrock]: { availableRegions: ['us-east-1', 'eu-west-1'] },
            },
          }),
        ),
      });
      const { getEndpointsConfig } = createEndpointsConfigService(deps);
      const result = await getEndpointsConfig(fakeReq());

      expect(result?.[EModelEndpoint.bedrock]?.availableRegions).toEqual([
        'us-east-1',
        'eu-west-1',
      ]);
    });

    it('exposes Bedrock user-provided credential options', async () => {
      const previousEnv = {
        BEDROCK_AWS_ACCESS_KEY_ID: process.env.BEDROCK_AWS_ACCESS_KEY_ID,
        BEDROCK_AWS_SECRET_ACCESS_KEY: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY,
        BEDROCK_AWS_SESSION_TOKEN: process.env.BEDROCK_AWS_SESSION_TOKEN,
        BEDROCK_AWS_BEARER_TOKEN: process.env.BEDROCK_AWS_BEARER_TOKEN,
      };

      process.env.BEDROCK_AWS_ACCESS_KEY_ID = AuthType.USER_PROVIDED;
      process.env.BEDROCK_AWS_SECRET_ACCESS_KEY = AuthType.USER_PROVIDED;
      process.env.BEDROCK_AWS_SESSION_TOKEN = AuthType.USER_PROVIDED;
      process.env.BEDROCK_AWS_BEARER_TOKEN = AuthType.USER_PROVIDED;

      try {
        const deps = createMockDeps({
          loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
            [EModelEndpoint.bedrock]: { userProvide: false, order: 0 },
          }),
        });
        const { getEndpointsConfig } = createEndpointsConfigService(deps);
        const result = await getEndpointsConfig(fakeReq());

        expect(result?.[EModelEndpoint.bedrock]).toEqual(
          expect.objectContaining({
            userProvideAccessKeyId: true,
            userProvideSecretAccessKey: true,
            userProvideSessionToken: true,
            userProvideBearerToken: true,
          }),
        );
      } finally {
        Object.entries(previousEnv).forEach(([key, value]) => {
          if (value == null) {
            delete process.env[key];
          } else {
            process.env[key] = value;
          }
        });
      }
    });

    it('uses req.config when available instead of calling getAppConfig', async () => {
      const mockGetAppConfig = jest.fn();
      const deps = createMockDeps({ getAppConfig: mockGetAppConfig });
      const { getEndpointsConfig } = createEndpointsConfigService(deps);

      await getEndpointsConfig(fakeReq({ config: appConfig({ endpoints: {} }) }));

      expect(mockGetAppConfig).not.toHaveBeenCalled();
    });

    it('passes userId when resolving scoped endpoint config', async () => {
      const mockGetAppConfig = jest.fn().mockResolvedValue(appConfig({ endpoints: {} }));
      const deps = createMockDeps({ getAppConfig: mockGetAppConfig });
      const { getEndpointsConfig } = createEndpointsConfigService(deps);

      await getEndpointsConfig(fakeReq({ user: { id: 'u1', role: 'USER', tenantId: 'tenant-a' } }));

      expect(mockGetAppConfig).toHaveBeenCalledWith({
        role: 'USER',
        userId: 'u1',
        idOnTheSource: undefined,
        tenantId: 'tenant-a',
      });
    });

    /** Endpoints a grouped user gets from a group override that references `${FOO_KEY}`/`${FOO_URL}`. */
    async function getGroupScopedEndpoints(overrideEnvAllowlist?: string) {
      const groupId = new Types.ObjectId('6a0aea2172e2d59d4658c9d2');
      const getUserPrincipals = jest.fn().mockResolvedValue([
        { principalType: PrincipalType.ROLE, principalId: 'USER' },
        { principalType: PrincipalType.USER, principalId: 'u1' },
        { principalType: PrincipalType.GROUP, principalId: groupId },
      ]);
      const getApplicableConfigs = jest.fn((principals: ConfigPrincipals = []) =>
        Promise.resolve(
          principals.some(
            (principal) =>
              principal.principalType === PrincipalType.GROUP &&
              String(principal.principalId) === groupId.toString(),
          )
            ? [
                configDoc({
                  principalType: PrincipalType.GROUP,
                  principalId: groupId,
                  priority: 20,
                  isActive: true,
                  overrides: {
                    endpoints: {
                      custom: [
                        {
                          name: 'FOO',
                          apiKey: '${FOO_KEY}',
                          baseURL: '${FOO_URL}',
                          models: { default: ['foo-model'], fetch: true },
                        },
                      ],
                    },
                  },
                }),
              ]
            : [],
        ),
      );
      const { getAppConfig } = createAppConfigService({
        loadBaseConfig: jest.fn().mockResolvedValue(appConfig({ endpoints: {} })),
        setCachedTools: jest.fn().mockResolvedValue(undefined),
        getCache: jest.fn().mockReturnValue(createAppConfigCache()),
        cacheKeys: { APP_CONFIG: 'app_config' },
        getApplicableConfigs,
        getUserPrincipals,
        overrideEnvAllowlist,
      });
      const { getEndpointsConfig } = createEndpointsConfigService({
        getAppConfig,
        loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({}),
      });

      const result = await getEndpointsConfig(fakeReq({ user: { id: 'u1', role: 'USER' } }));

      expect(getUserPrincipals).toHaveBeenCalledWith({
        userId: 'u1',
        role: 'USER',
      });
      expect(getApplicableConfigs).toHaveBeenCalledWith(
        expect.arrayContaining([
          expect.objectContaining({ principalType: PrincipalType.GROUP, principalId: groupId }),
        ]),
      );
      return result;
    }

    it('exposes custom endpoints from group-scoped overrides for grouped users', async () => {
      const result = await getGroupScopedEndpoints('FOO_KEY,FOO_URL');
      expect(result?.FOO).toEqual(expect.objectContaining({ type: EModelEndpoint.custom }));
    });

    it('treats env references outside the override allowlist as missing', async () => {
      const result = await getGroupScopedEndpoints();
      expect(result?.FOO).toBeUndefined();
    });
  });

  describe('checkCapability', () => {
    it('returns true when agents endpoint has the requested capability', async () => {
      const deps = createMockDeps({
        loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
          [EModelEndpoint.agents]: { userProvide: false, order: 0 },
        }),
        getAppConfig: jest.fn().mockResolvedValue(
          appConfig({
            endpoints: {
              [EModelEndpoint.agents]: {
                capabilities: [AgentCapabilities.execute_code],
              },
            },
          }),
        ),
      });
      const { checkCapability } = createEndpointsConfigService(deps);

      const result = await checkCapability(
        fakeReq({ body: { endpoint: EModelEndpoint.agents } }),
        AgentCapabilities.execute_code,
      );

      expect(result).toBe(true);
    });

    it('returns false when agents endpoint lacks the requested capability', async () => {
      const deps = createMockDeps({
        loadDefaultEndpointsConfig: jest.fn().mockResolvedValue({
          [EModelEndpoint.agents]: { userProvide: false, order: 0 },
        }),
        getAppConfig: jest.fn().mockResolvedValue(
          appConfig({
            endpoints: {
              [EModelEndpoint.agents]: {
                capabilities: [AgentCapabilities.execute_code],
              },
            },
          }),
        ),
      });
      const { checkCapability } = createEndpointsConfigService(deps);

      const result = await checkCapability(
        fakeReq({ body: { endpoint: EModelEndpoint.agents } }),
        AgentCapabilities.file_search,
      );

      expect(result).toBe(false);
    });

    it('falls back to defaultAgentCapabilities for non-agents endpoints', async () => {
      const deps = createMockDeps();
      const { checkCapability } = createEndpointsConfigService(deps);

      const result = await checkCapability(
        fakeReq({ body: { endpoint: EModelEndpoint.openAI } }),
        defaultAgentCapabilities[0],
      );

      expect(result).toBe(true);
    });
  });
});

describe('defaultAgentCapabilities', () => {
  it('includes AgentCapabilities.skills so skills are enabled by default', () => {
    expect(defaultAgentCapabilities).toContain(AgentCapabilities.skills);
  });
});