feat(mcp): add McpFunctionProvider and enhance tool handling #330

- Introduced McpFunctionProvider to manage MCP server tools.
- Refactored tool handling to support multiple tools and caching.
- Updated AgentTool and related interfaces to handle lists of tools.
- Added execute functionality for MCP tools.

Author: phodal

core/src/223/main/resources/META-INF/autodev-core.xml

@@ -269,6 +269,7 @@
         <toolchainFunctionProvider implementation="cc.unitmesh.devti.bridge.assessment.SccFunctionProvider"/>
         <toolchainFunctionProvider implementation="cc.unitmesh.devti.bridge.knowledge.HistoryFunctionProvider"/>
         <toolchainFunctionProvider implementation="cc.unitmesh.devti.bridge.knowledge.KnowledgeFunctionProvider"/>
+        <toolchainFunctionProvider implementation="cc.unitmesh.devti.mcp.provider.McpFunctionProvider"/>
     </extensions>
 
     <actions>

core/src/233/main/resources/META-INF/autodev-core.xml

@@ -270,6 +270,7 @@
         <toolchainFunctionProvider implementation="cc.unitmesh.devti.bridge.assessment.SccFunctionProvider"/>
         <toolchainFunctionProvider implementation="cc.unitmesh.devti.bridge.knowledge.HistoryFunctionProvider"/>
         <toolchainFunctionProvider implementation="cc.unitmesh.devti.bridge.knowledge.KnowledgeFunctionProvider"/>
+        <toolchainFunctionProvider implementation="cc.unitmesh.devti.mcp.provider.McpFunctionProvider"/>
     </extensions>
 
     <actions>

core/src/main/kotlin/cc/unitmesh/devti/agenttool/AgentTool.kt

