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
🧪 test: Restore Two Rotted Integration Suites and Run Every One in CI (#15866)
Danny Avilafb1322401d69
diff --git a/.github/workflows/agents-integration-tests.yml b/.github/workflows/agents-integration-tests.ymlindex 102e7db995..f015ee618a 100644--- a/.github/workflows/agents-integration-tests.yml+++ b/.github/workflows/agents-integration-tests.yml@@ -1,9 +1,12 @@-name: Agents Integration Tests--# Runs the packages/api `src/agents/**` integration specs (e.g. the durable HITL-# checkpointer and cross-replica subagent delivery against real MongoDB and Redis). These-# are `*.integration.spec.ts`, which `test:ci` deliberately excludes — without this-# job they run nowhere and their regressions guard nothing.+name: Integration Tests++# Runs every packages/api `*.integration.spec.ts` / `*.integration.test.ts` suite (e.g. the+# durable HITL checkpointer and cross-replica subagent delivery against real MongoDB and+# Redis, the admin config secret registry against a real Config collection, MCP flows+# against in-process servers). `test:ci` deliberately excludes them, and the Redis-backed+# `*.cache_integration` / `*.stream_integration` suites run in cache-integration-tests.yml —+# without this job they run nowhere and their regressions guard nothing. Selection is by+# suffix, not folder, so a suite added anywhere under src is picked up.on:pull_request:branches:@@ -11,9 +14,9 @@ on:- dev- dev-staging- release/*- # The suite builds and consumes data-provider and data-schemas and imports+ # The suites build and consume data-provider and data-schemas and import# across packages/api (the build-cache keys below hash all three src trees),- # so it must re-run on any of them — not just src/agents.+ # so they must re-run on any of them.paths:- 'packages/api/src/**'- 'packages/api/package.json'@@ -106,9 +109,9 @@ jobs:if: steps.cache-api.outputs.cache-hit != 'true'run: npm run build:api- - name: Run agents integration tests+ - name: Run integration testsworking-directory: packages/apienv:NODE_ENV: testREDIS_URI: redis://127.0.0.1:6379- run: npm run test:agents-integration+ run: npm run test:integrationdiff --git a/packages/api/package.json b/packages/api/package.jsonindex 51e60b61c2..7306a75a55 100644--- a/packages/api/package.json+++ b/packages/api/package.json@@ -33,11 +33,12 @@"build:watch:prod": "tsdown --watch","test": "jest --coverage --watch --testPathIgnorePatterns=\"\\.*integration\\.|\\.*helper\\.|__tests__/helpers/|\\.*manual\\.spec\\.\"","test:ci": "jest --coverage --ci --testPathIgnorePatterns=\"\\.*integration\\.|\\.*helper\\.|__tests__/helpers/|\\.*manual\\.spec\\.\"",- "test:cache-integration:core": "jest --testPathPatterns=\"src/cache/.*\\.cache_integration\\.spec\\.ts$\" --coverage=false",- "test:cache-integration:cluster": "jest --testPathPatterns=\"src/cluster/.*\\.cache_integration\\.spec\\.ts$\" --coverage=false --runInBand",- "test:cache-integration:mcp": "jest --testPathPatterns=\"src/mcp/.*\\.cache_integration\\.spec\\.ts$\" --coverage=false",- "test:cache-integration:stream": "jest --testPathPatterns=\"src/stream/.*\\.stream_integration\\.spec\\.ts$\" --coverage=false --runInBand --forceExit",+ "test:cache-integration:core": "jest --testPathPatterns=\"src/(cache|middleware)/.*\\.cache_integration\\.(spec|test)\\.ts$\" --coverage=false",+ "test:cache-integration:cluster": "jest --testPathPatterns=\"src/cluster/.*\\.cache_integration\\.(spec|test)\\.ts$\" --coverage=false --runInBand",+ "test:cache-integration:mcp": "jest --testPathPatterns=\"src/mcp/.*\\.cache_integration\\.(spec|test)\\.ts$\" --coverage=false",+ "test:cache-integration:stream": "jest --testPathPatterns=\"\\.stream_integration\\.(spec|test)\\.ts$\" --coverage=false --runInBand --forceExit","test:cache-integration": "npm run test:cache-integration:core && npm run test:cache-integration:cluster && npm run test:cache-integration:mcp && npm run test:cache-integration:stream",+ "test:integration": "jest --testPathPatterns=\"\\.integration\\.(spec|test)\\.ts$\" --coverage=false --runInBand --forceExit","test:s3-integration": "jest --testPathPatterns=\"src/storage/s3/.*\\.integration\\.spec\\.ts$\" --coverage=false --runInBand","test:agents-integration": "jest --testPathPatterns=\"src/agents/.*\\.integration\\.spec\\.ts$\" --coverage=false --runInBand --forceExit","verify": "npm run test:ci",diff --git a/packages/api/src/admin/secrets.integration.spec.ts b/packages/api/src/admin/secrets.integration.spec.tsindex 7b4a1ec2c2..b1297bb187 100644--- a/packages/api/src/admin/secrets.integration.spec.ts+++ b/packages/api/src/admin/secrets.integration.spec.ts@@ -1,5 +1,7 @@import mongoose from 'mongoose';import { MongoMemoryServer } from 'mongodb-memory-server';+import { PrincipalModel, PrincipalType } from 'librechat-data-provider';+import type { Config } from '@librechat/data-schemas';import type { Response } from 'express';import type { ServerRequest } from '~/types/http';@@ -8,12 +10,16 @@ process.env.CREDS_KEY =process.env.CREDS_IV = process.env.CREDS_IV ?? '0123456789abcdef0123456789abcdef';type DataSchemas = typeof import('@librechat/data-schemas');+type ConfigMethods = ReturnType<DataSchemas['createMethods']>;type AdminConfigHandlers = ReturnType<typeof import('./config').createAdminConfigHandlers>;let mongoServer: MongoMemoryServer;let handlers: AdminConfigHandlers;+let basePrincipalId: string;let decryptV3: DataSchemas['decryptV3'];+let patchConfigFields: ConfigMethods['patchConfigFields'];let getSecretPreview: typeof import('./secrets').getSecretPreview;+let encryptConfigSecretFields: typeof import('./secrets').encryptConfigSecretFields;interface SecretFieldCase {/** Dot-path of the secret field */@@ -30,15 +36,11 @@ interface SecretFieldCase {const SECRET = 'sk-super-secret-literal';+/**+ * Secrets written through the generic config API. `langfuse.secretKey` is absent because only the+ * dedicated Langfuse connection API writes that section; the generic API strips it.+ */const SECRET_FIELD_CASES: SecretFieldCase[] = [- {- path: 'langfuse.secretKey',- previewPath: 'langfuse.secretKeyPreview',- section: 'langfuse',- object: { publicKey: 'pk-lf-1', secretKey: SECRET },- siblingPath: 'langfuse.publicKey',- siblingValue: 'pk-lf-2',- },{path: 'ocr.apiKey',previewPath: 'ocr.apiKeyPreview',@@ -213,11 +215,17 @@ function getAtPath(root: unknown, path: string): unknown {return cursor;}-async function readRawOverrides(principalId: string): Promise<Record<string, unknown>> {+type RawConfig = Pick<Config, 'configVersion'> & { overrides: Record<string, unknown> };++async function readRawConfig(principalId: string): Promise<RawConfig> {const doc = await mongoose.models.Config.findOne({ principalId });expect(doc).not.toBeNull();expect(doc!.$isNew).toBe(false);- return (doc!.toObject() as { overrides: Record<string, unknown> }).overrides;+ return doc!.toObject() as RawConfig;+}++async function readRawOverrides(principalId: string): Promise<Record<string, unknown>> {+ return (await readRawConfig(principalId)).overrides;}let principalCounter = 0;@@ -229,19 +237,20 @@ function nextPrincipalId(): string {beforeAll(async () => {jest.resetModules();const dataSchemas = await import('@librechat/data-schemas');- ({ decryptV3 } = dataSchemas);+ ({ decryptV3, BASE_CONFIG_PRINCIPAL_ID: basePrincipalId } = dataSchemas);jest.spyOn(dataSchemas.logger, 'error').mockReturnValue(dataSchemas.logger);jest.spyOn(dataSchemas.logger, 'warn').mockReturnValue(dataSchemas.logger);jest.spyOn(dataSchemas.logger, 'info').mockReturnValue(dataSchemas.logger);jest.spyOn(dataSchemas.logger, 'debug').mockReturnValue(dataSchemas.logger);const { createAdminConfigHandlers } = await import('./config');- ({ getSecretPreview } = await import('./secrets'));+ ({ getSecretPreview, encryptConfigSecretFields } = await import('./secrets'));mongoServer = await MongoMemoryServer.create();await mongoose.connect(mongoServer.getUri());dataSchemas.createModels(mongoose);const methods = dataSchemas.createMethods(mongoose);+ ({ patchConfigFields } = methods);handlers = createAdminConfigHandlers({listAllConfigs: methods.listAllConfigs,@@ -491,6 +500,140 @@ describe('config secret registry — real handlers against a real Config collect},);+ describe('langfuse.secretKey (dedicated Langfuse connection API)', () => {+ type RefusedWrite = [+ string,+ 'patchConfigField' | 'tombstoneConfigField' | 'deleteConfigField',+ Record<string, unknown>,+ ];++ const secretPath = 'langfuse.secretKey';+ const previewPath = 'langfuse.secretKeyPreview';++ function baseReq(overrides: Record<string, unknown> = {}): ServerRequest {+ return mockReq({+ params: { principalType: 'role', principalId: basePrincipalId },+ ...overrides,+ });+ }++ /** Persists what the dedicated connection API writes, through the same shared secret helper. */+ async function seedLangfuseConnection(): Promise<RawConfig> {+ await mongoose.models.Config.deleteOne({ principalId: basePrincipalId });+ await patchConfigFields(+ PrincipalType.ROLE,+ basePrincipalId,+ PrincipalModel.ROLE,+ encryptConfigSecretFields({+ 'langfuse.enabled': true,+ 'langfuse.destination': 'eu',+ 'langfuse.publicKey': 'pk-lf-1',+ [secretPath]: SECRET,+ }),+ 10,+ );+ return readRawConfig(basePrincipalId);+ }++ it('keeps the stored secret encrypted at rest and redacts it from generic reads', async () => {+ const { overrides: stored } = await seedLangfuseConnection();+ expect(getAtPath(stored, secretPath)).toMatch(/^v3:/);+ expect(decryptV3(getAtPath(stored, secretPath) as string)).toBe(SECRET);+ expect(getAtPath(stored, previewPath)).toBe(getSecretPreview(SECRET));++ const getRes = mockRes();+ await handlers.getConfig(baseReq(), getRes);+ expect(getRes.statusCode).toBe(200);+ expect(JSON.stringify(getRes.body)).not.toContain(SECRET);+ expect(JSON.stringify(getRes.body)).not.toContain('v3:');+ const overrides = (getRes.body!.config as { overrides: Record<string, unknown> }).overrides;+ expect(getAtPath(overrides, secretPath)).toBeUndefined();+ expect(getAtPath(overrides, previewPath)).toBe(getSecretPreview(SECRET));+ expect(getAtPath(overrides, 'langfuse.publicKey')).toBe('pk-lf-1');++ const listRes = mockRes();+ await handlers.listConfigs(mockReq(), listRes);+ expect(listRes.statusCode).toBe(200);+ expect(JSON.stringify(listRes.body)).not.toContain(SECRET);+ expect(JSON.stringify(listRes.body)).not.toContain('v3:');+ });++ it.each<RefusedWrite>([+ [+ 'a dotted patch that replaces it',+ 'patchConfigField',+ { body: { entries: [{ fieldPath: secretPath, value: 'sk-lf-replacement' }] } },+ ],+ [+ 'a dotted patch that clears it',+ 'patchConfigField',+ { body: { entries: [{ fieldPath: secretPath, value: '' }] } },+ ],+ ['a field tombstone', 'tombstoneConfigField', { body: { fieldPath: secretPath } }],+ ['a field delete', 'deleteConfigField', { query: { fieldPath: secretPath } }],+ ])('ignores %s without writing the base config', async (_label, handler, request) => {+ const before = await seedLangfuseConnection();+ const res = mockRes();+ await handlers[handler](baseReq(request), res);+ expect(res.statusCode).toBe(200);++ const after = await readRawConfig(basePrincipalId);+ expect(after.configVersion).toBe(before.configVersion);+ expect(after.overrides).toEqual(before.overrides);+ });++ it('carries the stored secret through a full base-config replacement', async () => {+ const before = await seedLangfuseConnection();+ const res = mockRes();+ await handlers.upsertConfigOverrides(+ baseReq({+ body: {+ overrides: {+ interface: { modelSelect: false },+ langfuse: {+ enabled: false,+ publicKey: 'pk-lf-caller',+ secretKey: 'sk-lf-replacement',+ },+ },+ },+ }),+ res,+ );+ expect(res.statusCode).toBe(200);+ expect(JSON.stringify(res.body)).not.toContain(SECRET);++ const after = await readRawConfig(basePrincipalId);+ expect(after.configVersion).toBe(before.configVersion + 1);+ expect(getAtPath(after.overrides, 'interface.modelSelect')).toBe(false);+ expect(after.overrides.langfuse).toEqual(before.overrides.langfuse);+ });++ it('creates no role config from a Langfuse-only generic write', async () => {+ const principalId = nextPrincipalId();+ const patchRes = mockRes();+ await handlers.patchConfigField(+ mockReq({+ params: { principalType: 'role', principalId },+ body: { entries: [{ fieldPath: secretPath, value: SECRET }] },+ }),+ patchRes,+ );+ const upsertRes = mockRes();+ await handlers.upsertConfigOverrides(+ mockReq({+ params: { principalType: 'role', principalId },+ body: { overrides: { langfuse: { publicKey: 'pk-lf-1', secretKey: SECRET } } },+ }),+ upsertRes,+ );++ expect(patchRes.statusCode).toBe(200);+ expect(upsertRes.statusCode).toBe(200);+ expect(await mongoose.models.Config.exists({ principalId })).toBeNull();+ });+ });+describe.each(PLACEHOLDER_CASES)('$path env placeholder', ({ path, placeholder }) => {it('stores and returns `${ENV_VAR}` references without encryption or redaction', async () => {const principalId = nextPrincipalId();diff --git a/packages/api/src/mcp/registry/__tests__/MCPReinitRecovery.integration.test.ts b/packages/api/src/mcp/registry/__tests__/MCPReinitRecovery.integration.test.tsindex cd21502432..6c7cca6393 100644--- a/packages/api/src/mcp/registry/__tests__/MCPReinitRecovery.integration.test.ts+++ b/packages/api/src/mcp/registry/__tests__/MCPReinitRecovery.integration.test.ts@@ -36,6 +36,7 @@ import { MCPConnection } from '~/mcp/connection';import { MCPManager } from '~/mcp/MCPManager';jest.mock('@librechat/data-schemas', () => ({+ ...jest.requireActual<typeof import('@librechat/data-schemas')>('@librechat/data-schemas'),logger: {info: jest.fn(),warn: jest.fn(),@@ -107,6 +108,22 @@ async function safeDisconnect(conn: MCPConnection | null): Promise<void> {await conn.disconnect();}+function makeUser(): IUser {+ return {+ _id: new Types.ObjectId(),+ id: new Types.ObjectId().toString(),+ username: 'testuser',+ email: '[email protected]',+ name: 'Test',+ avatar: '',+ provider: 'email',+ role: 'user',+ emailVerified: true,+ createdAt: new Date(),+ updatedAt: new Date(),+ } as IUser;+}+function getFreePort(): Promise<number> {return new Promise((resolve, reject) => {const srv = net.createServer();@@ -137,6 +154,12 @@ interface TestServer {close: () => Promise<void>;}+interface ReinitOutcome {+ success: boolean;+ /** Tool count from a complete snapshot; `null` when the snapshot was incomplete */+ tools: number | null;+}+async function createMCPServerOnPort(port: number): Promise<TestServer> {const sessions = new Map<string, StreamableHTTPServerTransport>();@@ -396,26 +419,15 @@ describe('MCP reinitialize recovery – integration (issue #12143)', () => {server = await createMCPServerOnPort(deadPort);const flowManager = new FlowStateManager<null>(new Keyv(), { ttl: 60_000 });- const makeUser = (): IUser =>- ({- _id: new Types.ObjectId(),- id: new Types.ObjectId().toString(),- username: 'testuser',- email: '[email protected]',- name: 'Test',- avatar: '',- provider: 'email',- role: 'user',- emailVerified: true,- createdAt: new Date(),- updatedAt: new Date(),- }) as IUser;/**- * Replicate reinitMCPServer logic: check inspectionFailed → reinspect → getConnection.- * Each call uses a distinct user to simulate concurrent requests from different users.+ * Replicate reinitMCPServer logic: check inspectionFailed → reinspect → getConnection →+ * tools snapshot. Each call uses a distinct user to simulate concurrent requests from+ * different users. Concurrent reinspections can each succeed, and a later one replaces the+ * app connection an earlier call was handed; that call's snapshot is incomplete, which+ * reinitMCPServer answers by keeping the cached tools, reported here as `tools: null`.*/- async function simulateReinitMCPServer(): Promise<{ success: boolean; tools: number }> {+ async function simulateReinitMCPServer(): Promise<ReinitOutcome> {const user = makeUser();const config = await registry.getServerConfig(serverName, user.id);if (config?.inspectionFailed) {@@ -435,8 +447,8 @@ describe('MCP reinitialize recovery – integration (issue #12143)', () => {forceNew: true,});- const tools = await connection.fetchTools();- return { success: true, tools: tools.length };+ const snapshot = await connection.fetchToolsSnapshot();+ return { success: true, tools: snapshot.complete ? snapshot.tools.length : null };}const n = 3 + Math.floor(Math.random() * 5); // 3–7 concurrent calls@@ -449,14 +461,16 @@ describe('MCP reinitialize recovery – integration (issue #12143)', () => {expect(r.status).toBe('fulfilled');}- const values = (results as PromiseFulfilledResult<{ success: boolean; tools: number }>[]).map(- (r) => r.value,- );+ const values = (results as PromiseFulfilledResult<ReinitOutcome>[]).map((r) => r.value);// At least one full reinit must succeed with toolsconst succeeded = values.filter((v) => v.success);expect(succeeded.length).toBeGreaterThanOrEqual(1);- for (const s of succeeded) {++ // A connection created after the last reinspection is never replaced, so one snapshot completes+ const listed = succeeded.filter((v) => v.tools !== null);+ expect(listed.length).toBeGreaterThanOrEqual(1);+ for (const s of listed) {expect(s.tools).toBe(2);}@@ -471,6 +485,38 @@ describe('MCP reinitialize recovery – integration (issue #12143)', () => {expect(finalConfig!.tools).toContain('echo');});+ it('reports an incomplete tool snapshot when a newer config replaces the held app connection', async () => {+ const deadPort = await getFreePort();+ const serverName = 'replaced-connection';+ (MCPManager as unknown as { instance: null }).instance = null;+ await MCPManager.createInstance({+ [serverName]: { type: 'streamable-http', url: `http://127.0.0.1:${deadPort}/` },+ });+ const mcpManager = MCPManager.getInstance();+ server = await createMCPServerOnPort(deadPort);+ const flowManager = new FlowStateManager<null>(new Keyv(), { ttl: 60_000 });++ const firstUser = makeUser();+ await registry.reinspectServer(serverName, 'CACHE', firstUser.id);+ const held = await mcpManager.getConnection({ serverName, user: firstUser, flowManager });++ // What another replica's reinspection or an admin edit does: store a newer config+ await registry.updateServer(serverName, { type: 'streamable-http', url: server.url }, 'CACHE');+ const replacement = await mcpManager.getConnection({+ serverName,+ user: makeUser(),+ flowManager,+ });+ expect(replacement).not.toBe(held);++ // reinitMCPServer keeps cached tools for an incomplete snapshot; a complete empty one would+ // publish an empty catalog+ await expect(held.fetchToolsSnapshot()).resolves.toMatchObject({ complete: false, tools: [] });+ const current = await replacement.fetchToolsSnapshot();+ expect(current.complete).toBe(true);+ expect(current.tools.map((tool) => tool.name).sort()).toEqual(['echo', 'greet']);+ });+it('reinspectServer should throw MCPInspectionFailedError when the server is still unreachable', async () => {const deadPort = await getFreePort();const configs: t.MCPServers = {