feat(a2a): migrate to new Client.builder API

Migrate A2AClientConsumer to use io.a2a.client.Client.builder with JSON-RPC transport, streaming event consumers, and CompletableFuture response handling. Replace reflection-based AgentCard access in UI panels with record getters. Update build.gradle and adjust Tool constructor in McpConfigService.

Author: phodal

build.gradle.kts

@@ -429,6 +429,11 @@ project(":core") {
         implementation("io.ktor:ktor-server-sse:3.2.3")
 
         implementation("io.github.a2asdk:a2a-java-sdk-client:0.3.0.Beta1")
+        // A2A transport dependencies - JSON-RPC is included by default but we need to configure it
+        // Add gRPC transport if needed in the future
+        // implementation("io.github.a2asdk:a2a-java-sdk-client-transport-grpc:0.3.0.Beta1")
+        // Add REST transport if needed in the future
+        // implementation("io.github.a2asdk:a2a-java-sdk-client-transport-rest:0.3.0.Beta1")
 
         implementation("io.reactivex.rxjava3:rxjava:3.1.10")
 

core/src/main/kotlin/cc/unitmesh/devti/a2a/A2AClientConsumer.kt

@@ -1,48 +1,164 @@
 package cc.unitmesh.devti.a2a
 
 import io.a2a.A2A
-import io.a2a.client.A2AClient
+import io.a2a.client.Client
+import io.a2a.client.ClientEvent
+import io.a2a.client.MessageEvent
+import io.a2a.client.TaskEvent
+import io.a2a.client.TaskUpdateEvent
+import io.a2a.client.config.ClientConfig
+import io.a2a.client.transport.jsonrpc.JSONRPCTransport
+import io.a2a.client.transport.jsonrpc.JSONRPCTransportConfig
 import io.a2a.spec.AgentCard
-import io.a2a.spec.MessageSendParams
-import io.a2a.spec.SendMessageResponse
+import io.a2a.spec.Message
+import io.a2a.client.http.A2ACardResolver
 import kotlinx.serialization.Serializable
 import com.fasterxml.jackson.databind.ObjectMapper
+import io.a2a.client.http.JdkA2AHttpClient
+import io.a2a.spec.Part
+import java.util.function.BiConsumer
+import java.util.function.Consumer
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.ConcurrentHashMap
 
 class A2AClientConsumer {
-    var clientMap: MutableMap<String, A2AClient> = mutableMapOf()
-    var cardMap: MutableMap<String, AgentCard> = mutableMapOf()
-    var jacksonObjectMapper = ObjectMapper()
-
-    fun init(servers: List<A2aServer>): List<A2AClient> {
-        servers.forEach {
-            val client = A2AClient(it.url)
-            val cardName = client.agentCard.name
-            cardMap[cardName] = client.getAgentCard()
-            clientMap[cardName] = client
+    private val clientMap: MutableMap<String, Client> = ConcurrentHashMap()
+    private val cardMap: MutableMap<String, AgentCard> = ConcurrentHashMap()
+    private val jacksonObjectMapper = ObjectMapper()
+    private val responseMap: MutableMap<String, CompletableFuture<String>> = ConcurrentHashMap()
+
+    fun init(servers: List<A2aServer>): List<Client> {
+        servers.forEach { server ->
+            try {
+                // Get agent card using A2ACardResolver
+                val cardResolver = A2ACardResolver(server.url)
+                val agentCard = cardResolver.getAgentCard()
+                val agentName = agentCard.name()
+
+                // Create client configuration
+                val clientConfig = ClientConfig.Builder()
+                    .setAcceptedOutputModes(listOf("text", "application/json"))
+                    .build()
+
+                // Create event consumers to handle responses
+                val consumers = listOf<BiConsumer<ClientEvent, AgentCard>>(
+                    BiConsumer { event, card ->
+                        handleClientEvent(event, card, agentName)
+                    }
+                )
+
+                // Create error handler
+                val errorHandler = Consumer<Throwable> { error ->
+                    handleStreamingError(error, agentName)
+                }
+
+                // Create the client using the builder pattern
+                val client = Client.builder(agentCard)
+                    .clientConfig(clientConfig)
+                    .withTransport(JSONRPCTransport::class.java, JSONRPCTransportConfig())
+                    .addConsumers(consumers)
+                    .streamingErrorHandler(errorHandler)
+                    .build()
+
+                cardMap[agentName] = agentCard
+                clientMap[agentName] = client
+            } catch (e: Exception) {
+                throw RuntimeException("Failed to initialize A2A client for ${server.url}: ${e.message}", e)
+            }
         }
 
         return clientMap.values.toList()
     }
 
     fun listAgents(): List<AgentCard> {
-        return clientMap.values.map { it.getAgentCard() }
+        return cardMap.values.toList()
     }
 
     fun sendMessage(agentName: String, msgText: String): String {
         val client = clientMap[agentName] ?: throw IllegalArgumentException("No client found for $agentName")
-        val message = A2A.toUserMessage(msgText)
-        val msgParams = MessageSendParams.Builder()
-            .message(message)
-            .build()
 
         return try {
-            val response: SendMessageResponse = client.sendMessage(msgParams)
-            val resultString = jacksonObjectMapper.writeValueAsString(response.result)
-            resultString
+            // Create message using A2A utility
+            val message = A2A.toUserMessage(msgText)
+
+            // Create a future to capture the response
+            val responseFuture = CompletableFuture<String>()
+            responseMap[agentName] = responseFuture
+
+            // Send the message using the new API
+            client.sendMessage(message, null)
+
+            // Wait for response (with timeout)
+            responseFuture.get(30, java.util.concurrent.TimeUnit.SECONDS)
         } catch (e: Exception) {
+            responseMap.remove(agentName)
             throw RuntimeException("Failed to send message to agent $agentName: ${e.message}", e)
         }
     }
+
+    private fun handleClientEvent(event: ClientEvent, card: AgentCard, agentName: String) {
+        when (event) {
+            is MessageEvent -> {
+                // Handle message response
+                val message = event.message
+                val responseFuture = responseMap[agentName]
+                if (responseFuture != null && !responseFuture.isDone) {
+                    try {
+                        val responseText = extractTextFromMessage(message)
+                        responseFuture.complete(responseText)
+                    } catch (e: Exception) {
+                        responseFuture.completeExceptionally(e)
+                    } finally {
+                        responseMap.remove(agentName)
+                    }
+                }
+            }
+            is TaskEvent -> {
+                // Handle task events if needed
+                // For now, we'll just log or ignore
+            }
+            is TaskUpdateEvent -> {
+                // Handle task update events if needed
+                // For now, we'll just log or ignore
+            }
+        }
+    }
+
+    private fun handleStreamingError(error: Throwable, agentName: String) {
+        val responseFuture = responseMap[agentName]
+        if (responseFuture != null && !responseFuture.isDone) {
+            responseFuture.completeExceptionally(error)
+            responseMap.remove(agentName)
+        }
+    }
+
+    private fun extractTextFromMessage(message: Message): String {
+        val parts = message.getParts()
+        if (parts != null) {
+            return parts.joinToString("") { part ->
+                when {
+                    part.javaClass.simpleName == "TextPart" -> {
+                        // Try to use the text() method for TextPart record
+                        try {
+                            val textMethod = part.javaClass.getMethod("text")
+                            textMethod.invoke(part) as? String ?: ""
+                        } catch (e: Exception) {
+                            // Fallback to reflection for field access
+                            try {
+                                val textField = part.javaClass.getDeclaredField("text")
+                                textField.isAccessible = true
+                                textField.get(part) as? String ?: ""
+                            } catch (e2: Exception) {
+                                part.toString()
+                            }
+                        }
+                    }
+                    else -> part.toString()
+                }
+            }
+        }
+        return ""
+    }
 }
 
 @Serializable

core/src/main/kotlin/cc/unitmesh/devti/a2a/ui/A2AAgentCardPanel.kt

@@ -24,39 +24,34 @@ class A2AAgentCardPanel(
 ) : JPanel(BorderLayout(0, 0)) {
 
     // Helper methods to safely access AgentCard properties
-    // Use reflection to access Java record fields safely
+    // Use the new AgentCard record methods
     private fun getAgentName(): String = try {
-        getFieldValue(agentCard, "name") as? String ?: "Unknown Agent"
+        agentCard.name() ?: "Unknown Agent"
     } catch (e: Exception) {
         "Unknown Agent"
     }
 
     private fun getAgentDescription(): String = try {
-        getFieldValue(agentCard, "description") as? String ?: "No description available"
+        agentCard.description() ?: "No description available"
     } catch (e: Exception) {
         "No description available"
     }
 
     private fun getAgentVersion(): String = try {
-        getFieldValue(agentCard, "version") as? String ?: "1.0.0"
+        agentCard.version() ?: "1.0.0"
     } catch (e: Exception) {
         "1.0.0"
     }
 
     private fun getProviderName(): String = try {
-        val provider = getFieldValue(agentCard, "provider")
-        if (provider != null) {
-            getFieldValue(provider, "name") as? String ?: "Unknown"
-        } else {
-            "Unknown"
-        }
+        val provider = agentCard.provider()
+        provider?.organization() ?: "Unknown"
     } catch (e: Exception) {
         "Unknown"
     }
 
     private fun getSkillsCount(): Int = try {
-        val skills = getFieldValue(agentCard, "skills") as? List<*>
-        skills?.size ?: 0
+        agentCard.skills()?.size ?: 0
     } catch (e: Exception) {
         0
     }
@@ -198,7 +193,7 @@ class A2AAgentCardPanel(
         }
 
         private fun getAgentName(): String = try {
-            getFieldValue(agentCard, "name") as? String ?: "Unknown Agent"
+            agentCard.name() ?: "Unknown Agent"
         } catch (e: Exception) {
             "Unknown Agent"
         }
@@ -228,32 +223,35 @@ class A2AAgentCardPanel(
 
             // Basic Information
             addSectionHeader(panel, "Basic Information")
-            addDetailRow(panel, "Name", getFieldValue(agentCard, "name") as? String ?: "N/A")
-            addDetailRow(panel, "Description", getFieldValue(agentCard, "description") as? String ?: "N/A")
-            addDetailRow(panel, "Version", getFieldValue(agentCard, "version") as? String ?: "N/A")
-            addDetailRow(panel, "URL", getFieldValue(agentCard, "url") as? String ?: "N/A")
-            addDetailRow(panel, "Protocol Version", getFieldValue(agentCard, "protocolVersion") as? String ?: "N/A")
+            addDetailRow(panel, "Name", agentCard.name() ?: "N/A")
+            addDetailRow(panel, "Description", agentCard.description() ?: "N/A")
+            addDetailRow(panel, "Version", agentCard.version() ?: "N/A")
+            addDetailRow(panel, "URL", agentCard.url() ?: "N/A")
+            addDetailRow(panel, "Protocol Version", agentCard.protocolVersion() ?: "N/A")
 
             // Provider Information
-            val provider = getFieldValue(agentCard, "provider")
+            val provider = agentCard.provider()
             if (provider != null) {
                 addSectionHeader(panel, "Provider")
-                addDetailRow(panel, "Name", getFieldValue(provider, "name") as? String ?: "N/A")
-                addDetailRow(panel, "Description", getFieldValue(provider, "description") as? String ?: "N/A")
-                addDetailRow(panel, "URL", getFieldValue(provider, "url") as? String ?: "N/A")
+                try {
+                    addDetailRow(panel, "Organization", provider.organization() ?: "N/A")
+                    addDetailRow(panel, "URL", provider.url() ?: "N/A")
+                } catch (e: Exception) {
+                    addDetailRow(panel, "Provider", provider.toString())
+                }
             }
 
             // Capabilities
-            val capabilities = getFieldValue(agentCard, "capabilities")
+            val capabilities = agentCard.capabilities()
             if (capabilities != null) {
                 addSectionHeader(panel, "Capabilities")
-                addDetailRow(panel, "Supports Streaming", getFieldValue(capabilities, "supportsStreaming")?.toString() ?: "N/A")
-                addDetailRow(panel, "Supports Tools", getFieldValue(capabilities, "supportsTools")?.toString() ?: "N/A")
-                addDetailRow(panel, "Supports Resources", getFieldValue(capabilities, "supportsResources")?.toString() ?: "N/A")
+                addDetailRow(panel, "Supports Streaming", capabilities.streaming()?.toString() ?: "N/A")
+                addDetailRow(panel, "Push Notifications", capabilities.pushNotifications()?.toString() ?: "N/A")
+                addDetailRow(panel, "State Transition History", capabilities.stateTransitionHistory()?.toString() ?: "N/A")
             }
 
             // Skills
-            val skills = getFieldValue(agentCard, "skills") as? List<*>
+            val skills = agentCard.skills()
             if (!skills.isNullOrEmpty()) {
                 addSectionHeader(panel, "Skills (${skills.size})")
                 skills.forEach { skill ->
@@ -265,17 +263,17 @@ class A2AAgentCardPanel(
 
             // Input/Output Modes
             addSectionHeader(panel, "Input/Output Modes")
-            val inputModes = getFieldValue(agentCard, "defaultInputModes") as? List<*>
-            val outputModes = getFieldValue(agentCard, "defaultOutputModes") as? List<*>
+            val inputModes = agentCard.defaultInputModes()
+            val outputModes = agentCard.defaultOutputModes()
             addDetailRow(panel, "Default Input Modes", inputModes?.joinToString(", ") ?: "N/A")
             addDetailRow(panel, "Default Output Modes", outputModes?.joinToString(", ") ?: "N/A")
 
             // Additional Information
             addSectionHeader(panel, "Additional Information")
-            addDetailRow(panel, "Documentation URL", getFieldValue(agentCard, "documentationUrl") as? String ?: "N/A")
-            addDetailRow(panel, "Icon URL", getFieldValue(agentCard, "iconUrl") as? String ?: "N/A")
-            addDetailRow(panel, "Preferred Transport", getFieldValue(agentCard, "preferredTransport") as? String ?: "N/A")
-            addDetailRow(panel, "Supports Auth Extended Card", getFieldValue(agentCard, "supportsAuthenticatedExtendedCard")?.toString() ?: "N/A")
+            addDetailRow(panel, "Documentation URL", agentCard.documentationUrl() ?: "N/A")
+            addDetailRow(panel, "Icon URL", agentCard.iconUrl() ?: "N/A")
+            addDetailRow(panel, "Preferred Transport", agentCard.preferredTransport() ?: "N/A")
+            addDetailRow(panel, "Supports Auth Extended Card", agentCard.supportsAuthenticatedExtendedCard()?.toString() ?: "N/A")
 
             return panel
         }
@@ -320,8 +318,32 @@ class A2AAgentCardPanel(
                 isOpaque = true
             }
 
-            val skillName = getFieldValue(skill, "name") as? String ?: "Unnamed Skill"
-            val skillDesc = getFieldValue(skill, "description") as? String ?: "No description"
+            // Try to access skill properties using the new API
+            val skillName = try {
+                when {
+                    skill.javaClass.simpleName == "AgentSkill" -> {
+                        // Use reflection for AgentSkill record methods
+                        val nameMethod = skill.javaClass.getMethod("name")
+                        nameMethod.invoke(skill) as? String ?: "Unnamed Skill"
+                    }
+                    else -> getFieldValue(skill, "name") as? String ?: "Unnamed Skill"
+                }
+            } catch (e: Exception) {
+                "Unnamed Skill"
+            }
+
+            val skillDesc = try {
+                when {
+                    skill.javaClass.simpleName == "AgentSkill" -> {
+                        // Use reflection for AgentSkill record methods
+                        val descMethod = skill.javaClass.getMethod("description")
+                        descMethod.invoke(skill) as? String ?: "No description"
+                    }
+                    else -> getFieldValue(skill, "description") as? String ?: "No description"
+                }
+            } catch (e: Exception) {
+                "No description"
+            }
 
             val nameLabel = JBLabel("• $skillName").apply {
                 font = JBUI.Fonts.label(12.0f).asBold()
@@ -358,7 +380,7 @@ class A2AAgentCardPanel(
         }
 
         private fun getAgentName(): String = try {
-            getFieldValue(agentCard, "name") as? String ?: "Unknown Agent"
+            agentCard.name() ?: "Unknown Agent"
         } catch (e: Exception) {
             "Unknown Agent"
         }