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 React from 'react';
import { Provider } from 'jotai';
import { QueryKeys } from 'librechat-data-provider';
import { act, renderHook, waitFor } from '@testing-library/react';
import { QueryClient, QueryClientProvider, QueryObserver } from '@tanstack/react-query';
import type { MCPServersResponse, MCPReinitializeResponse } from 'librechat-data-provider';
import { useMCPServerManager } from '../useMCPServerManager';
const mockOpenInNewTab = jest.fn();
jest.mock('~/utils', () => ({ openInNewTab: (...args: unknown[]) => mockOpenInNewTab(...args) }));
const mockShowToast = jest.fn();
const mockSetMCPValues = jest.fn();
const mockReinitialize = jest.fn();
const mockUseMCPToolsQuery = jest.fn((_options?: unknown): { data?: MCPServersResponse } => ({
data: undefined,
}));
const mockUseMCPConnectionStatus = jest.fn((_options?: unknown) => ({ connectionStatus: {} }));
jest.mock('@librechat/client', () => ({
useToastContext: () => ({ showToast: mockShowToast }),
}));
jest.mock('~/hooks', () => ({
useLocalize: () => (key: string) => key,
useHasAccess: () => true,
useCatalogReady: () => true,
useMCPSelect: () => ({ mcpValues: [], setMCPValues: mockSetMCPValues }),
useMCPConnectionStatus: (options: unknown) => mockUseMCPConnectionStatus(options),
}));
jest.mock('~/data-provider', () => ({
useGetStartupConfig: () => ({ data: {} }),
useMCPServersQuery: () => ({ data: {}, isLoading: false }),
useMCPToolsQuery: (options: unknown) => mockUseMCPToolsQuery(options),
}));
jest.mock('librechat-data-provider/react-query', () => ({
useReinitializeMCPServerMutation: () => ({ mutateAsync: mockReinitialize }),
useCancelMCPOAuthMutation: () => ({}),
useUpdateUserPluginsMutation: () => ({}),
useGetAllEffectivePermissionsQuery: () => ({ data: {} }),
}));
function deferred<T>() {
let resolve!: (value: T) => void;
let reject!: (reason: Error) => void;
const promise = new Promise<T>((resolvePromise, rejectPromise) => {
resolve = resolvePromise;
reject = rejectPromise;
});
return { promise, resolve, reject };
}
describe('useMCPServerManager initialization', () => {
it.each(['response', 'http'] as const)(
'clears the spinner after a transient %s failure and lets retry succeed without OAuth',
async (failure) => {
mockReinitialize.mockReset();
mockSetMCPValues.mockClear();
mockShowToast.mockClear();
mockOpenInNewTab.mockClear();
const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
const wrapper = ({ children }: { children: React.ReactNode }) => (
<Provider>
<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
</Provider>
);
const { result, unmount } = renderHook(() => useMCPServerManager(), { wrapper });
const consoleError = jest.spyOn(console, 'error').mockImplementation(() => undefined);
try {
if (failure === 'http') {
mockReinitialize.mockRejectedValueOnce(new Error('Service temporarily unavailable'));
} else {
mockReinitialize.mockResolvedValueOnce({
success: false,
serverName: 'test-server',
oauthRequired: false,
failureReason: 'initialization_failed',
});
}
await act(async () => {
await result.current.initializeServer('test-server');
});
expect(result.current.isInitializing('test-server')).toBe(false);
expect(result.current.isCancellable('test-server')).toBe(false);
expect(mockOpenInNewTab).not.toHaveBeenCalled();
expect(mockSetMCPValues).not.toHaveBeenCalled();
expect(mockShowToast).toHaveBeenLastCalledWith({
message: 'com_ui_mcp_init_failed',
status: 'error',
});
mockReinitialize.mockResolvedValueOnce({
success: true,
serverName: 'test-server',
oauthRequired: false,
});
await act(async () => {
await result.current.initializeServer('test-server');
});
expect(mockReinitialize).toHaveBeenCalledTimes(2);
expect(result.current.isInitializing('test-server')).toBe(false);
expect(mockOpenInNewTab).not.toHaveBeenCalled();
expect(mockSetMCPValues).toHaveBeenCalledWith(['test-server']);
expect(mockShowToast).toHaveBeenLastCalledWith({
message: 'com_ui_mcp_initialized_success',
status: 'success',
});
} finally {
consoleError.mockRestore();
unmount();
queryClient.clear();
}
},
);
it('keeps passive authorization observers opt-in for shared hook callers', () => {
const queryClient = new QueryClient();
const wrapper = ({ children }: { children: React.ReactNode }) => (
<Provider>
<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
</Provider>
);
const { unmount } = renderHook(() => useMCPServerManager(), { wrapper });
expect(mockUseMCPToolsQuery).toHaveBeenLastCalledWith({ enabled: false });
expect(mockUseMCPConnectionStatus).toHaveBeenLastCalledWith({ enabled: false });
unmount();
queryClient.clear();
});
it.each(['success', 'error'])(
'finishes before a slow catalog refetch ends in %s',
async (outcome) => {
const connection = deferred<MCPReinitializeResponse>();
const catalog = deferred<string[]>();
mockReinitialize.mockReturnValue(connection.promise);
const queryClient = new QueryClient({
defaultOptions: { queries: { retry: false, cacheTime: 0 } },
logger: { log: console.log, warn: console.warn, error: jest.fn() },
});
const catalogQuery = new QueryObserver(queryClient, {
queryKey: [QueryKeys.mcpTools],
queryFn: () => catalog.promise,
initialData: [],
staleTime: Infinity,
});
const unsubscribe = catalogQuery.subscribe(() => undefined);
const invalidate = jest.spyOn(queryClient, 'invalidateQueries');
const wrapper = ({ children }: { children: React.ReactNode }) => (
<Provider>
<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
</Provider>
);
const { result, unmount } = renderHook(() => useMCPServerManager(), { wrapper });
const initialized = jest.fn();
try {
act(() => {
void result.current.initializeServer('test-server').then(initialized);
});
expect(result.current.isInitializing('test-server')).toBe(true);
expect(mockShowToast).not.toHaveBeenCalled();
const response = { success: true, message: 'Connected', serverName: 'test-server' };
await act(async () => {
connection.resolve(response);
});
expect(queryClient.getQueryState([QueryKeys.mcpTools])?.fetchStatus).toBe('fetching');
expect(result.current.isInitializing('test-server')).toBe(false);
expect(initialized).toHaveBeenCalledWith(response);
expect(mockSetMCPValues).toHaveBeenCalledWith(['test-server']);
expect(mockShowToast).toHaveBeenCalledWith({
message: 'com_ui_mcp_initialized_success',
status: 'success',
});
for (const key of [
QueryKeys.mcpServers,
QueryKeys.mcpTools,
QueryKeys.mcpAuthValues,
QueryKeys.mcpConnectionStatus,
]) {
expect(invalidate).toHaveBeenCalledWith([key]);
}
await act(async () => {
if (outcome === 'error') {
catalog.reject(new Error('Catalog unavailable'));
} else {
catalog.resolve(['test-tool']);
}
});
await waitFor(() => {
expect(queryClient.getQueryState([QueryKeys.mcpTools])?.fetchStatus).toBe('idle');
});
expect(result.current.isInitializing('test-server')).toBe(false);
expect(mockShowToast).toHaveBeenCalledTimes(1);
} finally {
catalog.resolve([]);
unmount();
unsubscribe();
queryClient.clear();
}
},
);
it('keeps a server this browser is authorizing connecting when rediscovery outdates a cached connection', async () => {
jest.useFakeTimers();
const serverName = 'clickhouse';
/** Stored tokens the server rejects: status reports a durable connection, discovery a reauth. */
const connectionStatus = {
[serverName]: {
requiresOAuth: true,
connectionState: 'connected',
authorizationState: 'authorized',
authorizationGeneration: 'generation-1',
},
};
const catalog = (authorizationGeneration: string) => ({
data: {
servers: {
[serverName]: {
name: serverName,
icon: '',
authenticated: false,
authorizationState: 'reauth_required' as const,
authorizationGeneration,
authConfig: [],
tools: [],
},
},
},
});
mockUseMCPConnectionStatus.mockImplementation(() => ({ connectionStatus }));
mockUseMCPToolsQuery.mockImplementation(() => catalog('generation-1'));
mockReinitialize.mockReset();
mockReinitialize.mockResolvedValueOnce({
success: true,
serverName,
oauthRequired: true,
oauthUrl: 'https://auth.example.test/authorize',
flowId: `user:${serverName}`,
});
const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
const wrapper = ({ children }: { children: React.ReactNode }) => (
<Provider>
<QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
</Provider>
);
const { result, rerender, unmount } = renderHook(() => useMCPServerManager(), { wrapper });
try {
expect(result.current.connectionStatus?.[serverName]?.connectionState).toBe('disconnected');
await act(async () => {
await result.current.initializeServer(serverName, false);
});
/** Reinitialize refetches the catalog, which reports a newer generation than cached status. */
mockUseMCPToolsQuery.mockImplementation(() => catalog('generation-2'));
rerender();
expect(result.current.connectionStatus?.[serverName]).toMatchObject({
connectionState: 'connecting',
authorizationState: 'authorizing',
});
expect(result.current.getServerStatusIconProps(serverName)).toMatchObject({
isInitializing: true,
canCancel: true,
});
} finally {
unmount();
queryClient.clear();
jest.clearAllTimers();
jest.useRealTimers();
mockUseMCPConnectionStatus.mockImplementation(() => ({ connectionStatus: {} }));
mockUseMCPToolsQuery.mockImplementation(() => ({ data: undefined }));
}
});
});