fix(mcp): keep last-known-good tools instead of flashing red on a transient failure

A connected server with cached tools was turning red 'Failed to discover' on a
single transient discovery probe blip, even though the stored status stayed
connected with tools — because useMcpToolsQuery dropped React Query's retained
data on error, and the row's showDiscoveryError fired over a populated server.

Now the aggregate keeps last-known-good tools across a failed refetch, and the
row only hard-reds when there are genuinely no tools to show. A persistent
failure still surfaces via the stored connectionStatus (gated by
MAX_CONSECUTIVE_FAILURES), matching how Claude Code / LibreChat / OpenCode /
VS Code handle a transient tools/list failure on a live connection.

Validated against those clients' source + the MCP spec before changing; this
supersedes the #5829 over-correction that showed the error even when tools
existed.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/settings/components/mcp/mcp.tsx

@@ -97,12 +97,12 @@ function ServerListItem({
     server.lastError,
     server.authType
   )
-  // A live discovery failure whose stored status hasn't caught up yet would otherwise read as
-  // "0 tools"; surface it directly so a failed row reads as failed, not empty.
-  // Shown even when cached tools exist: a present discoveryError means the LATEST
-  // discovery failed, and silently showing the stale tool count would hide that.
+  // Only hard-red when there are no last-known tools to show. A populated, connected server
+  // stays on its tool count through a transient probe failure; a persistent failure flips
+  // `connectionStatus` to error/disconnected and reads as failed through that path instead.
   const showDiscoveryError =
     Boolean(discoveryError) &&
+    tools.length === 0 &&
     server.connectionStatus !== 'error' &&
     server.connectionStatus !== 'disconnected'
   const hasConnectionIssue =

apps/sim/hooks/queries/mcp.test.tsx

@@ -3,7 +3,7 @@
  */
 import { act, type ReactNode } from 'react'
 import { sleep } from '@sim/utils/helpers'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { QueryClient, QueryClientProvider, useQueryClient } from '@tanstack/react-query'
 import { createRoot, type Root } from 'react-dom/client'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
@@ -20,7 +20,12 @@ import {
   listMcpServersContract,
   type McpServer,
 } from '@/lib/api/contracts/mcp'
-import { useForceRefreshMcpTools, useMcpServers, useMcpToolsQuery } from '@/hooks/queries/mcp'
+import {
+  mcpKeys,
+  useForceRefreshMcpTools,
+  useMcpServers,
+  useMcpToolsQuery,
+} from '@/hooks/queries/mcp'
 
 const WORKSPACE_ID = 'workspace-1'
 
@@ -181,6 +186,46 @@ describe('useMcpToolsQuery', () => {
     unmount()
   })
 
+  it('keeps last-known-good tools when a later discovery refetch fails', async () => {
+    let discoverCalls = 0
+    mockRequestJson.mockImplementation(async (contract) => {
+      if (contract === listMcpServersContract) {
+        return {
+          success: true,
+          data: { servers: [server('s1', { authType: 'headers', connectionStatus: 'connected' })] },
+        }
+      }
+      if (contract === discoverMcpToolsContract) {
+        discoverCalls++
+        if (discoverCalls === 1) {
+          return { success: true, data: { tools: [{ name: 'tool-a', serverId: 's1' }] } }
+        }
+        throw new Error('transient stall')
+      }
+      throw new Error('Unexpected MCP request')
+    })
+
+    const { getResult, unmount } = renderHookWithClient(() => ({
+      tools: useMcpToolsQuery(WORKSPACE_ID),
+      queryClient: useQueryClient(),
+    }))
+    await flush()
+    expect(getResult().tools.data).toHaveLength(1)
+
+    // Force a refetch that fails; the last successful tools must survive.
+    await act(async () => {
+      await getResult().queryClient.invalidateQueries({
+        queryKey: mcpKeys.serverToolsList(WORKSPACE_ID, 's1'),
+      })
+    })
+    await flush()
+
+    expect(getResult().tools.data).toHaveLength(1)
+    expect(getResult().tools.toolsStateByServer.get('s1')?.error).toBeInstanceOf(Error)
+
+    unmount()
+  })
+
   it('does not force-refresh disconnected OAuth servers', async () => {
     mockServers([
       server('oauth-disconnected', { authType: 'oauth', connectionStatus: 'disconnected' }),

apps/sim/hooks/queries/mcp.ts

@@ -188,8 +188,10 @@ export function useMcpToolsQuery(workspaceId: string) {
     >()
     for (let index = 0; index < results.length; index++) {
       const result = results[index]
-      // Drop stale data from servers whose latest refetch errored.
-      if (result.data && !result.isError) {
+      // Keep last-known-good tools when the latest refetch errored (React Query retains `data`);
+      // the per-server error rides in `toolsStateByServer`. Blanking a populated server on a
+      // transient discovery failure is what every reference MCP client avoids.
+      if (result.data) {
         tools.push(...result.data)
         hasData = true
       }