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 { MCPToolsChangedEvent } from './toolsChanged';
import type { ParsedServerConfig } from './types';
import {
setMCPToolsChangedHandler,
setMCPToolsChangedGenerationHandler,
setMCPToolsChangedGenerationRenewalHandler,
setMCPToolsChangedRevisionHandler,
getMCPToolsChangedGeneration,
renewMCPToolsChangedGeneration,
reserveMCPToolsChangedRevision,
cancelMCPToolsChanged,
notifyMCPToolsChanged,
getMCPAppToolsPublicationGeneration,
getMCPToolCatalogGeneration,
} from './toolsChanged';
const createEvent = (name = 'one'): MCPToolsChangedEvent => ({
serverName: 'dynamic',
serverConfig: { type: 'streamable-http', url: 'https://mcp.example.com' },
tools: [{ name, inputSchema: { type: 'object' } }],
});
describe('MCP tools-changed dispatch', () => {
afterEach(() => {
setMCPToolsChangedHandler(null);
setMCPToolsChangedGenerationHandler(null);
setMCPToolsChangedGenerationRenewalHandler(null);
setMCPToolsChangedRevisionHandler(null);
jest.useRealTimers();
});
it('derives stable app publication generations from connection-relevant config', () => {
const first: ParsedServerConfig = {
type: 'sse',
url: 'https://mcp.example.com/sse',
headers: { Authorization: 'Bearer token', Accept: 'text/event-stream' },
updatedAt: 1,
toolFunctions: {},
};
const equivalent: ParsedServerConfig = {
headers: { Accept: 'text/event-stream', Authorization: 'Bearer token' },
url: 'https://mcp.example.com/sse',
type: 'sse',
updatedAt: 2,
inspectionFailed: true,
};
const changed: ParsedServerConfig = {
...equivalent,
url: 'https://mcp.example.com/v2/sse',
};
expect(getMCPAppToolsPublicationGeneration(first)).toBe(
getMCPAppToolsPublicationGeneration(equivalent),
);
expect(getMCPAppToolsPublicationGeneration(first)).not.toBe(
getMCPAppToolsPublicationGeneration(changed),
);
});
it('keeps catalog headers and request overrides in the server identity', () => {
const declared: ParsedServerConfig = {
type: 'streamable-http',
url: 'https://mcp.example.com/mcp',
headers: { 'X-Workspace': 'catalog-1' },
requestHeaders: { 'X-Workspace': 'chat' },
};
const generation = getMCPAppToolsPublicationGeneration(declared);
expect(
getMCPAppToolsPublicationGeneration({
...declared,
headers: { 'X-Workspace': 'catalog-2' },
}),
).not.toBe(generation);
expect(
getMCPAppToolsPublicationGeneration({
...declared,
requestHeaders: { 'X-Workspace': 'chat-2' },
}),
).not.toBe(generation);
expect(
getMCPAppToolsPublicationGeneration({
...declared,
headers: { 'X-Workspace': 'chat' },
requestHeaders: undefined,
}),
).not.toBe(generation);
});
it('rotates the declared identity when a chat override of the catalog API key changes', () => {
const config: ParsedServerConfig = {
type: 'streamable-http',
url: 'https://mcp.example.com',
source: 'yaml',
apiKey: { source: 'admin', authorization_type: 'bearer', key: 'catalog' },
requestHeaders: { Authorization: 'Bearer chat-one' },
};
expect(getMCPAppToolsPublicationGeneration(config)).not.toBe(
getMCPAppToolsPublicationGeneration({
...config,
requestHeaders: { Authorization: 'Bearer chat-two' },
}),
);
});
it('includes request-header environment changes without mutating the declaration', () => {
const variable = 'MCP_REQUEST_HEADER_GENERATION_TEST';
const original = process.env[variable];
const config: ParsedServerConfig = {
type: 'streamable-http',
url: 'https://mcp.example.com',
source: 'yaml',
requestHeaders: { 'X-Workspace': `\${${variable}}` },
};
try {
process.env[variable] = 'first';
const first = getMCPAppToolsPublicationGeneration(config);
process.env[variable] = 'second';
expect(getMCPAppToolsPublicationGeneration(config)).not.toBe(first);
expect(config.requestHeaders).toEqual({ 'X-Workspace': `\${${variable}}` });
} finally {
if (original === undefined) {
delete process.env[variable];
} else {
process.env[variable] = original;
}
}
});
it('includes the resolved runtime environment in app publication generations', () => {
const variable = 'LIBRECHAT_MCP_CATALOG_ORIGIN_TEST';
const original = process.env[variable];
const config: ParsedServerConfig = {
type: 'streamable-http',
url: `\${${variable}}/mcp`,
};
try {
process.env[variable] = 'https://old.example.com';
const oldGeneration = getMCPAppToolsPublicationGeneration(config);
process.env[variable] = 'https://new.example.com';
const newGeneration = getMCPAppToolsPublicationGeneration(config);
expect(newGeneration).not.toBe(oldGeneration);
} finally {
if (original === undefined) {
delete process.env[variable];
} else {
process.env[variable] = original;
}
}
});
it('captures a connection-bound publication generation from the app layer', async () => {
const generationHandler = jest.fn().mockResolvedValue('generation-a');
setMCPToolsChangedGenerationHandler(generationHandler);
await expect(
getMCPToolsChangedGeneration({ userId: 'user-1', serverName: 'dynamic' }),
).resolves.toBe('generation-a');
expect(generationHandler).toHaveBeenCalledWith({
userId: 'user-1',
serverName: 'dynamic',
});
});
it('renews a current connection-bound publication generation through the app layer', async () => {
const renewalHandler = jest.fn().mockResolvedValue(true);
setMCPToolsChangedGenerationRenewalHandler(renewalHandler);
const scope = {
userId: 'user-1',
serverName: 'dynamic',
publicationGeneration: 'generation-a',
};
await expect(renewMCPToolsChangedGeneration(scope)).resolves.toBe(true);
expect(renewalHandler).toHaveBeenCalledWith(scope);
});
it('reserves app revisions by runtime config and skips user scopes', async () => {
const revisionHandler = jest.fn().mockResolvedValue('7');
const serverConfig: ParsedServerConfig = {
type: 'streamable-http',
url: 'https://mcp.example.com/mcp',
};
setMCPToolsChangedRevisionHandler(revisionHandler);
await expect(
reserveMCPToolsChangedRevision({ serverName: 'dynamic', serverConfig }),
).resolves.toBe('7');
await expect(
reserveMCPToolsChangedRevision({ serverName: 'dynamic', serverConfig, userId: 'user-1' }),
).resolves.toBeUndefined();
expect(revisionHandler).toHaveBeenCalledTimes(1);
expect(revisionHandler).toHaveBeenCalledWith({
serverName: 'dynamic',
configGeneration: getMCPToolCatalogGeneration(serverConfig),
});
});
it('passes a complete server snapshot and user scope to the handler', async () => {
const handler = jest.fn();
const event = { ...createEvent(), userId: 'user-1' };
setMCPToolsChangedHandler(handler);
await notifyMCPToolsChanged(event);
expect(handler).toHaveBeenCalledWith(event);
});
it('awaits an async handler before returning', async () => {
let finished = false;
setMCPToolsChangedHandler(async () => {
await Promise.resolve();
finished = true;
});
await notifyMCPToolsChanged(createEvent());
expect(finished).toBe(true);
});
it('coalesces an in-flight burst and publishes the newest snapshot last', async () => {
let releaseFirst: (() => void) | undefined;
const firstBlocked = new Promise<void>((resolve) => {
releaseFirst = resolve;
});
const published: string[] = [];
const handler = jest.fn(async (event: MCPToolsChangedEvent) => {
published.push(event.tools[0].name);
if (event.tools[0].name === 'one') {
await firstBlocked;
}
});
setMCPToolsChangedHandler(handler);
const first = notifyMCPToolsChanged(createEvent('one'));
await Promise.resolve();
const second = notifyMCPToolsChanged(createEvent('two'));
const third = notifyMCPToolsChanged(createEvent('three'));
releaseFirst?.();
await Promise.all([first, second, third]);
expect(published).toEqual(['one', 'three']);
});
it('retries a failed cache publication without rejecting the notification handler', async () => {
jest.useFakeTimers();
const handler = jest
.fn<Promise<void>, [MCPToolsChangedEvent]>()
.mockRejectedValueOnce(new Error('Redis down'))
.mockResolvedValue(undefined);
setMCPToolsChangedHandler(handler);
await expect(notifyMCPToolsChanged(createEvent())).resolves.toBeUndefined();
expect(handler).toHaveBeenCalledTimes(1);
await jest.advanceTimersByTimeAsync(250);
expect(handler).toHaveBeenCalledTimes(2);
});
it('stops dispatching when the handler is unregistered during an in-flight failure', async () => {
let rejectPublication: ((error: Error) => void) | undefined;
const publication = new Promise<void>((_, reject) => {
rejectPublication = reject;
});
const handler = jest.fn(() => publication);
setMCPToolsChangedHandler(handler);
const notification = notifyMCPToolsChanged(createEvent());
await Promise.resolve();
setMCPToolsChangedHandler(null);
rejectPublication?.(new Error('publisher shutting down'));
await expect(notification).resolves.toBeUndefined();
await Promise.resolve();
expect(handler).toHaveBeenCalledTimes(1);
});
it('cancels a queued retry before cache invalidation', async () => {
jest.useFakeTimers();
const handler = jest.fn().mockRejectedValue(new Error('Redis down'));
const event = { ...createEvent(), userId: 'user-1' };
setMCPToolsChangedHandler(handler);
await notifyMCPToolsChanged(event);
await cancelMCPToolsChanged(event);
await jest.advanceTimersByTimeAsync(30_000);
expect(handler).toHaveBeenCalledTimes(1);
});
it('drains an in-flight publication before disconnect returns', async () => {
let releasePublication: (() => void) | undefined;
const publication = new Promise<void>((resolve) => {
releasePublication = resolve;
});
const event = { ...createEvent(), userId: 'user-1' };
setMCPToolsChangedHandler(() => publication);
const notification = notifyMCPToolsChanged(event);
await Promise.resolve();
let drained = false;
const cancellation = cancelMCPToolsChanged(event).then(() => {
drained = true;
});
await Promise.resolve();
expect(drained).toBe(false);
releasePublication?.();
await Promise.all([notification, cancellation]);
expect(drained).toBe(true);
});
it('does nothing when no handler is registered', async () => {
await expect(notifyMCPToolsChanged(createEvent())).resolves.toBeUndefined();
});
});