feat(nano): Implement cross-platform action dispatch system

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/render/CodingAgentRenderer.kt

@@ -50,6 +50,22 @@ interface CodingAgentRenderer {
 
     fun updateTokenInfo(tokenInfo: TokenInfo) {}
 
+    /**
+     * Handle task-boundary tool call to update task progress display.
+     * Called when the agent uses the task-boundary tool to mark task status.
+     *
+     * This is an optional method primarily used by UI renderers that display
+     * task progress visually. Console and server renderers typically don't need
+     * to implement this.
+     *
+     * @param taskName The name of the task
+     * @param status The task status (e.g., "WORKING", "DONE", "FAILED")
+     * @param summary Optional summary of the task progress
+     */
+    fun handleTaskBoundary(taskName: String, status: String, summary: String = "") {
+        // Default: no-op for renderers that don't display task progress
+    }
+
     /**
      * Render a compact plan summary bar.
      * Called when plan is created or updated to show progress in a compact format.

mpp-idea/build.gradle.kts

@@ -344,6 +344,8 @@ project(":") {
             exclude(group = "cc.unitmesh.viewer.web", module = "mpp-viewer-web")
             exclude(group = "cc.unitmesh", module = "mpp-viewer-web")
         }
+
+        testImplementation(kotlin("test"))
     }
 
     tasks {

mpp-idea/src/main/kotlin/cc/unitmesh/devins/idea/renderer/JewelRenderer.kt

@@ -6,6 +6,8 @@ import cc.unitmesh.agent.render.BaseRenderer
 import cc.unitmesh.devins.llm.MessageRole
 import cc.unitmesh.agent.render.RendererUtils
 
+import cc.unitmesh.agent.render.TaskInfo
+import cc.unitmesh.agent.render.TaskStatus
 import cc.unitmesh.agent.render.TimelineItem
 import cc.unitmesh.agent.render.ToolCallDisplayInfo
 import cc.unitmesh.agent.render.ToolCallInfo
@@ -82,6 +84,10 @@ class JewelRenderer : BaseRenderer() {
     private val _currentPlan = MutableStateFlow<AgentPlan?>(null)
     val currentPlan: StateFlow<AgentPlan?> = _currentPlan.asStateFlow()
 
+    // Task tracking (from task-boundary tool)
+    private val _tasks = MutableStateFlow<List<TaskInfo>>(emptyList())
+    val tasks: StateFlow<List<TaskInfo>> = _tasks.asStateFlow()
+
     /**
      * Set the current plan directly.
      * Used to sync with PlanStateService from CodingAgent.
@@ -152,6 +158,11 @@ class JewelRenderer : BaseRenderer() {
 
         jewelRendererLogger.info("renderToolCall: parsed params keys=${params.keys}")
 
+        // Handle task-boundary tool - update task list
+        if (toolName == "task-boundary") {
+            updateTaskFromToolCall(params)
+        }
+
         // Handle plan management tool - update plan state
         if (toolName == "plan") {
             jewelRendererLogger.info("renderToolCall: detected plan tool, calling updatePlanFromToolCall")
@@ -178,6 +189,11 @@ class JewelRenderer : BaseRenderer() {
         // Convert Map<String, Any> to Map<String, String> for internal use
         val stringParams = params.mapValues { it.value.toString() }
 
+        // Handle task-boundary tool - update task list
+        if (toolName == "task-boundary") {
+            updateTaskFromToolCall(stringParams)
+        }
+
         // Handle plan management tool - update plan state with original params
         if (toolName == "plan") {
             updatePlanFromToolCallWithAnyParams(params)
@@ -322,6 +338,49 @@ class JewelRenderer : BaseRenderer() {
         }
     }
 
+    /**
+     * Update task list from task-boundary tool call
+     */
+    private fun updateTaskFromToolCall(params: Map<String, String>) {
+        val taskName = params["taskName"] ?: return
+        val statusStr = params["status"] ?: "WORKING"
+        val summary = params["summary"] ?: ""
+        val status = TaskStatus.fromString(statusStr)
+
+        _tasks.update { currentTasks ->
+            val existingIndex = currentTasks.indexOfFirst { it.taskName == taskName }
+            if (existingIndex >= 0) {
+                // Update existing task
+                currentTasks.toMutableList().apply {
+                    this[existingIndex] = currentTasks[existingIndex].copy(
+                        status = status,
+                        summary = summary,
+                        timestamp = System.currentTimeMillis()
+                    )
+                }
+            } else {
+                // Add new task
+                currentTasks + TaskInfo(
+                    taskName = taskName,
+                    status = status,
+                    summary = summary
+                )
+            }
+        }
+    }
+
+    /**
+     * Handle task-boundary tool call to update task progress display.
+     * Overrides the interface method to provide UI-specific task tracking.
+     */
+    override fun handleTaskBoundary(taskName: String, status: String, summary: String) {
+        updateTaskFromToolCall(mapOf(
+            "taskName" to taskName,
+            "status" to status,
+            "summary" to summary
+        ))
+    }
+
     override fun renderToolResult(
         toolName: String,
         success: Boolean,

mpp-idea/src/test/kotlin/cc/unitmesh/devins/idea/renderer/JewelRendererTest.kt

@@ -1,7 +1,6 @@
 package cc.unitmesh.devins.idea.renderer
 
 import cc.unitmesh.devins.llm.MessageRole
-import cc.unitmesh.agent.render.TaskStatus
 import cc.unitmesh.agent.render.TimelineItem
 import cc.unitmesh.llm.compression.TokenInfo
 import kotlinx.coroutines.flow.first

mpp-ui/src/commonMain/kotlin/cc/unitmesh/devins/ui/compose/agent/ComposeRenderer.kt

@@ -280,6 +280,18 @@ class ComposeRenderer : BaseRenderer() {
         }
     }
 
+    /**
+     * Handle task-boundary tool call to update task progress display.
+     * Overrides the interface method to provide UI-specific task tracking.
+     */
+    override fun handleTaskBoundary(taskName: String, status: String, summary: String) {
+        updateTaskFromToolCall(mapOf(
+            "taskName" to taskName,
+            "status" to status,
+            "summary" to summary
+        ))
+    }
+
     /**
      * Update plan state from plan management tool call (string params version)
      */

mpp-ui/src/jvmMain/kotlin/cc/unitmesh/devins/ui/nano/ComposeActionHandler.kt

@@ -0,0 +1,200 @@
+package cc.unitmesh.devins.ui.nano
+
+import cc.unitmesh.xuiper.action.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import java.awt.Desktop
+import java.net.URI
+import java.net.http.HttpClient
+import java.net.http.HttpRequest
+import java.net.http.HttpResponse
+import javax.swing.JOptionPane
+
+/**
+ * Compose/Desktop implementation of NanoActionHandler
+ *
+ * Handles NanoUI actions in a Compose Desktop environment.
+ * Provides platform-specific implementations for navigation, toast, and fetch.
+ *
+ * Example:
+ * ```kotlin
+ * val handler = ComposeActionHandler(
+ *     scope = rememberCoroutineScope(),
+ *     onNavigate = { route -> navController.navigate(route) },
+ *     onToast = { message -> snackbarHostState.showSnackbar(message) }
+ * )
+ *
+ * handler.registerCustomAction("AddTask") { payload, context ->
+ *     val title = payload["title"] as? String ?: ""
+ *     taskRepository.add(Task(title))
+ *     ActionResult.Success
+ * }
+ * ```
+ */
+class ComposeActionHandler(
+    private val scope: CoroutineScope = CoroutineScope(Dispatchers.IO),
+    private val onNavigate: ((String) -> Unit)? = null,
+    private val onToast: ((String) -> Unit)? = null,
+    private val onFetchComplete: ((String, Boolean, String?) -> Unit)? = null
+) : BaseNanoActionHandler() {
+
+    private val httpClient = HttpClient.newBuilder().build()
+
+    override fun handleNavigate(
+        navigate: NanoAction.Navigate,
+        context: NanoActionContext
+    ): ActionResult {
+        return try {
+            if (onNavigate != null) {
+                onNavigate.invoke(navigate.to)
+            } else {
+                // Default: open in browser if it's a URL
+                if (navigate.to.startsWith("http://") || navigate.to.startsWith("https://")) {
+                    Desktop.getDesktop().browse(URI(navigate.to))
+                }
+            }
+            ActionResult.Success
+        } catch (e: Exception) {
+            ActionResult.Error("Navigation failed: ${e.message}", e)
+        }
+    }
+
+    override fun handleFetch(
+        fetch: NanoAction.Fetch,
+        context: NanoActionContext
+    ): ActionResult {
+        // Set loading state if specified
+        fetch.loadingState?.let { path ->
+            context.set(path, true)
+        }
+
+        scope.launch {
+            try {
+                val requestBuilder = HttpRequest.newBuilder()
+                    .uri(URI(fetch.url))
+
+                // Set method
+                when (fetch.method) {
+                    HttpMethod.GET -> requestBuilder.GET()
+                    HttpMethod.POST -> {
+                        val body = buildRequestBody(fetch.body, context)
+                        requestBuilder.POST(HttpRequest.BodyPublishers.ofString(body))
+                        requestBuilder.header("Content-Type", fetch.contentType.mimeType)
+                    }
+                    HttpMethod.PUT -> {
+                        val body = buildRequestBody(fetch.body, context)
+                        requestBuilder.PUT(HttpRequest.BodyPublishers.ofString(body))
+                        requestBuilder.header("Content-Type", fetch.contentType.mimeType)
+                    }
+                    HttpMethod.DELETE -> requestBuilder.DELETE()
+                    else -> requestBuilder.GET()
+                }
+
+                // Add headers
+                fetch.headers?.forEach { (key, value) ->
+                    requestBuilder.header(key, value)
+                }
+
+                val response = httpClient.send(
+                    requestBuilder.build(),
+                    HttpResponse.BodyHandlers.ofString()
+                )
+
+                // Update loading state
+                fetch.loadingState?.let { path ->
+                    context.set(path, false)
+                }
+
+                if (response.statusCode() in 200..299) {
+                    // Success
+                    fetch.responseBinding?.let { path ->
+                        context.set(path, response.body())
+                    }
+
+                    fetch.onSuccess?.let { successAction ->
+                        handleAction(successAction, context)
+                    }
+
+                    onFetchComplete?.invoke(fetch.url, true, response.body())
+                } else {
+                    // Error
+                    val errorMsg = "HTTP ${response.statusCode()}: ${response.body()}"
+                    fetch.errorBinding?.let { path ->
+                        context.set(path, errorMsg)
+                    }
+
+                    fetch.onError?.let { errorAction ->
+                        handleAction(errorAction, context)
+                    }
+
+                    onFetchComplete?.invoke(fetch.url, false, errorMsg)
+                }
+
+            } catch (e: Exception) {
+                fetch.loadingState?.let { path ->
+                    context.set(path, false)
+                }
+                fetch.errorBinding?.let { path ->
+                    context.set(path, e.message)
+                }
+                fetch.onError?.let { errorAction ->
+                    handleAction(errorAction, context)
+                }
+                onFetchComplete?.invoke(fetch.url, false, e.message)
+            }
+        }
+
+        return ActionResult.Pending { /* async operation */ }
+    }
+
+    override fun handleShowToast(
+        toast: NanoAction.ShowToast,
+        context: NanoActionContext
+    ): ActionResult {
+        return try {
+            if (onToast != null) {
+                onToast.invoke(toast.message)
+            } else {
+                // Default: use Swing dialog (for desktop)
+                javax.swing.SwingUtilities.invokeLater {
+                    JOptionPane.showMessageDialog(null, toast.message)
+                }
+            }
+            ActionResult.Success
+        } catch (e: Exception) {
+            ActionResult.Error("Toast failed: ${e.message}", e)
+        }
+    }
+
+    private fun buildRequestBody(
+        body: Map<String, BodyField>?,
+        context: NanoActionContext
+    ): String {
+        if (body == null) return ""
+
+        val resolvedBody = body.mapValues { (_, field) ->
+            when (field) {
+                is BodyField.Literal -> field.value
+                is BodyField.StateBinding -> context.get(field.path)?.toString() ?: ""
+            }
+        }
+
+        // Simple JSON serialization with proper escaping
+        return buildString {
+            append("{")
+            resolvedBody.entries.forEachIndexed { index, (key, value) ->
+                if (index > 0) append(",")
+                append("\"$key\":")
+                when (value) {
+                    is String -> append("\"${value.replace("\\", "\\\\").replace("\"", "\\\"")}\"")
+                    is Number, is Boolean -> append(value)
+                    null -> append("null")
+                    else -> append("\"${value.toString().replace("\\", "\\\\").replace("\"", "\\\"")}\"")
+                }
+            }
+            append("}")
+        }
+    }
+}
+

mpp-ui/src/jvmMain/kotlin/cc/unitmesh/devins/ui/nano/NanoDSLDemo.kt

@@ -256,7 +256,7 @@ fun NanoDSLDemo(
                         .verticalScroll(rememberScrollState())
                 ) {
                     parsedIR?.let { ir ->
-                        ComposeNanoRenderer.Render(ir)
+                        StatefulNanoRenderer.Render(ir)
                     } ?: run {
                         Box(
                             modifier = Modifier.fillMaxSize(),
@@ -305,13 +305,18 @@ component ShoppingItem:
 
 private val COUNTER_DSL = """
 component Counter:
+    state:
+        count: int = 0
+
     Card(padding="lg", shadow="md"):
         VStack(spacing="md"):
             Text("Counter Example", style="h2")
             HStack(spacing="md", align="center", justify="center"):
-                Button("-", intent="secondary")
-                Text("0", style="h1")
-                Button("+", intent="primary")
+                Button("-", intent="secondary"):
+                    on_click: state.count -= 1
+                Text(content << state.count, style="h1")
+                Button("+", intent="primary"):
+                    on_click: state.count += 1
             Divider
             Text("Click buttons to change value", style="caption")
 """.trimIndent()