feat(mcp): add cached tool management and lookup

Implement tool caching mechanism to improve performance:
- Add findToolByName method to locate tools by server/name
- Store Tool objects in McpConfigService for persistent access
- Enhance tool selection tracking with object references
- Update UI to maintain tool object mapping alongside checkbox state

Author: phodal

core/src/main/kotlin/cc/unitmesh/devti/mcp/client/CustomMcpServerManager.kt

@@ -1,6 +1,7 @@
 package cc.unitmesh.devti.mcp.client
 
 import cc.unitmesh.devti.settings.customize.customizeSetting
+import cc.unitmesh.devti.mcp.ui.McpConfigService
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.project.Project
@@ -122,6 +123,26 @@ class CustomMcpServerManager(val project: Project) {
         return "No such tool: ${tool.name} or failed to execute"
     }
 
+    /**
+     * Find a Tool by server name and tool name
+     * @param serverName The name of the MCP server
+     * @param toolName The name of the tool
+     * @return The Tool object if found, null otherwise
+     */
+    suspend fun findToolByName(serverName: String, toolName: String): Tool? {
+        // First try to get from cached tools
+        val tools = cached[project.customizeSetting.mcpServerConfig]?.get(serverName) ?: emptyList()
+        val tool = tools.find { it.name == toolName }
+        if (tool != null) {
+            return tool
+        }
+        
+        // If not found in cache, try to get from config service
+        val configService = McpConfigService.getInstance(project)
+        val selectedTools = configService.getSelectedToolObjects()
+        return selectedTools[serverName]?.find { it.name == toolName }
+    }
+
     companion object {
         fun instance(project: Project): CustomMcpServerManager {
             return project.getService(CustomMcpServerManager::class.java)

core/src/main/kotlin/cc/unitmesh/devti/mcp/ui/McpConfigPopup.kt

@@ -7,6 +7,7 @@ import com.intellij.ui.components.JBLoadingPanel
 import com.intellij.ui.components.JBScrollPane
 import com.intellij.ui.components.JBTextField
 import com.intellij.util.ui.JBUI
+import io.modelcontextprotocol.kotlin.sdk.Tool
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -32,6 +33,7 @@ class McpConfigPopup {
         layout = BoxLayout(this, BoxLayout.Y_AXIS)
     }
     private val toolCheckboxMap = mutableMapOf<Pair<String, String>, JCheckBox>() // Stores serverName/toolName to JCheckBox
+    private val toolObjectMap = mutableMapOf<Pair<String, String>, Tool>() // Maps serverName/toolName to Tool object
 
     private fun createAndShow(component: JComponent?, project: Project, configService: McpConfigService) {
         val mainPanel = JPanel(BorderLayout()).apply {
@@ -121,6 +123,7 @@ class McpConfigPopup {
     ) {
         toolsPanel.removeAll()
         toolCheckboxMap.clear()
+        toolObjectMap.clear()
 
         loadToolsIntoPanel(project, configService, loadingPanel)
     }
@@ -132,6 +135,7 @@ class McpConfigPopup {
     ) {
         toolsPanel.removeAll() // Clear previous content
         toolCheckboxMap.clear()
+        toolObjectMap.clear()
 
         val loadingLabel = JLabel("Loading tools...")
         loadingLabel.alignmentX = Component.LEFT_ALIGNMENT
@@ -177,6 +181,7 @@ class McpConfigPopup {
                                         border = JBUI.Borders.emptyLeft(10)
                                     }
                                     toolCheckboxMap[Pair(serverName, tool.name)] = checkBox
+                                    toolObjectMap[Pair(serverName, tool.name)] = tool
                                     toolsPanel.add(checkBox)
                                 }
                             }
@@ -224,7 +229,14 @@ class McpConfigPopup {
             }
         }
 
-        configService.setSelectedTools(selectedTools)
+        toolObjectMap.forEach { (key, tool) ->
+            val (serverName, toolName) = key
+            if (selectedTools[serverName]?.contains(toolName) == true) {
+                configService.addSelectedTool(serverName, tool)
+            }
+        }
+
+        configService.setSelectedTools(selectedTools, false) // Don't clear cache as we just populated it
     }
 
     private fun filterToolsList(searchText: String) {

core/src/main/kotlin/cc/unitmesh/devti/mcp/ui/McpConfigService.kt

@@ -17,6 +17,7 @@ import kotlinx.coroutines.withContext
 )
 class McpConfigService(private val project: Project) : PersistentStateComponent<McpConfigService.State> {
     private val selectedTools = mutableMapOf<String, MutableSet<String>>()
+    private val cachedTools = mutableMapOf<Pair<String, String>, Tool>() // Cache of (serverName, toolName) -> Tool
     data class State(
         var toolSelections: Map<String, Set<String>> = emptyMap()
     )
@@ -41,12 +42,21 @@ class McpConfigService(private val project: Project) : PersistentStateComponent<
     fun addSelectedTool(serverName: String, toolName: String) {
         selectedTools.getOrPut(serverName) { mutableSetOf() }.add(toolName)
     }
+    
+    /**
+     * Add a selected tool and cache the Tool object
+     */
+    fun addSelectedTool(serverName: String, tool: Tool) {
+        addSelectedTool(serverName, tool.name)
+        cachedTools[Pair(serverName, tool.name)] = tool
+    }
 
     fun removeSelectedTool(serverName: String, toolName: String) {
         selectedTools[serverName]?.remove(toolName)
         if (selectedTools[serverName]?.isEmpty() == true) {
             selectedTools.remove(serverName)
         }
+        cachedTools.remove(Pair(serverName, toolName))
     }
 
     fun isToolSelected(serverName: String, toolName: String): Boolean {
@@ -57,11 +67,33 @@ class McpConfigService(private val project: Project) : PersistentStateComponent<
         return selectedTools.mapValues { it.value.toSet() }
     }
 
+    /**
+     * Gets the selected tools as actual Tool objects
+     * If tools haven't been cached, it will attempt to retrieve them
+     */
+    suspend fun getSelectedToolObjects(): Map<String, Set<Tool>> {
+        val result = mutableMapOf<String, MutableSet<Tool>>()
+        // First try to get from cache
+        selectedTools.forEach { (serverName, toolNames) ->
+            val toolsForServer = mutableSetOf<Tool>()
+            toolNames.forEach { toolName ->
+                cachedTools[Pair(serverName, toolName)]?.let {
+                    toolsForServer.add(it)
+                }
+            }
+            if (toolsForServer.isNotEmpty()) {
+                result[serverName] = toolsForServer
+            }
+        }
+        return result.mapValues { it.value.toSet() }
+    }
+
     fun clearSelectedTools() {
         selectedTools.clear()
+        cachedTools.clear()
     }
 
-    fun setSelectedTools(tools: Map<String, MutableSet<String>>) {
+    fun setSelectedTools(tools: Map<String, MutableSet<String>>, clearCache: Boolean = true) {
         selectedTools.clear()
         selectedTools.putAll(tools)
         // Update Sketch systemPromptPanel when tools change
@@ -75,6 +107,9 @@ class McpConfigService(private val project: Project) : PersistentStateComponent<
 //                }
 //            }
 //        }
+        if (clearCache) {
+            cachedTools.clear()
+        }
     }
 
     /**
@@ -96,6 +131,10 @@ class McpConfigService(private val project: Project) : PersistentStateComponent<
             try {
                 val tools = mcpServerManager.collectServerInfo(serverName, serverConfig)
                 allTools[serverName] = tools
+                // Cache the tools for later use
+                tools.forEach { tool ->
+                    cachedTools[Pair(serverName, tool.name)] = tool
+                }
             } catch (e: Exception) {
                 // Log error but continue with other servers
                 allTools[serverName] = emptyList()