@ynhcj/xiaoyi 2.5.2 → 2.5.4

package/dist/channel.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.xiaoyiPlugin = void 0;
 const runtime_1 = require("./runtime");
-const file_handler_1 = require("./file-handler");
+const onboarding_1 = require("./onboarding");
+const xiaoyi_media_1 = require("./xiaoyi-media");
 /**
  * XiaoYi Channel Plugin
  * Implements OpenClaw ChannelPlugin interface for XiaoYi A2A protocol
@@ -26,6 +27,7 @@ exports.xiaoyiPlugin = {
         media: true,
         nativeCommands: false,
     },
+    onboarding: onboarding_1.xiaoyiOnboardingAdapter,
     /**
      * Config adapter - single account mode
      */
@@ -119,8 +121,11 @@ exports.xiaoyiPlugin = {
             const agentId = resolvedAccount.config.agentId;
             // Use 'to' as sessionId (it's set from incoming message's sessionId)
             const sessionId = ctx.to;
-            // Get taskId from runtime's session mapping
-            const taskId = runtime.getTaskIdForSession(sessionId) || `task_${Date.now()}`;
+            // Get taskId from runtime's session mapping (must exist - from original A2A request)
+            const taskId = runtime.getTaskIdForSession(sessionId);
+            if (!taskId) {
+                throw new Error(`Cannot send outbound message: No taskId found for session ${sessionId}. Outbound messages must be in response to an incoming A2A request.`);
+            }
             // Build A2A response message
             const response = {
                 sessionId: sessionId,
@@ -160,8 +165,11 @@ exports.xiaoyiPlugin = {
             const agentId = resolvedAccount.config.agentId;
             // Use 'to' as sessionId
             const sessionId = ctx.to;
-            // Get taskId from runtime's session mapping
-            const taskId = runtime.getTaskIdForSession(sessionId) || `task_${Date.now()}`;
+            // Get taskId from runtime's session mapping (must exist - from original A2A request)
+            const taskId = runtime.getTaskIdForSession(sessionId);
+            if (!taskId) {
+                throw new Error(`Cannot send outbound media: No taskId found for session ${sessionId}. Outbound messages must be in response to an incoming A2A request.`);
+            }
             // Build A2A response message with media
             const response = {
                 sessionId: sessionId,
@@ -214,6 +222,16 @@ exports.xiaoyiPlugin = {
                 const { getXiaoYiRuntime } = require("./runtime");
                 const runtime = getXiaoYiRuntime();
                 console.log(`XiaoYi: [Message Handler] Using runtime instance: ${runtime.getInstanceId()}`);
+                // CRITICAL FIX: Extract and store config values at message handler level
+                // This prevents "Cannot read properties of undefined" errors in concurrent scenarios
+                // where the outer scope's resolvedAccount might become unavailable
+                const messageHandlerAgentId = resolvedAccount.config?.agentId;
+                const messageHandlerAccountId = resolvedAccount.accountId;
+                if (!messageHandlerAgentId) {
+                    console.error("XiaoYi: [FATAL] agentId not available in resolvedAccount.config");
+                    return;
+                }
+                console.log(`XiaoYi: [Message Handler] Stored config values - agentId: ${messageHandlerAgentId}, accountId: ${messageHandlerAccountId}`);
                 // For message/stream, prioritize params.sessionId, fallback to top-level sessionId
                 const sessionId = message.params?.sessionId || message.sessionId;
                 // Validate sessionId exists
@@ -221,8 +239,6 @@ exports.xiaoyiPlugin = {
                     console.error("XiaoYi: Missing sessionId in message, cannot process");
                     return;
                 }
-                // Store sessionId -> taskId mapping in runtime (use params.id as taskId)
-                runtime.setTaskIdForSession(sessionId, message.params.id);
                 // Get PluginRuntime from our runtime wrapper
                 const pluginRuntime = runtime.getPluginRuntime();
                 if (!pluginRuntime) {
@@ -231,8 +247,8 @@ exports.xiaoyiPlugin = {
                 }
                 // Extract text, file, and image content from parts array
                 let bodyText = "";
-                let images = [];
                 let fileAttachments = [];
+                const mediaFiles = [];
                 for (const part of message.params.message.parts) {
                     if (part.kind === "text" && part.text) {
                         // Handle text content
@@ -246,35 +262,27 @@ exports.xiaoyiPlugin = {
                             continue;
                         }
                         try {
-                            // Handle image files
-                            if ((0, file_handler_1.isImageMimeType)(mimeType)) {
-                                console.log(`XiaoYi: Processing image file: ${name} (${mimeType})`);
-                                const imageContent = await (0, file_handler_1.extractImageFromUrl)(uri, {
-                                    maxBytes: 10000000, // 10MB
-                                    timeoutMs: 30000, // 30 seconds
-                                });
-                                images.push(imageContent);
-                                fileAttachments.push(`[图片: ${name}]`);
-                                console.log(`XiaoYi: Successfully processed image: ${name}`);
-                            }
-                            // Handle PDF files - extract as text for now
-                            else if ((0, file_handler_1.isPdfMimeType)(mimeType)) {
-                                console.log(`XiaoYi: Processing PDF file: ${name}`);
-                                // Note: PDF text extraction requires pdfjs-dist, for now just add a placeholder
-                                fileAttachments.push(`[PDF文件: ${name} - PDF内容提取需要额外配置]`);
-                                console.log(`XiaoYi: PDF file noted: ${name} (text extraction requires pdfjs-dist)`);
-                            }
-                            // Handle text-based files
-                            else if ((0, file_handler_1.isTextMimeType)(mimeType)) {
-                                console.log(`XiaoYi: Processing text file: ${name} (${mimeType})`);
-                                const textContent = await (0, file_handler_1.extractTextFromUrl)(uri, 5000000, 30000);
-                                bodyText += `\n\n[文件内容: ${name}]\n${textContent}`;
-                                fileAttachments.push(`[文件: ${name}]`);
-                                console.log(`XiaoYi: Successfully processed text file: ${name}`);
+                            // All files are downloaded to local disk and passed to OpenClaw
+                            // No type validation - let Agent decide how to handle them
+                            console.log(`XiaoYi: Processing file: ${name} (${mimeType})`);
+                            mediaFiles.push({ uri, mimeType, name });
+                            // For text-based files, also extract content inline
+                            if ((0, xiaoyi_media_1.isTextMimeType)(mimeType)) {
+                                try {
+                                    const textContent = await (0, xiaoyi_media_1.extractTextFromUrl)(uri, 5000000, 30000);
+                                    bodyText += `\n\n[文件内容: ${name}]\n${textContent}`;
+                                    fileAttachments.push(`[文件: ${name}]`);
+                                    console.log(`XiaoYi: Successfully extracted text from: ${name}`);
+                                }
+                                catch (textError) {
+                                    // Text extraction failed, but file is still in mediaFiles
+                                    console.warn(`XiaoYi: Text extraction failed for ${name}, will download as binary`);
+                                    fileAttachments.push(`[文件: ${name}]`);
+                                }
                             }
                             else {
-                                console.warn(`XiaoYi: Unsupported file type: ${mimeType}, name: ${name}`);
-                                fileAttachments.push(`[不支持的文件类型: ${name} (${mimeType})]`);
+                                // Binary files (images, pdf, office docs, etc.)
+                                fileAttachments.push(`[文件: ${name}]`);
                             }
                         }
                         catch (error) {
@@ -289,12 +297,18 @@ exports.xiaoyiPlugin = {
                 if (fileAttachments.length > 0) {
                     console.log(`XiaoYi: Processed ${fileAttachments.length} file(s): ${fileAttachments.join(", ")}`);
                 }
-                if (images.length > 0) {
-                    console.log(`XiaoYi: Total ${images.length} image(s) extracted for AI processing`);
+                // Download media files to local disk (like feishu does)
+                let mediaPayload = {};
+                if (mediaFiles.length > 0) {
+                    console.log(`XiaoYi: Downloading ${mediaFiles.length} media file(s) to local disk...`);
+                    const downloadedMedia = await (0, xiaoyi_media_1.downloadAndSaveMediaList)(pluginRuntime, mediaFiles, { maxBytes: 30000000, timeoutMs: 60000 });
+                    console.log(`XiaoYi: Successfully downloaded ${downloadedMedia.length}/${mediaFiles.length} file(s)`);
+                    mediaPayload = (0, xiaoyi_media_1.buildXiaoYiMediaPayload)(downloadedMedia);
                 }
                 // Determine sender ID from role
                 const senderId = message.params.message.role === "user" ? "user" : message.agentId;
                 // Build MsgContext for OpenClaw's message pipeline
+                // Include media payload so OpenClaw can access local file paths
                 const msgContext = {
                     Body: bodyText,
                     From: senderId,
@@ -309,7 +323,24 @@ exports.xiaoyiPlugin = {
                     SenderName: message.params.message.role, // Use role as sender name
                     SenderId: senderId,
                     OriginatingChannel: "xiaoyi",
+                    ...mediaPayload, // Spread MediaPath, MediaPaths, MediaType, MediaTypes
                 };
+                // Log the message context for debugging
+                console.log("\n" + "=".repeat(60));
+                console.log("XiaoYi: [DEBUG] Message Context");
+                console.log("  " + JSON.stringify({
+                    Body: msgContext.Body.substring(0, 50) + "...",
+                    From: msgContext.From,
+                    To: msgContext.To,
+                    SessionKey: msgContext.SessionKey,
+                    AccountId: msgContext.AccountId,
+                    Provider: msgContext.Provider,
+                    Surface: msgContext.Surface,
+                    MediaPath: msgContext.MediaPath,
+                    MediaPaths: msgContext.MediaPaths,
+                    MediaType: msgContext.MediaType,
+                }, null, 2));
+                console.log("=".repeat(60) + "\n");
                 // Dispatch message using OpenClaw's reply dispatcher
                 try {
                     console.log("\n" + "=".repeat(60));
@@ -317,39 +348,82 @@ exports.xiaoyiPlugin = {
                     console.log(`  Session: ${sessionId}`);
                     console.log(`  Task ID: ${message.params.id}`);
                     console.log(`  User input: ${bodyText.substring(0, 50)}${bodyText.length > 50 ? "..." : ""}`);
-                    console.log(`  Images: ${images.length}`);
+                    console.log(`  Images: ${mediaFiles.length}`);
                     console.log("=".repeat(60) + "\n");
-                    const taskId = runtime.getTaskIdForSession(sessionId) || `task_${Date.now()}`;
+                    // Get taskId from this message's params.id
+                    // NOTE: We store this AFTER concurrent check to avoid overwriting active task's taskId
+                    const currentTaskId = message.params.id;
+                    // ==================== CONCURRENT REQUEST DETECTION ====================
+                    // Check if this session already has an active agent run
+                    // If so, send an immediate "busy" response and skip processing
+                    if (runtime.isSessionActive(sessionId)) {
+                        console.log("\n" + "=".repeat(60));
+                        console.log(`[CONCURRENT] Session ${sessionId} has an active agent run`);
+                        console.log(`  Action: Sending busy response and skipping message`);
+                        console.log("=".repeat(60) + "\n");
+                        const conn = runtime.getConnection();
+                        if (conn) {
+                            try {
+                                await conn.sendResponse({
+                                    sessionId: sessionId,
+                                    messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                                    timestamp: Date.now(),
+                                    agentId: messageHandlerAgentId,
+                                    sender: {
+                                        id: messageHandlerAgentId,
+                                        name: "OpenClaw Agent",
+                                        type: "agent",
+                                    },
+                                    content: {
+                                        type: "text",
+                                        text: "上一个任务仍在处理中，请稍后再试",
+                                    },
+                                    status: "success",
+                                }, currentTaskId, sessionId, true, false);
+                                console.log(`[CONCURRENT] Busy response sent to session ${sessionId}\n`);
+                            }
+                            catch (error) {
+                                console.error(`[CONCURRENT] Failed to send busy response:`, error);
+                            }
+                        }
+                        return; // Skip processing this concurrent request
+                    }
+                    // =================================================================
+                    // Store sessionId -> taskId mapping (only after passing concurrent check)
+                    runtime.setTaskIdForSession(sessionId, currentTaskId);
                     const startTime = Date.now();
                     let accumulatedText = "";
                     let sentTextLength = 0; // Track sent text length for streaming
                     let hasSentFinal = false; // Track if final content has been sent (to prevent duplicate isFinal=true)
                     // ==================== CREATE ABORT CONTROLLER ====================
                     // Create AbortController for this session to allow cancelation
-                    const { controller: abortController, signal: abortSignal } = runtime.createAbortControllerForSession(sessionId);
+                    const abortControllerResult = runtime.createAbortControllerForSession(sessionId);
+                    if (!abortControllerResult) {
+                        console.error(`[ERROR] Failed to create AbortController for session ${sessionId}`);
+                        return;
+                    }
+                    const { controller: abortController, signal: abortSignal } = abortControllerResult;
                     // ================================================================
                     // ==================== START TIMEOUT PROTECTION ====================
-                    // Start 60-second timeout timer
+                    // Start periodic 60-second timeout timer
+                    // Will trigger every 60 seconds until a response is received or session completes
                     const timeoutConfig = runtime.getTimeoutConfig();
-                    console.log(`[TIMEOUT] Starting ${timeoutConfig.duration}ms timeout protection for session ${sessionId}`);
-                    // Define recursive timeout handler
+                    console.log(`[TIMEOUT] Starting ${timeoutConfig.duration}ms periodic timeout protection for session ${sessionId}`);
+                    // Define periodic timeout handler (will be called every 60 seconds)
                     const createTimeoutHandler = () => {
                         return async () => {
                             const elapsed = Date.now() - startTime;
                             console.log("\n" + "=".repeat(60));
                             console.log(`[TIMEOUT] Timeout triggered for session ${sessionId}`);
                             console.log(`  Elapsed: ${elapsed}ms`);
-                            console.log(`  Task ID: ${taskId}`);
+                            console.log(`  Task ID: ${currentTaskId}`);
                             console.log("=".repeat(60) + "\n");
                             const conn = runtime.getConnection();
                             if (conn) {
                                 try {
-                                    // Send status update instead of artifact-update to keep conversation active
-                                    await conn.sendStatusUpdate(taskId, sessionId, timeoutConfig.message);
+                                    // Send status update to keep conversation active
+                                    await conn.sendStatusUpdate(currentTaskId, sessionId, timeoutConfig.message);
                                     console.log(`[TIMEOUT] Status update sent successfully to session ${sessionId}\n`);
-                                    // Restart the timeout timer - allow repeated timeout messages
-                                    console.log(`[TIMEOUT] Restarting timeout timer for session ${sessionId}...\n`);
-                                    runtime.setTimeoutForSession(sessionId, createTimeoutHandler());
                                 }
                                 catch (error) {
                                     console.error(`[TIMEOUT] Failed to send status update:`, error);
@@ -358,234 +432,273 @@ exports.xiaoyiPlugin = {
                             else {
                                 console.error(`[TIMEOUT] Connection not available, cannot send status update\n`);
                             }
+                            // Note: Timeout will trigger again in 60 seconds if still active
                         };
                     };
-                    // Start initial timeout
+                    // Start periodic timeout
                     runtime.setTimeoutForSession(sessionId, createTimeoutHandler());
                     // ==================== END TIMEOUT PROTECTION ====================
-                    await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-                        ctx: msgContext,
-                        cfg: config,
-                        dispatcherOptions: {
-                            deliver: async (payload, info) => {
-                                const elapsed = Date.now() - startTime;
-                                const completeText = payload.text || "";
-                                accumulatedText = completeText;
-                                const kind = info.kind; // "tool" | "block" | "final"
-                                // ==================== DEBUG LOG - ENTRY POINT ====================
-                                // Log EVERY call to deliver with full details
-                                console.log("\n" + "█".repeat(70));
-                                console.log(`📨 [DELIVER ENTRY] deliver() callback invoked`);
-                                console.log(`  Session: ${sessionId}`);
-                                console.log(`  Elapsed: ${elapsed}ms`);
-                                console.log(`  Kind: "${kind}"`);
-                                console.log(`  Text length: ${completeText.length} chars`);
-                                console.log(`  Sent so far: ${sentTextLength} chars`);
-                                if (completeText.length > 0) {
-                                    console.log(`  Text preview: "${completeText.substring(0, 80)}${completeText.length > 80 ? "..." : ""}"`);
-                                }
-                                console.log(`  Full info object:`, JSON.stringify(info, null, 2));
-                                console.log(`  Full payload keys:`, Object.keys(payload));
-                                console.log("█".repeat(70) + "\n");
-                                // =================================================================
-                                // Check if session was aborted
-                                if (runtime.isSessionAborted(sessionId)) {
-                                    console.log("\n" + "=".repeat(60));
-                                    console.log(`[ABORT] Response received AFTER abort`);
-                                    console.log(`  Session: ${sessionId}`);
-                                    console.log(`  Kind: ${kind}`);
-                                    console.log(`  Elapsed: ${elapsed}ms`);
-                                    console.log(`  Action: DISCARDING (session was canceled)`);
-                                    console.log("=".repeat(60) + "\n");
-                                    return;
+                    // ==================== CREATE STREAMING DISPATCHER ====================
+                    // Use createReplyDispatcherWithTyping for real-time streaming feedback
+                    const { dispatcher, replyOptions, markDispatchIdle } = pluginRuntime.channel.reply.createReplyDispatcherWithTyping({
+                        humanDelay: 0,
+                        onReplyStart: async () => {
+                            const elapsed = Date.now() - startTime;
+                            console.log("\n" + "=".repeat(60));
+                            console.log("XiaoYi: [START] Reply started after " + elapsed + "ms");
+                            console.log("  Session: " + sessionId);
+                            console.log("  Task ID: " + currentTaskId);
+                            console.log("=".repeat(60) + "\n");
+                            // Send immediate status update to let user know Agent is working
+                            const conn = runtime.getConnection();
+                            if (conn) {
+                                try {
+                                    await conn.sendStatusUpdate(currentTaskId, sessionId, "任务正在处理中，请稍后");
+                                    console.log("✓ [START] Initial status update sent\n");
                                 }
-                                // ==================== CHECK TIMEOUT ====================
-                                // If timeout already sent, discard this response
-                                if (runtime.isSessionTimeout(sessionId)) {
-                                    console.log("\n" + "=".repeat(60));
-                                    console.log(`[TIMEOUT] Response received AFTER timeout`);
-                                    console.log(`  Session: ${sessionId}`);
-                                    console.log(`  Kind: ${kind}`);
-                                    console.log(`  Elapsed: ${elapsed}ms`);
-                                    console.log(`  Action: DISCARDING (timeout message already sent)`);
-                                    console.log("=".repeat(60) + "\n");
-                                    return;
+                                catch (error) {
+                                    console.error("✗ [START] Failed to send initial status update:", error);
                                 }
-                                // ==================== CHECK EMPTY RESPONSE ====================
-                                // If response is empty, don't clear timeout (let it trigger)
-                                if (!completeText || completeText.length === 0) {
-                                    console.log("\n" + "=".repeat(60));
-                                    console.log(`[STREAM] Empty ${kind} response detected`);
-                                    console.log(`  Session: ${sessionId}`);
-                                    console.log(`  Elapsed: ${elapsed}ms`);
-                                    console.log(`  Action: SKIPPING (empty response)`);
-                                    console.log("=".repeat(60) + "\n");
-                                    // Don't send anything, and don't clear timeout
-                                    return;
+                            }
+                        },
+                        deliver: async (payload, info) => {
+                            const elapsed = Date.now() - startTime;
+                            const text = payload.text || "";
+                            const kind = info.kind;
+                            const payloadStatus = payload.status;
+                            // IMPORTANT: Check if this is actually the final message
+                            // Check multiple sources: payload.status, payload.queuedFinal, AND info.kind
+                            // info.kind is the most reliable indicator for final messages
+                            const isFinal = payloadStatus === "final" || payload.queuedFinal === true || kind === "final";
+                            accumulatedText = text;
+                            console.log("\n" + "█".repeat(70));
+                            console.log("📨 [DELIVER] Payload received");
+                            console.log("  Session: " + sessionId);
+                            console.log("  Elapsed: " + elapsed + "ms");
+                            console.log("  Info Kind: \"" + kind + "\"");
+                            console.log("  Payload Status: \"" + (payloadStatus || "unknown") + "\"");
+                            console.log("  Is Final: " + isFinal);
+                            console.log("  Text length: " + text.length + " chars");
+                            console.log("  Sent so far: " + sentTextLength + " chars");
+                            if (text.length > 0) {
+                                console.log("  Text preview: \"" + text.substring(0, 80) + (text.length > 80 ? "..." : "") + "\"");
+                            }
+                            console.log("█".repeat(70) + "\n");
+                            // Only check for abort, NOT timeout
+                            // Timeout is just for user notification, final responses should still be delivered
+                            if (runtime.isSessionAborted(sessionId)) {
+                                console.log("\n" + "=".repeat(60));
+                                console.log("[ABORT] Response received AFTER abort");
+                                console.log("  Session: " + sessionId);
+                                console.log("  Action: DISCARDING");
+                                console.log("=".repeat(60) + "\n");
+                                return;
+                            }
+                            // NOTE: We DON'T check timeout here anymore
+                            // Even if timeout occurred, we should still deliver the final response
+                            // Timeout was just to keep user informed, not to discard results
+                            const conn = runtime.getConnection();
+                            if (!conn) {
+                                console.error("✗ XiaoYi: Connection not available\n");
+                                return;
+                            }
+                            // ==================== FIX: Empty text handling ====================
+                            // If text is empty but this is not final, ALWAYS send a status update
+                            // This ensures user gets feedback for EVERY Agent activity (tool calls, subagent calls, etc.)
+                            if ((!text || text.length === 0) && !isFinal) {
+                                console.log("\n" + "=".repeat(60));
+                                console.log("[STREAM] Empty " + kind + " response detected");
+                                console.log("  Session: " + sessionId);
+                                console.log("  Action: Sending status update (no throttling)");
+                                console.log("=".repeat(60) + "\n");
+                                try {
+                                    await conn.sendStatusUpdate(currentTaskId, sessionId, "任务正在处理中，请稍后");
+                                    console.log("✓ Status update sent\n");
                                 }
-                                const conn = runtime.getConnection();
-                                if (!conn) {
-                                    console.error(`✗ XiaoYi: Connection not available\n`);
-                                    return;
+                                catch (error) {
+                                    console.error("✗ Failed to send status update:", error);
                                 }
-                                // ==================== STREAMING LOGIC ====================
-                                // For "block" kind: send incremental text (streaming)
-                                // For "final" kind: send complete text (final message)
-                                if (kind === "block") {
-                                    // Calculate incremental text
-                                    const incrementalText = completeText.slice(sentTextLength);
-                                    if (incrementalText.length > 0) {
-                                        console.log("\n" + "-".repeat(60));
-                                        console.log(`XiaoYi: [STREAM] Incremental block received`);
-                                        console.log(`  Session: ${sessionId}`);
-                                        console.log(`  Elapsed: ${elapsed}ms`);
-                                        console.log(`  Total length: ${completeText.length} chars`);
-                                        console.log(`  Incremental: +${incrementalText.length} chars (sent: ${sentTextLength})`);
-                                        console.log(`  Preview: "${incrementalText.substring(0, 50)}${incrementalText.length > 50 ? "..." : ""}"`);
-                                        console.log("-".repeat(60) + "\n");
-                                        const response = {
-                                            sessionId: sessionId,
-                                            messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-                                            timestamp: Date.now(),
-                                            agentId: resolvedAccount.config.agentId,
-                                            sender: {
-                                                id: resolvedAccount.config.agentId,
-                                                name: "OpenClaw Agent",
-                                                type: "agent",
-                                            },
-                                            content: {
-                                                type: "text",
-                                                text: incrementalText,
-                                            },
-                                            status: "success",
-                                        };
-                                        // Send incremental text, NOT final, append mode
-                                        await conn.sendResponse(response, taskId, sessionId, false, true);
-                                        console.log(`✓ XiaoYi: Stream chunk sent (+${incrementalText.length} chars)\n`);
-                                        // Update sent length
-                                        sentTextLength = completeText.length;
-                                    }
-                                    else {
-                                        console.log("\n" + "-".repeat(60));
-                                        console.log(`XiaoYi: [STREAM] No new text to send`);
-                                        console.log(`  Session: ${sessionId}`);
-                                        console.log(`  Total length: ${completeText.length} chars`);
-                                        console.log(`  Already sent: ${sentTextLength} chars`);
-                                        console.log("-".repeat(60) + "\n");
+                                return;
+                            }
+                            // ==================== END FIX ====================
+                            const responseStatus = isFinal ? "success" : "processing";
+                            const incrementalText = text.slice(sentTextLength);
+                            const isAppend = !isFinal && incrementalText.length > 0;
+                            if (incrementalText.length > 0 || isFinal) {
+                                console.log("\n" + "-".repeat(60));
+                                console.log("XiaoYi: [STREAM] Sending response");
+                                console.log("  Response Status: " + responseStatus);
+                                console.log("  Is Final: " + isFinal);
+                                console.log("  Is Append: " + isAppend);
+                                console.log("-".repeat(60) + "\n");
+                                const response = {
+                                    sessionId: sessionId,
+                                    messageId: "msg_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9),
+                                    timestamp: Date.now(),
+                                    agentId: messageHandlerAgentId, // Use stored value instead of resolvedAccount.config.agentId
+                                    sender: {
+                                        id: messageHandlerAgentId, // Use stored value instead of resolvedAccount.config.agentId
+                                        name: "OpenClaw Agent",
+                                        type: "agent",
+                                    },
+                                    content: {
+                                        type: "text",
+                                        text: isFinal ? text : incrementalText,
+                                    },
+                                    status: responseStatus,
+                                };
+                                // ==================== FIX: Prevent duplicate final messages ====================
+                                // Only send isFinal=true if we haven't sent it before AND this is actually the final message
+                                const shouldSendFinal = isFinal && !hasSentFinal;
+                                try {
+                                    await conn.sendResponse(response, currentTaskId, sessionId, shouldSendFinal, isAppend);
+                                    console.log("✓ Sent (status=" + responseStatus + ", isFinal=" + shouldSendFinal + ", append=" + isAppend + ")\n");
+                                    // Mark that we've sent a final message (even if we're still processing subagent responses)
+                                    if (isFinal) {
+                                        hasSentFinal = true;
                                     }
                                 }
-                                else if (kind === "final") {
-                                    console.log("\n" + "=".repeat(60));
-                                    console.log(`XiaoYi: [STREAM] Final response received`);
-                                    console.log(`  Session: ${sessionId}`);
-                                    console.log(`  Elapsed: ${elapsed}ms`);
-                                    console.log(`  Total length: ${completeText.length} chars`);
-                                    console.log(`  Has already sent final: ${hasSentFinal}`);
-                                    console.log(`  Preview: "${completeText.substring(0, 100)}..."`);
-                                    console.log("=".repeat(60) + "\n");
-                                    // Check if we've already sent final content - prevent duplicate isFinal=true
-                                    if (hasSentFinal) {
-                                        console.log(`XiaoYi: [STREAM] Skipping duplicate final response (already sent)\n`);
-                                        // Don't send anything, but clear timeout to prevent timeout warnings
-                                        runtime.clearSessionTimeout(sessionId);
-                                        return;
-                                    }
+                                catch (error) {
+                                    console.error("✗ Failed to send:", error);
+                                }
+                                sentTextLength = text.length;
+                            }
+                            // ==================== FIX: SubAgent-friendly cleanup logic ====================
+                            // Only mark session as completed if we're truly done (no more subagent responses expected)
+                            // The key insight: we should NOT cleanup on every "final" payload, because subagents
+                            // can generate additional responses after the main agent returns "final".
+                            //
+                            // Instead, we let onIdle handle the cleanup, which is called after ALL processing is done.
+                            if (isFinal) {
+                                // Clear timeout but DON'T mark session as completed yet
+                                // SubAgent might still send more responses
+                                runtime.clearSessionTimeout(sessionId);
+                                console.log("[CLEANUP] Final payload received, but NOT marking session completed yet (waiting for onIdle)\n");
+                            }
+                            // ==================== END FIX ====================
+                        },
+                        onError: (err, info) => {
+                            console.error("\n" + "=".repeat(60));
+                            console.error("XiaoYi: [ERROR] " + info.kind + " failed: " + String(err));
+                            console.log("=".repeat(60) + "\n");
+                            runtime.clearSessionTimeout(sessionId);
+                            runtime.clearAbortControllerForSession(sessionId);
+                            runtime.markSessionCompleted(sessionId);
+                        },
+                        onIdle: async () => {
+                            const elapsed = Date.now() - startTime;
+                            console.log("\n" + "=".repeat(60));
+                            console.log("XiaoYi: [IDLE] Processing complete");
+                            console.log("  Total time: " + elapsed + "ms");
+                            console.log("=".repeat(60) + "\n");
+                            // ==================== PUSH MESSAGE FOR BACKGROUND RESULTS ====================
+                            // NOTE: Push logic disabled because we cannot reliably distinguish between:
+                            // - Normal responses (should be sent via WebSocket)
+                            // - Background task completion (should be sent via HTTP push)
+                            // TODO: Implement proper push message detection and HTTP API call
+                            console.log("[IDLE] All agent processing complete");
+                            // ==================== END PUSH MESSAGE ====================
+                            // This is called AFTER all processing is done (including subagents)
+                            // NOW we can safely mark the session as completed
+                            runtime.clearAbortControllerForSession(sessionId);
+                            runtime.markSessionCompleted(sessionId);
+                            console.log("[CLEANUP] Session marked as completed in onIdle\n");
+                        },
+                    });
+                    try {
+                        const result = await pluginRuntime.channel.reply.dispatchReplyFromConfig({
+                            ctx: msgContext,
+                            cfg: config,
+                            dispatcher,
+                            replyOptions: {
+                                ...replyOptions,
+                                abortSignal: abortSignal,
+                            },
+                        });
+                        const { queuedFinal, counts } = result;
+                        console.log("\n" + "=".repeat(60));
+                        console.log("XiaoYi: [DISPATCH] Summary");
+                        console.log("  Queued Final: " + queuedFinal);
+                        if (counts && Object.keys(counts).length > 0) {
+                            console.log("  Counts:", JSON.stringify(counts, null, 2));
+                        }
+                        console.log("=".repeat(60) + "\n");
+                        // ==================== ANALYZE EXECUTION RESULT ====================
+                        // Check if Agent produced any output
+                        const hasAnyCounts = counts && ((counts.tool && counts.tool > 0) ||
+                            (counts.block && counts.block > 0) ||
+                            (counts.final && counts.final > 0));
+                        if (!hasAnyCounts) {
+                            // Scenario 1: No Agent output detected
+                            // This could mean:
+                            // a) SubAgent running in background (main Agent returned)
+                            // b) Concurrent request (another Agent already running on this session)
+                            console.log("\n" + "=".repeat(60));
+                            console.log("[NO OUTPUT] Agent produced no output");
+                            console.log("  Session: " + sessionId);
+                            console.log("  Checking if there's another active Agent...");
+                            console.log("=".repeat(60) + "\n");
+                            // Check if there's an active Agent on this session
+                            // We use the existence of deliver callback triggers as an indicator
+                            // If the dispatcher's onIdle will be called later, an Agent is still running
+                            const conn = runtime.getConnection();
+                            if (conn) {
+                                // IMPORTANT: Send a response to user for THIS request
+                                // User needs to know what's happening
+                                try {
                                     const response = {
                                         sessionId: sessionId,
                                         messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
                                         timestamp: Date.now(),
-                                        agentId: resolvedAccount.config.agentId,
+                                        agentId: messageHandlerAgentId, // Use stored value instead of resolvedAccount.config.agentId
                                         sender: {
-                                            id: resolvedAccount.config.agentId,
+                                            id: messageHandlerAgentId, // Use stored value instead of resolvedAccount.config.agentId
                                             name: "OpenClaw Agent",
                                             type: "agent",
                                         },
                                         content: {
                                             type: "text",
-                                            text: completeText,
+                                            text: "任务正在处理中，请稍候...",
                                         },
                                         status: "success",
                                     };
-                                    // Send complete text but NOT as final yet - use append mode to keep stream alive
-                                    // The true isFinal=true will be sent in onIdle callback
-                                    await conn.sendResponse(response, taskId, sessionId, false, true);
-                                    console.log(`✓ XiaoYi: Final response content sent (${completeText.length} chars, stream kept alive)\n`);
-                                    // Mark that we've sent the final content
-                                    hasSentFinal = true;
-                                    // Clear timeout to prevent timeout warnings, but don't mark session as completed yet
-                                    runtime.clearSessionTimeout(sessionId);
-                                    // Note: We DON'T call markSessionCompleted here
-                                    // The session will be marked completed in onIdle when we send isFinal=true
-                                }
-                                else if (kind === "tool") {
-                                    // Tool results - typically not sent as messages
-                                    console.log("\n" + "-".repeat(60));
-                                    console.log(`XiaoYi: [STREAM] Tool result received (not forwarded)`);
-                                    console.log(`  Session: ${sessionId}`);
-                                    console.log(`  Elapsed: ${elapsed}ms`);
-                                    console.log("-".repeat(60) + "\n");
-                                }
-                            },
-                            onIdle: async () => {
-                                const elapsed = Date.now() - startTime;
-                                console.log("\n" + "=".repeat(60));
-                                console.log(`XiaoYi: [IDLE] Processing complete`);
-                                console.log(`  Total time: ${elapsed}ms`);
-                                console.log(`  Final length: ${accumulatedText.length} chars`);
-                                console.log(`  Has sent final: ${hasSentFinal}`);
-                                // Only send final close message if we have valid content
-                                if (accumulatedText.length > 0) {
-                                    const conn = runtime.getConnection();
-                                    if (conn) {
-                                        try {
-                                            // Send the true final response with isFinal=true to properly close the stream
-                                            const finalResponse = {
-                                                sessionId: sessionId,
-                                                messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-                                                timestamp: Date.now(),
-                                                agentId: resolvedAccount.config.agentId,
-                                                sender: {
-                                                    id: resolvedAccount.config.agentId,
-                                                    name: "OpenClaw Agent",
-                                                    type: "agent",
-                                                },
-                                                content: {
-                                                    type: "text",
-                                                    text: accumulatedText,
-                                                },
-                                                status: "success",
-                                            };
-                                            // Send with isFinal=true to properly close the A2A communication stream
-                                            await conn.sendResponse(finalResponse, taskId, sessionId, true, false);
-                                            console.log(`✓ XiaoYi: True isFinal=true sent to close stream\n`);
-                                        }
-                                        catch (error) {
-                                            console.error(`✗ XiaoYi: Failed to send final close message:`, error);
-                                        }
-                                    }
-                                    // Now mark session as completed and clean up
-                                    runtime.markSessionCompleted(sessionId);
-                                    runtime.clearAbortControllerForSession(sessionId);
-                                    console.log(`[TIMEOUT] Session completed and cleaned up\n`);
+                                    // Send response with isFinal=true to close THIS request
+                                    await conn.sendResponse(response, currentTaskId, sessionId, true, false);
+                                    console.log("✓ [NO OUTPUT] Response sent to user\n");
                                 }
-                                else {
-                                    console.log(`[TIMEOUT] No valid response, keeping timeout active\n`);
+                                catch (error) {
+                                    console.error("✗ [NO OUTPUT] Failed to send response:", error);
                                 }
-                                console.log("=".repeat(60) + "\n");
-                            },
-                        },
-                        replyOptions: {
-                            abortSignal: abortSignal, // Pass abort signal to allow cancellation
-                        },
-                        images: images.length > 0 ? images : undefined,
-                    });
+                            }
+                            // CRITICAL: Don't cleanup resources yet!
+                            // The original Agent might still be running and needs these resources
+                            // onIdle will be called when the original Agent completes
+                            console.log("[NO OUTPUT] Keeping resources alive for potential background Agent\n");
+                            markDispatchIdle();
+                        }
+                        else {
+                            // Scenario 2: Normal execution with output
+                            // - Agent produced output synchronously
+                            // - All cleanup is already handled in deliver/onIdle callbacks
+                            console.log("[NORMAL] Agent produced output, cleanup handled in callbacks");
+                            markDispatchIdle();
+                        }
+                        // ==================== END ANALYSIS ====================
+                    }
+                    catch (error) {
+                        console.error("XiaoYi: [ERROR] Error dispatching message:", error);
+                        // Clear timeout on error
+                        runtime.clearSessionTimeout(sessionId);
+                        // Clear abort controller on error
+                        runtime.clearAbortControllerForSession(sessionId);
+                        // Mark session as completed on error
+                        runtime.markSessionCompleted(sessionId);
+                        // Mark dispatcher as idle even on error
+                        markDispatchIdle();
+                    }
                 }
                 catch (error) {
-                    console.error("XiaoYi: [ERROR] Error dispatching message:", error);
-                    // Clear timeout on error
-                    runtime.clearSessionTimeout(sessionId);
-                    // Clear abort controller on error
-                    runtime.clearAbortControllerForSession(sessionId);
+                    console.error("XiaoYi: [ERROR] Unexpected error in message handler:", error);
                 }
             });
             // Setup cancel handler