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
👻 fix: Phantom MCP Tool Calls (#9634)
Dustin Healy52b65492d5e8
diff --git a/client/src/hooks/MCP/__tests__/useMCPSelect.test.tsx b/client/src/hooks/MCP/__tests__/useMCPSelect.test.tsxnew file mode 100644index 0000000000..b562b77d86--- /dev/null+++ b/client/src/hooks/MCP/__tests__/useMCPSelect.test.tsx@@ -0,0 +1,495 @@+import React from 'react';+import { Provider, createStore } from 'jotai';+import { renderHook, act, waitFor } from '@testing-library/react';+import { RecoilRoot, useRecoilState, useRecoilValue, useSetRecoilState } from 'recoil';+import { Constants, LocalStorageKeys } from 'librechat-data-provider';+import { ephemeralAgentByConvoId } from '~/store';+import { setTimestamp } from '~/utils/timestamps';+import { useMCPSelect } from '../useMCPSelect';++// Mock dependencies+jest.mock('~/utils/timestamps', () => ({+ setTimestamp: jest.fn(),+}));++jest.mock('lodash/isEqual', () => jest.fn((a, b) => JSON.stringify(a) === JSON.stringify(b)));++const createWrapper = () => {+ // Create a new Jotai store for each test to ensure clean state+ const store = createStore();++ const Wrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => (+ <RecoilRoot>+ <Provider store={store}>{children}</Provider>+ </RecoilRoot>+ );+ return Wrapper;+};++describe('useMCPSelect', () => {+ beforeEach(() => {+ jest.clearAllMocks();+ localStorage.clear();+ });++ describe('Basic Functionality', () => {+ it('should initialize with default values', () => {+ const { result } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ expect(result.current.mcpValues).toEqual([]);+ expect(result.current.isPinned).toBe(true); // Default value from mcpPinnedAtom is true+ expect(typeof result.current.setMCPValues).toBe('function');+ expect(typeof result.current.setIsPinned).toBe('function');+ });++ it('should use conversationId when provided', () => {+ const conversationId = 'test-convo-123';+ const { result } = renderHook(() => useMCPSelect({ conversationId }), {+ wrapper: createWrapper(),+ });++ expect(result.current.mcpValues).toEqual([]);+ });++ it('should use NEW_CONVO constant when conversationId is null', () => {+ const { result } = renderHook(() => useMCPSelect({ conversationId: null }), {+ wrapper: createWrapper(),+ });++ expect(result.current.mcpValues).toEqual([]);+ });+ });++ describe('State Updates', () => {+ it('should update mcpValues when setMCPValues is called', async () => {+ const { result } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ const newValues = ['value1', 'value2'];++ act(() => {+ result.current.setMCPValues(newValues);+ });++ await waitFor(() => {+ expect(result.current.mcpValues).toEqual(newValues);+ });+ });++ it('should not update mcpValues if non-array is passed', () => {+ const { result } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ act(() => {+ // @ts-ignore - Testing invalid input+ result.current.setMCPValues('not-an-array');+ });++ expect(result.current.mcpValues).toEqual([]);+ });++ it('should update isPinned state', () => {+ const { result } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ // Default is true+ expect(result.current.isPinned).toBe(true);++ // Toggle to false+ act(() => {+ result.current.setIsPinned(false);+ });++ expect(result.current.isPinned).toBe(false);++ // Toggle back to true+ act(() => {+ result.current.setIsPinned(true);+ });++ expect(result.current.isPinned).toBe(true);+ });+ });++ describe('Timestamp Management', () => {+ it('should set timestamp when mcpValues is updated with values', async () => {+ const conversationId = 'test-convo';+ const { result } = renderHook(() => useMCPSelect({ conversationId }), {+ wrapper: createWrapper(),+ });++ const newValues = ['value1', 'value2'];++ act(() => {+ result.current.setMCPValues(newValues);+ });++ await waitFor(() => {+ const expectedKey = `${LocalStorageKeys.LAST_MCP_}${conversationId}`;+ expect(setTimestamp).toHaveBeenCalledWith(expectedKey);+ });+ });++ it('should not set timestamp when mcpValues is empty', async () => {+ const { result } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ act(() => {+ result.current.setMCPValues([]);+ });++ await waitFor(() => {+ expect(setTimestamp).not.toHaveBeenCalled();+ });+ });+ });++ describe('Race Conditions and Infinite Loops Prevention', () => {+ it('should not create infinite loop when syncing between Jotai and Recoil states', async () => {+ const { result, rerender } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ let renderCount = 0;+ const maxRenders = 10;++ // Track renders to detect infinite loops+ const trackRender = () => {+ renderCount++;+ if (renderCount > maxRenders) {+ throw new Error('Potential infinite loop detected');+ }+ };++ // Set initial value+ act(() => {+ trackRender();+ result.current.setMCPValues(['initial']);+ });++ // Trigger multiple rerenders+ for (let i = 0; i < 3; i++) {+ rerender();+ trackRender();+ }++ // Should not exceed max renders+ expect(renderCount).toBeLessThanOrEqual(maxRenders);+ });++ it('should handle rapid consecutive updates without race conditions', async () => {+ const { result } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ const updates = [+ ['value1'],+ ['value1', 'value2'],+ ['value1', 'value2', 'value3'],+ ['value4'],+ [],+ ];++ // Rapid fire updates+ act(() => {+ updates.forEach((update) => {+ result.current.setMCPValues(update);+ });+ });++ await waitFor(() => {+ // Should settle on the last update+ expect(result.current.mcpValues).toEqual([]);+ });+ });++ it('should maintain stable setter function reference', () => {+ const { result, rerender } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ const firstSetMCPValues = result.current.setMCPValues;++ // Trigger multiple rerenders+ rerender();+ rerender();+ rerender();++ // Setter should remain the same reference (memoized)+ expect(result.current.setMCPValues).toBe(firstSetMCPValues);+ });++ it('should handle switching conversation IDs without issues', async () => {+ const { result, rerender } = renderHook(+ ({ conversationId }) => useMCPSelect({ conversationId }),+ {+ wrapper: createWrapper(),+ initialProps: { conversationId: 'convo1' },+ },+ );++ // Set values for first conversation+ act(() => {+ result.current.setMCPValues(['convo1-value']);+ });++ await waitFor(() => {+ expect(result.current.mcpValues).toEqual(['convo1-value']);+ });++ // Switch to different conversation+ rerender({ conversationId: 'convo2' });++ // Should have different state for new conversation+ expect(result.current.mcpValues).toEqual([]);++ // Set values for second conversation+ act(() => {+ result.current.setMCPValues(['convo2-value']);+ });++ await waitFor(() => {+ expect(result.current.mcpValues).toEqual(['convo2-value']);+ });++ // Switch back to first conversation+ rerender({ conversationId: 'convo1' });++ // Should maintain separate state+ await waitFor(() => {+ expect(result.current.mcpValues).toEqual(['convo1-value']);+ });+ });+ });++ describe('Ephemeral Agent Synchronization', () => {+ it('should sync mcpValues when ephemeralAgent is updated externally', async () => {+ // Create a shared wrapper for both hooks to share the same Recoil/Jotai context+ const wrapper = createWrapper();++ // Create a component that uses both hooks to ensure they share state+ const TestComponent = () => {+ const mcpHook = useMCPSelect({});+ const [ephemeralAgent, setEphemeralAgent] = useRecoilState(+ ephemeralAgentByConvoId(Constants.NEW_CONVO),+ );+ return { mcpHook, ephemeralAgent, setEphemeralAgent };+ };++ const { result } = renderHook(() => TestComponent(), { wrapper });++ // Simulate external update to ephemeralAgent (e.g., from another component)+ const externalMcpValues = ['external-value1', 'external-value2'];+ act(() => {+ result.current.setEphemeralAgent({+ mcp: externalMcpValues,+ });+ });++ // The hook should sync with the external update+ await waitFor(() => {+ expect(result.current.mcpHook.mcpValues).toEqual(externalMcpValues);+ });+ });++ it('should update ephemeralAgent when mcpValues changes through hook', async () => {+ // Create a shared wrapper for both hooks+ const wrapper = createWrapper();++ // Create a component that uses both the hook and accesses Recoil state+ const TestComponent = () => {+ const mcpHook = useMCPSelect({});+ const ephemeralAgent = useRecoilValue(ephemeralAgentByConvoId(Constants.NEW_CONVO));+ return { mcpHook, ephemeralAgent };+ };++ const { result } = renderHook(() => TestComponent(), { wrapper });++ const newValues = ['hook-value1', 'hook-value2'];++ act(() => {+ result.current.mcpHook.setMCPValues(newValues);+ });++ // Verify both mcpValues and ephemeralAgent are updated+ await waitFor(() => {+ expect(result.current.mcpHook.mcpValues).toEqual(newValues);+ expect(result.current.ephemeralAgent?.mcp).toEqual(newValues);+ });+ });++ it('should handle empty ephemeralAgent.mcp array correctly', async () => {+ // Create a shared wrapper+ const wrapper = createWrapper();++ // Create a component that uses both hooks+ const TestComponent = () => {+ const mcpHook = useMCPSelect({});+ const setEphemeralAgent = useSetRecoilState(ephemeralAgentByConvoId(Constants.NEW_CONVO));+ return { mcpHook, setEphemeralAgent };+ };++ const { result } = renderHook(() => TestComponent(), { wrapper });++ // Set initial values+ act(() => {+ result.current.mcpHook.setMCPValues(['initial-value']);+ });++ await waitFor(() => {+ expect(result.current.mcpHook.mcpValues).toEqual(['initial-value']);+ });++ // Try to set empty array externally+ act(() => {+ result.current.setEphemeralAgent({+ mcp: [],+ });+ });++ // Values should remain unchanged since empty mcp array doesn't trigger update+ // (due to the condition: ephemeralAgent?.mcp && ephemeralAgent.mcp.length > 0)+ expect(result.current.mcpHook.mcpValues).toEqual(['initial-value']);+ });++ it('should properly sync non-empty arrays from ephemeralAgent', async () => {+ // Additional test to ensure non-empty arrays DO sync+ const wrapper = createWrapper();++ const TestComponent = () => {+ const mcpHook = useMCPSelect({});+ const setEphemeralAgent = useSetRecoilState(ephemeralAgentByConvoId(Constants.NEW_CONVO));+ return { mcpHook, setEphemeralAgent };+ };++ const { result } = renderHook(() => TestComponent(), { wrapper });++ // Set initial values through ephemeralAgent with non-empty array+ const initialValues = ['value1', 'value2'];+ act(() => {+ result.current.setEphemeralAgent({+ mcp: initialValues,+ });+ });++ // Should sync since it's non-empty+ await waitFor(() => {+ expect(result.current.mcpHook.mcpValues).toEqual(initialValues);+ });++ // Update with different non-empty values+ const updatedValues = ['value3', 'value4', 'value5'];+ act(() => {+ result.current.setEphemeralAgent({+ mcp: updatedValues,+ });+ });++ // Should sync the new values+ await waitFor(() => {+ expect(result.current.mcpHook.mcpValues).toEqual(updatedValues);+ });+ });+ });++ describe('Edge Cases', () => {+ it('should handle undefined conversationId', () => {+ const { result } = renderHook(() => useMCPSelect({ conversationId: undefined }), {+ wrapper: createWrapper(),+ });++ expect(result.current.mcpValues).toEqual([]);++ act(() => {+ result.current.setMCPValues(['test']);+ });++ expect(() => result.current).not.toThrow();+ });++ it('should handle empty string conversationId', () => {+ const { result } = renderHook(() => useMCPSelect({ conversationId: '' }), {+ wrapper: createWrapper(),+ });++ expect(result.current.mcpValues).toEqual([]);+ });++ it('should handle very large arrays without performance issues', async () => {+ const { result } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ const largeArray = Array.from({ length: 1000 }, (_, i) => `value-${i}`);++ const startTime = performance.now();++ act(() => {+ result.current.setMCPValues(largeArray);+ });++ const endTime = performance.now();+ const executionTime = endTime - startTime;++ // Should complete within reasonable time (< 100ms)+ expect(executionTime).toBeLessThan(100);++ await waitFor(() => {+ expect(result.current.mcpValues).toEqual(largeArray);+ });+ });++ it('should cleanup properly on unmount', () => {+ const { unmount } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ // Should unmount without errors+ expect(() => unmount()).not.toThrow();+ });+ });++ describe('Memory Leak Prevention', () => {+ it('should not leak memory on repeated updates', async () => {+ const { result } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ // Perform many updates to test for memory leaks+ for (let i = 0; i < 100; i++) {+ act(() => {+ result.current.setMCPValues([`value-${i}`]);+ });+ }++ // If we get here without crashing, memory management is likely OK+ expect(result.current.mcpValues).toEqual(['value-99']);+ });++ it('should handle component remounting', () => {+ const { result, unmount } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ act(() => {+ result.current.setMCPValues(['before-unmount']);+ });++ unmount();++ // Remount+ const { result: newResult } = renderHook(() => useMCPSelect({}), {+ wrapper: createWrapper(),+ });++ // Should handle remounting gracefully+ expect(newResult.current.mcpValues).toBeDefined();+ });+ });+});diff --git a/client/src/hooks/MCP/useMCPSelect.ts b/client/src/hooks/MCP/useMCPSelect.tsindex 92fe71a5fa..dc3ac869c9 100644--- a/client/src/hooks/MCP/useMCPSelect.ts+++ b/client/src/hooks/MCP/useMCPSelect.ts@@ -1,5 +1,6 @@import { useCallback, useEffect } from 'react';import { useAtom } from 'jotai';+import isEqual from 'lodash/isEqual';import { useRecoilState } from 'recoil';import { Constants, LocalStorageKeys } from 'librechat-data-provider';import { ephemeralAgentByConvoId, mcpValuesAtomFamily, mcpPinnedAtom } from '~/store';@@ -19,15 +20,14 @@ export function useMCPSelect({ conversationId }: { conversationId?: string | nul}}, [ephemeralAgent?.mcp, setMCPValuesRaw]);- // Update ephemeral agent when Jotai state changesuseEffect(() => {- if (mcpValues.length > 0 && JSON.stringify(mcpValues) !== JSON.stringify(ephemeralAgent?.mcp)) {- setEphemeralAgent((prev) => ({- ...prev,- mcp: mcpValues,- }));- }- }, [mcpValues, ephemeralAgent?.mcp, setEphemeralAgent]);+ setEphemeralAgent((prev) => {+ if (!isEqual(prev?.mcp, mcpValues)) {+ return { ...(prev ?? {}), mcp: mcpValues };+ }+ return prev;+ });+ }, [mcpValues, setEphemeralAgent]);useEffect(() => {const mcpStorageKey = `${LocalStorageKeys.LAST_MCP_}${key}`;