@@ -3,11 +3,11 @@ package cc.unitmesh.devti.agenttool
 data class AgentTool(val commandName: String, val description: String, val example: String) {
     override fun toString(): String {
         val string = if (description.isEmpty()) "" else """desc: $description"""
-        return """<tool>name: ${commandName}, $string
-example:
+        val example = if (example.isEmpty()) "" else """example:
 <devin>
 $example
-</devin>
+</devin>"""
+        return """<tool>name: ${commandName}, $string, $example
 </tool>"""
     }
 }

core/src/main/kotlin/cc/unitmesh/devti/bridge/BridgeToolProvider.kt

@@ -18,17 +18,17 @@ object BridgeToolProvider {
 
         val functions = ToolchainFunctionProvider.all()
 
-        commonTools += functions.map {
-            if (it.toolInfo() != null) {
-                return@map listOf(it.toolInfo()!!)
+        commonTools += functions.flatMap {
+            if (it.toolInfos().isNotEmpty()) {
+                return@flatMap it.toolInfos()
             }
 
             val funcNames = it.funcNames()
             funcNames.map { name ->
                 val example = BuiltinCommand.example(name)
                 AgentTool(name, "", example)
             }
-        }.flatten()
+        }
 
         return commonTools
     }

core/src/main/kotlin/cc/unitmesh/devti/devin/dataprovider/BuiltinCommand.kt

@@ -2,6 +2,7 @@ package cc.unitmesh.devti.devin.dataprovider
 
 import cc.unitmesh.devti.AutoDevIcons
 import cc.unitmesh.devti.AutoDevNotifications
+import cc.unitmesh.devti.agenttool.AgentTool
 import cc.unitmesh.devti.provider.toolchain.ToolchainFunctionProvider
 import com.intellij.icons.AllIcons
 import com.intellij.openapi.project.ProjectManager
@@ -164,10 +165,9 @@ enum class BuiltinCommand(
 
         fun allToolchains(): List<String> {
             return ToolchainFunctionProvider.all().map {
-                val toolInfo = it.toolInfo()
-                if (toolInfo != null) {
-                    val base = toolInfo.commandName
-                    return@map it.funcNames().map { "$base:$it" }
+                val toolInfo: List<AgentTool> = it.toolInfos()
+                if (toolInfo.isNotEmpty()) {
+                    return@map toolInfo.map { it.commandName }
                 }
 
                 it.funcNames()

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

@@ -1,11 +1,9 @@
 package cc.unitmesh.devti.mcp
 
 import cc.unitmesh.devti.settings.customize.customizeSetting
-import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.Service
 import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.project.Project
-import com.intellij.openapi.project.ProjectManager
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
 import io.modelcontextprotocol.kotlin.sdk.client.Client
@@ -33,9 +31,8 @@ data class McpServer(
 ) {
 
     companion object {
-        fun load(): McpConfig? {
-            val project = ProjectManager.getInstance().openProjects.first()
-            return tryParse(project.customizeSetting.mcpServerConfig)
+        fun load(mcpServerConfig: String): McpConfig? {
+            return tryParse(mcpServerConfig)
         }
 
         fun tryParse(configs: String?): McpConfig? {
@@ -56,8 +53,20 @@ data class McpServer(
 
 @Service(Service.Level.PROJECT)
 class CustomMcpServerManager(val project: Project) {
-    fun collectServerInfos(): List<Any> {
-        val mcpConfig = McpServer.load()
+    val cached = mutableMapOf<String, List<Tool>>()
+    val toolClientMap = mutableMapOf<Tool, Client>()
+
+    fun collectServerInfos(): List<Tool> {
+        val mcpServerConfig = project.customizeSetting.mcpServerConfig
+        if (mcpServerConfig.isEmpty()) {
+            return emptyList()
+        }
+
+        if (cached.containsKey(mcpServerConfig)) {
+            return cached[mcpServerConfig]!!
+        }
+
+        val mcpConfig = McpServer.load(mcpServerConfig)
         if (mcpConfig == null) {
             return emptyList()
         }
@@ -92,6 +101,10 @@ class CustomMcpServerManager(val project: Project) {
                         future.complete(listTools.tools)
                     }
 
+                    listTools?.tools?.map {
+                        toolClientMap[it] = client
+                    }
+
                     listTools
                 } catch (e: java.lang.Error) {
                     logger<CustomMcpServerManager>().warn("Failed to list tools from ${it.key}: $e")
@@ -102,15 +115,35 @@ class CustomMcpServerManager(val project: Project) {
             future.get(30, java.util.concurrent.TimeUnit.SECONDS)
         }.flatten()
 
-
+        cached[mcpServerConfig] = tools
         return tools
     }
 
+    fun execute(project: Project, tool: Tool, map: List<String>): Any {
+        toolClientMap[tool]?.let {
+            val future = CompletableFuture<Any>()
+            kotlinx.coroutines.runBlocking {
+                try {
+                    val result = it.callTool(tool.name, mapOf<String, Any?>(), true, null)
+                    future.complete(result)
+                } catch (e: java.lang.Error) {
+                    logger<CustomMcpServerManager>().warn("Failed to execute tool ${tool.name}: $e")
+                    future.complete("Failed to execute tool ${tool.name}: $e")
+                }
+            }
+
+            return future.get(30, java.util.concurrent.TimeUnit.SECONDS)
+        }
+
+        return "No such tool: ${tool.name} or failed to execute"
+    }
+
     companion object {
         private val logger = logger<CustomMcpServerManager>()
 
         fun instance(project: Project): CustomMcpServerManager {
             return project.getService(CustomMcpServerManager::class.java)
         }
     }
-}
+}
+

core/src/main/kotlin/cc/unitmesh/devti/mcp/provider/McpFunctionProvider.kt

@@ -0,0 +1,41 @@
+package cc.unitmesh.devti.mcp.provider
+
+import cc.unitmesh.devti.agenttool.AgentTool
+import cc.unitmesh.devti.mcp.CustomMcpServerManager
+import cc.unitmesh.devti.provider.toolchain.ToolchainFunctionProvider
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.project.ProjectManager
+
+class McpFunctionProvider : ToolchainFunctionProvider {
+    override fun funcNames(): List<String> {
+        val project = ProjectManager.getInstance().openProjects.firstOrNull() ?: return emptyList()
+        return CustomMcpServerManager.instance(project).collectServerInfos().map { it.name }
+    }
+
+    override fun toolInfos(): List<AgentTool> {
+        val manager = CustomMcpServerManager.instance(
+            ProjectManager.getInstance().openProjects.firstOrNull() ?: return emptyList()
+        )
+        return manager.collectServerInfos().map {
+            AgentTool(it.name, it.description ?: "", "")
+        }
+    }
+
+    override fun isApplicable(project: Project, funcName: String): Boolean {
+        return CustomMcpServerManager.instance(project).collectServerInfos().any { it.name == funcName }
+    }
+
+    override fun execute(
+        project: Project,
+        prop: String,
+        args: List<Any>,
+        allVariables: Map<String, Any?>
+    ): Any {
+        val tool = CustomMcpServerManager.instance(project).collectServerInfos().firstOrNull { it.name == prop }
+        if (tool == null) {
+            return "No such tool: $prop"
+        }
+
+        return CustomMcpServerManager.instance(project).execute(project, tool, args.map { it.toString() })
+    }
+}

core/src/main/kotlin/cc/unitmesh/devti/provider/toolchain/ToolchainFunctionProvider.kt

@@ -5,7 +5,7 @@ import com.intellij.openapi.extensions.ExtensionPointName
 import com.intellij.openapi.project.Project
 
 interface ToolchainFunctionProvider {
-    fun toolInfo(): AgentTool? = null
+    fun toolInfos(): List<AgentTool> = emptyList()
 
     fun funcNames(): List<String>
 

exts/ext-database/src/main/kotlin/cc/unitmesh/database/provider/DatabaseFunctionProvider.kt

@@ -12,9 +12,9 @@ import com.intellij.openapi.diagnostic.logger
 import com.intellij.openapi.project.Project
 
 class DatabaseFunctionProvider : ToolchainFunctionProvider {
-    override fun toolInfo(): AgentTool? {
+    override fun toolInfos(): List<AgentTool> {
         val example = BuiltinCommand.example("database")
-        return AgentTool("database", "Database schema and query tool", example)
+        return listOf(AgentTool("database", "Database schema and query tool", example))
     }
 
     override fun isApplicable(project: Project, funcName: String): Boolean = DatabaseFunction.entries.any { it.funName == funcName }