@ynhcj/xiaoyi 2.5.5 → 2.5.6

package/dist/channel.d.ts

@@ -30,6 +30,63 @@ export declare const xiaoyiPlugin: {
         media: boolean;
         nativeCommands: boolean;
     };
+    /**
+     * Config schema for UI form rendering
+     */
+    configSchema: {
+        schema: {
+            type: string;
+            properties: {
+                enabled: {
+                    type: string;
+                    default: boolean;
+                    description: string;
+                };
+                wsUrl1: {
+                    type: string;
+                    default: string;
+                    description: string;
+                };
+                wsUrl2: {
+                    type: string;
+                    default: string;
+                    description: string;
+                };
+                ak: {
+                    type: string;
+                    description: string;
+                };
+                sk: {
+                    type: string;
+                    description: string;
+                };
+                agentId: {
+                    type: string;
+                    description: string;
+                };
+                debug: {
+                    type: string;
+                    default: boolean;
+                    description: string;
+                };
+                apiId: {
+                    type: string;
+                    default: string;
+                    description: string;
+                };
+                pushId: {
+                    type: string;
+                    default: string;
+                    description: string;
+                };
+                taskTimeoutMs: {
+                    type: string;
+                    default: number;
+                    description: string;
+                };
+            };
+        };
+    };
     onboarding: any;
     /**
      * Config adapter - single account mode

package/dist/channel.js

@@ -32,6 +32,63 @@ exports.xiaoyiPlugin = {
         media: true,
         nativeCommands: false,
     },
+    /**
+     * Config schema for UI form rendering
+     */
+    configSchema: {
+        schema: {
+            type: "object",
+            properties: {
+                enabled: {
+                    type: "boolean",
+                    default: false,
+                    description: "Enable XiaoYi channel",
+                },
+                wsUrl1: {
+                    type: "string",
+                    default: "wss://hag.cloud.huawei.com/openclaw/v1/ws/link",
+                    description: "Primary WebSocket server URL",
+                },
+                wsUrl2: {
+                    type: "string",
+                    default: "wss://116.63.174.231/openclaw/v1/ws/link",
+                    description: "Secondary WebSocket server URL",
+                },
+                ak: {
+                    type: "string",
+                    description: "Access Key",
+                },
+                sk: {
+                    type: "string",
+                    description: "Secret Key",
+                },
+                agentId: {
+                    type: "string",
+                    description: "Agent ID",
+                },
+                debug: {
+                    type: "boolean",
+                    default: false,
+                    description: "Enable debug logging",
+                },
+                apiId: {
+                    type: "string",
+                    default: "",
+                    description: "API ID for push notifications",
+                },
+                pushId: {
+                    type: "string",
+                    default: "",
+                    description: "Push ID for push notifications",
+                },
+                taskTimeoutMs: {
+                    type: "number",
+                    default: 3600000,
+                    description: "Task timeout in milliseconds (default: 1 hour)",
+                },
+            },
+        },
+    },
     onboarding: onboarding_1.xiaoyiOnboardingAdapter,
     /**
      * Config adapter - single account mode
@@ -251,10 +308,13 @@ exports.xiaoyiPlugin = {
                     // where the outer scope's resolvedAccount might become unavailable
                     const messageHandlerAgentId = resolvedAccount.config?.agentId;
                     const messageHandlerAccountId = resolvedAccount.accountId;
+                    const messageHandlerConfig = resolvedAccount.config;
                     if (!messageHandlerAgentId) {
                         console.error("XiaoYi: [FATAL] agentId not available in resolvedAccount.config");
                         return;
                     }
+                    // Set task timeout time from configuration
+                    runtime.setTaskTimeout(messageHandlerConfig.taskTimeoutMs || 3600000);
                     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;
@@ -418,7 +478,6 @@ exports.xiaoyiPlugin = {
                         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 abortControllerResult = runtime.createAbortControllerForSession(sessionId);
@@ -428,24 +487,62 @@ exports.xiaoyiPlugin = {
                         }
                         const { controller: abortController, signal: abortSignal } = abortControllerResult;
                         // ================================================================
-                        // ==================== START TIMEOUT PROTECTION ====================
-                        // Start periodic 60-second timeout timer
-                        // Will trigger every 60 seconds until a response is received or session completes
+                        // ==================== 1-HOUR TASK TIMEOUT PROTECTION ====================
+                        // Start 1-hour task timeout timer
+                        // Will trigger once after 1 hour if no response received
+                        console.log(`[TASK TIMEOUT] Starting ${messageHandlerConfig.taskTimeoutMs || 3600000}ms task timeout protection for session ${sessionId}`);
+                        // Define task timeout handler (will be called once after 1 hour)
+                        const createTaskTimeoutHandler = () => {
+                            return async (timeoutSessionId, timeoutTaskId) => {
+                                const elapsed = Date.now() - startTime;
+                                console.log("\n" + "=".repeat(60));
+                                console.log(`[TASK TIMEOUT] 1-hour timeout triggered for session ${sessionId}`);
+                                console.log(`  Elapsed: ${elapsed}ms`);
+                                console.log(`  Task ID: ${currentTaskId}`);
+                                console.log("=".repeat(60) + "\n");
+                                const conn = runtime.getConnection();
+                                if (conn) {
+                                    try {
+                                        // Send default message with isFinal=true
+                                        await conn.sendResponse({
+                                            sessionId: timeoutSessionId,
+                                            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",
+                                        }, timeoutTaskId, timeoutSessionId, true, false); // isFinal=true
+                                        console.log(`[TASK TIMEOUT] Default message sent (isFinal=true) to session ${timeoutSessionId}\n`);
+                                    }
+                                    catch (error) {
+                                        console.error(`[TASK TIMEOUT] Failed to send default message:`, error);
+                                    }
+                                }
+                                // Cancel 60-second periodic timeout
+                                runtime.clearSessionTimeout(timeoutSessionId);
+                                // Mark as waiting for push state
+                                runtime.markSessionWaitingForPush(timeoutSessionId, timeoutTaskId);
+                            };
+                        };
+                        // Start 1-hour task timeout timer
+                        runtime.setTaskTimeoutForSession(sessionId, currentTaskId, createTaskTimeoutHandler());
+                        // Also start 60-second periodic timeout for status updates (for messages before 1-hour timeout)
                         const timeoutConfig = runtime.getTimeoutConfig();
-                        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 = () => {
+                        const createPeriodicTimeoutHandler = () => {
                             return async () => {
+                                // Skip if already waiting for push (1-hour timeout already triggered)
+                                if (runtime.isSessionWaitingForPush(sessionId, currentTaskId)) {
+                                    return;
+                                }
                                 const elapsed = Date.now() - startTime;
                                 console.log("\n" + "=".repeat(60));
-                                console.log(`[TIMEOUT] Timeout triggered for session ${sessionId}`);
+                                console.log(`[TIMEOUT] Periodic timeout triggered for session ${sessionId}`);
                                 console.log(`  Elapsed: ${elapsed}ms`);
-                                console.log(`  Task ID: ${currentTaskId}`);
                                 console.log("=".repeat(60) + "\n");
                                 const conn = runtime.getConnection();
                                 if (conn) {
                                     try {
-                                        // 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`);
                                     }
@@ -453,18 +550,15 @@ exports.xiaoyiPlugin = {
                                         console.error(`[TIMEOUT] Failed to send status update:`, error);
                                     }
                                 }
-                                else {
-                                    console.error(`[TIMEOUT] Connection not available, cannot send status update\n`);
-                                }
-                                // Note: Timeout will trigger again in 60 seconds if still active
                             };
                         };
-                        // Start periodic timeout
-                        runtime.setTimeoutForSession(sessionId, createTimeoutHandler());
-                        // ==================== END TIMEOUT PROTECTION ====================
+                        runtime.setTimeoutForSession(sessionId, createPeriodicTimeoutHandler());
+                        // ==================== END TASK TIMEOUT PROTECTION ====================
                         // ==================== CREATE STREAMING DISPATCHER ====================
-                        // Use createReplyDispatcherWithTyping for real-time streaming feedback
-                        const { dispatcher, replyOptions, markDispatchIdle } = pluginRuntime.channel.reply.createReplyDispatcherWithTyping({
+                        // ==================== DISPATCHER OPTIONS ====================
+                        // Define dispatcher options for dispatchInboundMessageWithBufferedDispatcher
+                        // This uses the standard OpenClaw pattern which properly handles dispatcher lifecycle
+                        const dispatcherOptions = {
                             humanDelay: 0,
                             onReplyStart: async () => {
                                 const elapsed = Date.now() - startTime;
@@ -494,6 +588,11 @@ exports.xiaoyiPlugin = {
                                 // 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";
+                                // If session is waiting for push (1-hour timeout occurred), ignore non-final responses
+                                if (runtime.isSessionWaitingForPush(sessionId, currentTaskId) && !payload.queuedFinal && info.kind !== "final") {
+                                    console.log(`[TASK TIMEOUT] Ignoring non-final response for session ${sessionId} (already timed out)`);
+                                    return;
+                                }
                                 accumulatedText = text;
                                 console.log("\n" + "█".repeat(70));
                                 console.log("📨 [DELIVER] Payload received");
@@ -547,7 +646,12 @@ exports.xiaoyiPlugin = {
                                 // ==================== END FIX ====================
                                 const responseStatus = isFinal ? "success" : "processing";
                                 const incrementalText = text.slice(sentTextLength);
-                                const isAppend = !isFinal && incrementalText.length > 0;
+                                // ==================== FIX: Always send isFinal=false in deliver ====================
+                                // All responses from deliver callback are sent with isFinal=false
+                                // The final isFinal=true will be sent in onIdle callback when ALL processing is complete
+                                const shouldSendFinal = false;
+                                // Always use append=true for all responses
+                                const isAppend = true;
                                 if (incrementalText.length > 0 || isFinal) {
                                     console.log("\n" + "-".repeat(60));
                                     console.log("XiaoYi: [STREAM] Sending response");
@@ -571,16 +675,9 @@ exports.xiaoyiPlugin = {
                                         },
                                         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;
-                                        }
+                                        console.log("✓ Sent (status=" + responseStatus + ", isFinal=false, append=" + isAppend + ")\n");
                                     }
                                     catch (error) {
                                         console.error("✗ Failed to send:", error);
@@ -606,7 +703,14 @@ exports.xiaoyiPlugin = {
                                 console.error("XiaoYi: [ERROR] " + info.kind + " failed: " + String(err));
                                 console.log("=".repeat(60) + "\n");
                                 runtime.clearSessionTimeout(sessionId);
+                                runtime.clearTaskTimeoutForSession(sessionId);
+                                runtime.clearSessionWaitingForPush(sessionId, currentTaskId);
                                 runtime.clearAbortControllerForSession(sessionId);
+                                // Check if session was cleared
+                                const conn = runtime.getConnection();
+                                if (conn && conn.isSessionPendingCleanup(sessionId)) {
+                                    conn.forceCleanupSession(sessionId);
+                                }
                                 runtime.markSessionCompleted(sessionId);
                             },
                             onIdle: async () => {
@@ -615,27 +719,101 @@ exports.xiaoyiPlugin = {
                                 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 ====================
+                                // Clear 1-hour task timeout timer
+                                runtime.clearTaskTimeoutForSession(sessionId);
+                                // ==================== CHECK IF SESSION WAS CLEARED ====================
+                                const conn = runtime.getConnection();
+                                const isPendingCleanup = conn && conn.isSessionPendingCleanup(sessionId);
+                                const isWaitingForPush = runtime.isSessionWaitingForPush(sessionId, currentTaskId);
+                                // ==================== PUSH NOTIFICATION LOGIC ====================
+                                // Send push if task timeout was triggered (regardless of session cleanup status)
+                                // This ensures users get notified when long-running tasks complete
+                                if (isWaitingForPush && accumulatedText.length > 0) {
+                                    const pushReason = isPendingCleanup
+                                        ? `Session ${sessionId} was cleared`
+                                        : `Session ${sessionId} task timeout triggered`;
+                                    console.log(`[CLEANUP] ${pushReason}, sending push notification`);
+                                    try {
+                                        const { XiaoYiPushService } = require("./push");
+                                        const pushService = new XiaoYiPushService(messageHandlerConfig);
+                                        if (pushService.isConfigured()) {
+                                            // Generate summary
+                                            const summary = accumulatedText.length > 30
+                                                ? accumulatedText.substring(0, 30) + "..."
+                                                : accumulatedText;
+                                            await pushService.sendPush(summary, "后台任务已完成：" + summary);
+                                            console.log("✓ [CLEANUP] Push notification sent\n");
+                                            // Clear push waiting state for this specific task
+                                            runtime.clearSessionWaitingForPush(sessionId, currentTaskId);
+                                        }
+                                        else {
+                                            console.log("[CLEANUP] Push not configured, skipping notification");
+                                            runtime.clearSessionWaitingForPush(sessionId, currentTaskId);
+                                        }
+                                    }
+                                    catch (error) {
+                                        console.error("[CLEANUP] Error sending push:", error);
+                                        runtime.clearSessionWaitingForPush(sessionId, currentTaskId);
+                                    }
+                                    // If session was cleared, update cleanup state
+                                    if (isPendingCleanup) {
+                                        conn?.updateAccumulatedTextForCleanup(sessionId, accumulatedText);
+                                        conn?.forceCleanupSession(sessionId);
+                                    }
+                                }
+                                // ==================== NORMAL WEBSOCKET FLOW (no timeout triggered) ====================
+                                else if (!isPendingCleanup) {
+                                    // Normal flow: send WebSocket response (no timeout, session still active)
+                                    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: accumulatedText,
+                                                },
+                                                status: "success",
+                                            }, currentTaskId, sessionId, true, true); // isFinal=true, append=true
+                                            console.log("✓ [IDLE] Final response sent (isFinal=true)\n");
+                                        }
+                                        catch (error) {
+                                            console.error("✗ [IDLE] Failed to send final response:", error);
+                                        }
+                                    }
+                                }
+                                // ==================== SESSION CLEARED BUT NO TIMEOUT ====================
+                                else {
+                                    // Session was cleared but no timeout triggered - edge case, just cleanup
+                                    console.log(`[CLEANUP] Session ${sessionId} was cleared but no push needed`);
+                                    conn?.forceCleanupSession(sessionId);
+                                }
                                 // 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({
+                            // Use standard OpenClaw pattern with dispatchReplyWithBufferedBlockDispatcher
+                            // This properly handles dispatcher lifecycle:
+                            // 1. Calls dispatcher.markComplete() after run() completes
+                            // 2. Waits for waitForIdle() to ensure all deliveries are done
+                            // 3. Then calls markDispatchIdle() in the finally block
+                            const result = await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
                                 ctx: msgContext,
                                 cfg: config,
-                                dispatcher,
+                                dispatcherOptions: dispatcherOptions,
                                 replyOptions: {
-                                    ...replyOptions,
                                     abortSignal: abortSignal,
                                 },
                             });
@@ -687,7 +865,7 @@ exports.xiaoyiPlugin = {
                                             status: "success",
                                         };
                                         // Send response with isFinal=true to close THIS request
-                                        await conn.sendResponse(response, currentTaskId, sessionId, true, false);
+                                        await conn.sendResponse(response, currentTaskId, sessionId, true, true);
                                         console.log("✓ [NO OUTPUT] Response sent to user\n");
                                     }
                                     catch (error) {
@@ -698,14 +876,16 @@ exports.xiaoyiPlugin = {
                                 // 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();
+                                // Note: No need to call markDispatchIdle() manually
+                                // dispatchInboundMessageWithBufferedDispatcher handles this in its finally block
                             }
                             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();
+                                // Note: No need to call markDispatchIdle() manually
+                                // dispatchInboundMessageWithBufferedDispatcher handles this in its finally block
                             }
                             // ==================== END ANALYSIS ====================
                         }
@@ -713,12 +893,14 @@ exports.xiaoyiPlugin = {
                             console.error("XiaoYi: [ERROR] Error dispatching message:", error);
                             // Clear timeout on error
                             runtime.clearSessionTimeout(sessionId);
+                            runtime.clearTaskTimeoutForSession(sessionId);
+                            runtime.clearSessionWaitingForPush(sessionId, currentTaskId);
                             // 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();
+                            // Note: No need to call markDispatchIdle() manually
+                            // dispatchInboundMessageWithBufferedDispatcher handles this in its finally block
                         }
                     }
                     catch (error) {
@@ -742,9 +924,33 @@ exports.xiaoyiPlugin = {
                     else {
                         console.log(`[CANCEL] No active agent run found for session ${sessionId}`);
                     }
-                    // Clear timeout as the session is being canceled
+                    // Clear timeout and push state as the session is being canceled
+                    runtime.clearTaskTimeoutForSession(sessionId);
+                    runtime.clearSessionWaitingForPush(sessionId, data.taskId);
                     runtime.markSessionCompleted(sessionId);
                 });
+                // Handle clear context events
+                connection.on("clear", async (data) => {
+                    const { sessionId, serverId } = data;
+                    console.log("\n" + "=".repeat(60));
+                    console.log("[CLEAR] Context cleared by user");
+                    console.log(`  Session: ${sessionId}`);
+                    console.log("=".repeat(60) + "\n");
+                    // Check if there's an active task for this session
+                    const hasActiveTask = runtime.isSessionActive(sessionId);
+                    if (hasActiveTask) {
+                        console.log(`[CLEAR] Active task exists for session ${sessionId}, will continue in background`);
+                        // Session is already marked for cleanup in websocket.ts
+                        // Just track that we're waiting for completion
+                    }
+                    else {
+                        console.log(`[CLEAR] No active task for session ${sessionId}, clean up immediately`);
+                        const conn = runtime.getConnection();
+                        if (conn) {
+                            conn.forceCleanupSession(sessionId);
+                        }
+                    }
+                });
                 // Mark handlers as registered to prevent duplicate registration
                 handlersRegistered = true;
             }

package/dist/config-schema.d.ts

@@ -8,8 +8,10 @@ export declare const XiaoYiConfigSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     /** Whether this channel is enabled */
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** WebSocket URL for A2A connection */
-    wsUrl: z.ZodOptional<z.ZodString>;
+    /** First WebSocket server URL */
+    wsUrl1: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    /** Second WebSocket server URL */
+    wsUrl2: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     /** Access Key for authentication */
     ak: z.ZodOptional<z.ZodString>;
     /** Secret Key for authentication */
@@ -18,27 +20,25 @@ export declare const XiaoYiConfigSchema: z.ZodObject<{
     agentId: z.ZodOptional<z.ZodString>;
     /** Enable debug logging */
     debug: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** Enable streaming responses (default: false) */
-    enableStreaming: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     /** Multi-account configuration */
     accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     enabled?: boolean;
-    wsUrl?: string;
+    wsUrl1?: string;
+    wsUrl2?: string;
     ak?: string;
     sk?: string;
     agentId?: string;
-    enableStreaming?: boolean;
     name?: string;
     debug?: boolean;
     accounts?: Record<string, unknown>;
 }, {
     enabled?: boolean;
-    wsUrl?: string;
+    wsUrl1?: string;
+    wsUrl2?: string;
     ak?: string;
     sk?: string;
     agentId?: string;
-    enableStreaming?: boolean;
     name?: string;
     debug?: boolean;
     accounts?: Record<string, unknown>;

package/dist/config-schema.js

@@ -10,9 +10,11 @@ exports.XiaoYiConfigSchema = zod_1.z.object({
     /** Account name (optional display name) */
     name: zod_1.z.string().optional(),
     /** Whether this channel is enabled */
-    enabled: zod_1.z.boolean().optional().default(true),
-    /** WebSocket URL for A2A connection */
-    wsUrl: zod_1.z.string().optional(),
+    enabled: zod_1.z.boolean().optional().default(false),
+    /** First WebSocket server URL */
+    wsUrl1: zod_1.z.string().optional().default("wss://hag.cloud.huawei.com/openclaw/v1/ws/link"),
+    /** Second WebSocket server URL */
+    wsUrl2: zod_1.z.string().optional().default("wss://116.63.174.231/openclaw/v1/ws/link"),
     /** Access Key for authentication */
     ak: zod_1.z.string().optional(),
     /** Secret Key for authentication */
@@ -21,8 +23,6 @@ exports.XiaoYiConfigSchema = zod_1.z.object({
     agentId: zod_1.z.string().optional(),
     /** Enable debug logging */
     debug: zod_1.z.boolean().optional().default(false),
-    /** Enable streaming responses (default: false) */
-    enableStreaming: zod_1.z.boolean().optional().default(false),
     /** Multi-account configuration */
     accounts: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
 });

package/dist/index.d.ts

@@ -14,13 +14,10 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
  *       "wsUrl2": "ws://localhost:8766/ws/link",
  *       "ak": "test_ak",
  *       "sk": "test_sk",
- *       "agentId": "your-agent-id",
- *       "enableStreaming": true
+ *       "agentId": "your-agent-id"
  *     }
  *   }
  * }
- *
- * Backward compatibility: Can use "wsUrl" instead of "wsUrl1" (wsUrl2 will use default)
  */
 declare const plugin: {
     id: string;

package/dist/index.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const plugin_sdk_1 = require("openclaw/plugin-sdk");
 const channel_1 = require("./channel");
 const runtime_1 = require("./runtime");
 /**
@@ -18,19 +17,16 @@ const runtime_1 = require("./runtime");
  *       "wsUrl2": "ws://localhost:8766/ws/link",
  *       "ak": "test_ak",
  *       "sk": "test_sk",
- *       "agentId": "your-agent-id",
- *       "enableStreaming": true
+ *       "agentId": "your-agent-id"
  *     }
  *   }
  * }
- *
- * Backward compatibility: Can use "wsUrl" instead of "wsUrl1" (wsUrl2 will use default)
  */
 const plugin = {
     id: "xiaoyi",
     name: "XiaoYi Channel",
     description: "XiaoYi channel plugin with A2A protocol support",
-    configSchema: (0, plugin_sdk_1.emptyPluginConfigSchema)(),
+    configSchema: undefined,
     register(api) {
         console.log("XiaoYi: register() called - START");
         // Set runtime for managing WebSocket connections

package/dist/push.d.ts

@@ -0,0 +1,28 @@
+import { XiaoYiChannelConfig } from "./types";
+/**
+ * Push message sending service
+ * Sends notifications to XiaoYi clients via webhook API
+ */
+export declare class XiaoYiPushService {
+    private config;
+    private readonly pushUrl;
+    constructor(config: XiaoYiChannelConfig);
+    /**
+     * Check if push functionality is configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Generate HMAC-SHA256 signature
+     */
+    private generateSignature;
+    /**
+     * Generate UUID
+     */
+    private generateUUID;
+    /**
+     * Send push notification (with summary text)
+     * @param text - Summary text to send (e.g., first 30 characters)
+     * @param pushText - Push notification message (e.g., "任务已完成：xxx...")
+     */
+    sendPush(text: string, pushText: string): Promise<boolean>;
+}

package/dist/push.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XiaoYiPushService = void 0;
+const crypto = __importStar(require("crypto"));
+/**
+ * Push message sending service
+ * Sends notifications to XiaoYi clients via webhook API
+ */
+class XiaoYiPushService {
+    constructor(config) {
+        this.pushUrl = "https://hag.cloud.huawei.com/open-ability-agent/v1/agent-webhook";
+        this.config = config;
+    }
+    /**
+     * Check if push functionality is configured
+     */
+    isConfigured() {
+        return Boolean(this.config.apiId?.trim() &&
+            this.config.pushId?.trim() &&
+            this.config.ak?.trim() &&
+            this.config.sk?.trim());
+    }
+    /**
+     * Generate HMAC-SHA256 signature
+     */
+    generateSignature(timestamp) {
+        const hmac = crypto.createHmac("sha256", this.config.sk);
+        hmac.update(timestamp);
+        return hmac.digest().toString("base64");
+    }
+    /**
+     * Generate UUID
+     */
+    generateUUID() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    /**
+     * Send push notification (with summary text)
+     * @param text - Summary text to send (e.g., first 30 characters)
+     * @param pushText - Push notification message (e.g., "任务已完成：xxx...")
+     */
+    async sendPush(text, pushText) {
+        if (!this.isConfigured()) {
+            console.log("[PUSH] Push not configured, skipping");
+            return false;
+        }
+        try {
+            const timestamp = Date.now().toString();
+            const signature = this.generateSignature(timestamp);
+            const messageId = this.generateUUID();
+            const payload = {
+                jsonrpc: "2.0",
+                id: messageId,
+                result: {
+                    id: this.generateUUID(),
+                    apiId: this.config.apiId,
+                    pushId: this.config.pushId,
+                    pushText: pushText,
+                    kind: "task",
+                    artifacts: [{
+                            artifactId: this.generateUUID(),
+                            parts: [{
+                                    kind: "text",
+                                    text: text, // Summary text
+                                }]
+                        }],
+                    status: { state: "completed" }
+                }
+            };
+            console.log(`[PUSH] Sending push notification: ${pushText}`);
+            const response = await fetch(this.pushUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Accept": "application/json",
+                    "x-hag-trace-id": this.generateUUID(),
+                    "X-Access-Key": this.config.ak,
+                    "X-Sign": signature,
+                    "X-Ts": timestamp,
+                },
+                body: JSON.stringify(payload),
+            });
+            if (response.ok) {
+                console.log("[PUSH] Push notification sent successfully");
+                return true;
+            }
+            else {
+                console.error(`[PUSH] Failed: HTTP ${response.status}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("[PUSH] Error:", error);
+            return false;
+        }
+    }
+}
+exports.XiaoYiPushService = XiaoYiPushService;

package/dist/runtime.d.ts

@@ -23,6 +23,11 @@ export declare class XiaoYiRuntime {
     private timeoutConfig;
     private sessionAbortControllerMap;
     private sessionActiveRunMap;
+    private sessionStartTimeMap;
+    private static readonly SESSION_STALE_TIMEOUT_MS;
+    private sessionTaskTimeoutMap;
+    private sessionPushPendingMap;
+    private taskTimeoutMs;
     constructor();
     getInstanceId(): string;
     /**
@@ -115,6 +120,7 @@ export declare class XiaoYiRuntime {
     } | null;
     /**
      * Check if a session has an active agent run
+     * If session is active but stale (超过 SESSION_STALE_TIMEOUT_MS), automatically clean up
      * @param sessionId - Session ID
      * @returns true if session is busy
      */
@@ -140,6 +146,46 @@ export declare class XiaoYiRuntime {
      * Clear all AbortControllers
      */
     clearAllAbortControllers(): void;
+    /**
+     * Generate a composite key for session+task combination
+     * This ensures each task has its own push state, even within the same session
+     */
+    private getPushStateKey;
+    /**
+     * Set task timeout time (from configuration)
+     */
+    setTaskTimeout(timeoutMs: number): void;
+    /**
+     * Set a 1-hour task timeout timer for a session
+     * @returns timeout ID
+     */
+    setTaskTimeoutForSession(sessionId: string, taskId: string, callback: (sessionId: string, taskId: string) => void): NodeJS.Timeout;
+    /**
+     * Clear the task timeout timer for a session
+     */
+    clearTaskTimeoutForSession(sessionId: string): void;
+    /**
+     * Check if session+task is waiting for push notification
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    isSessionWaitingForPush(sessionId: string, taskId?: string): boolean;
+    /**
+     * Mark session+task as waiting for push notification
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    markSessionWaitingForPush(sessionId: string, taskId?: string): void;
+    /**
+     * Clear the waiting push state for a session+task
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    clearSessionWaitingForPush(sessionId: string, taskId?: string): void;
+    /**
+     * Clear all task timeout related state for a session
+     */
+    clearTaskTimeoutState(sessionId: string): void;
 }
 export declare function getXiaoYiRuntime(): XiaoYiRuntime;
 export declare function setXiaoYiRuntime(runtime: any): void;

package/dist/runtime.js

@@ -30,6 +30,12 @@ class XiaoYiRuntime {
         this.sessionAbortControllerMap = new Map();
         // Track if a session has an active agent run (for concurrent request detection)
         this.sessionActiveRunMap = new Map();
+        // Track session start time for timeout detection
+        this.sessionStartTimeMap = new Map();
+        // 1-hour task timeout mechanism
+        this.sessionTaskTimeoutMap = new Map();
+        this.sessionPushPendingMap = new Map();
+        this.taskTimeoutMs = 3600000; // Default 1 hour
         this.instanceId = `runtime_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         console.log(`XiaoYi: Created new runtime instance: ${this.instanceId}`);
     }
@@ -106,6 +112,10 @@ class XiaoYiRuntime {
         this.clearAllTimeouts();
         // Clear all abort controllers
         this.clearAllAbortControllers();
+        // Clear all task timeout state
+        for (const sessionId of this.sessionTaskTimeoutMap.keys()) {
+            this.clearTaskTimeoutState(sessionId);
+        }
     }
     /**
      * Set timeout configuration
@@ -246,16 +256,35 @@ class XiaoYiRuntime {
         const controller = new AbortController();
         this.sessionAbortControllerMap.set(sessionId, controller);
         this.sessionActiveRunMap.set(sessionId, true);
+        this.sessionStartTimeMap.set(sessionId, Date.now());
         console.log(`[ABORT] Created AbortController for session ${sessionId}`);
         return { controller, signal: controller.signal };
     }
     /**
      * Check if a session has an active agent run
+     * If session is active but stale (超过 SESSION_STALE_TIMEOUT_MS), automatically clean up
      * @param sessionId - Session ID
      * @returns true if session is busy
      */
     isSessionActive(sessionId) {
-        return this.sessionActiveRunMap.get(sessionId) || false;
+        const isActive = this.sessionActiveRunMap.get(sessionId) || false;
+        if (isActive) {
+            // Check if the session has been active for too long
+            const startTime = this.sessionStartTimeMap.get(sessionId);
+            if (startTime) {
+                const elapsed = Date.now() - startTime;
+                if (elapsed > XiaoYiRuntime.SESSION_STALE_TIMEOUT_MS) {
+                    // Session is stale, auto-cleanup and return false
+                    console.log(`[CONCURRENT] Session ${sessionId} is stale (active for ${elapsed}ms), auto-cleaning`);
+                    this.clearAbortControllerForSession(sessionId);
+                    this.clearTaskIdForSession(sessionId);
+                    this.clearSessionTimeout(sessionId);
+                    this.sessionStartTimeMap.delete(sessionId);
+                    return false;
+                }
+            }
+        }
+        return isActive;
     }
     /**
      * Abort a session's agent run
@@ -294,6 +323,8 @@ class XiaoYiRuntime {
         }
         // Also clear the active run flag
         this.sessionActiveRunMap.delete(sessionId);
+        // Clear the session start time
+        this.sessionStartTimeMap.delete(sessionId);
         console.log(`[CONCURRENT] Session ${sessionId} marked as inactive`);
     }
     /**
@@ -303,8 +334,91 @@ class XiaoYiRuntime {
         this.sessionAbortControllerMap.clear();
         console.log("[ABORT] All AbortControllers cleared");
     }
+    // ==================== PUSH STATE MANAGEMENT HELPERS ====================
+    /**
+     * Generate a composite key for session+task combination
+     * This ensures each task has its own push state, even within the same session
+     */
+    getPushStateKey(sessionId, taskId) {
+        return `${sessionId}:${taskId}`;
+    }
+    // ==================== END PUSH STATE MANAGEMENT HELPERS ====================
+    // ==================== 1-HOUR TASK TIMEOUT METHODS ====================
+    /**
+     * Set task timeout time (from configuration)
+     */
+    setTaskTimeout(timeoutMs) {
+        this.taskTimeoutMs = timeoutMs;
+        console.log(`[TASK TIMEOUT] Task timeout set to ${timeoutMs}ms`);
+    }
+    /**
+     * Set a 1-hour task timeout timer for a session
+     * @returns timeout ID
+     */
+    setTaskTimeoutForSession(sessionId, taskId, callback) {
+        this.clearTaskTimeoutForSession(sessionId);
+        const timeoutId = setTimeout(() => {
+            console.log(`[TASK TIMEOUT] ${this.taskTimeoutMs}ms timeout triggered for session ${sessionId}, task ${taskId}`);
+            callback(sessionId, taskId);
+        }, this.taskTimeoutMs);
+        this.sessionTaskTimeoutMap.set(sessionId, timeoutId);
+        console.log(`[TASK TIMEOUT] ${this.taskTimeoutMs}ms task timeout started for session ${sessionId}`);
+        return timeoutId;
+    }
+    /**
+     * Clear the task timeout timer for a session
+     */
+    clearTaskTimeoutForSession(sessionId) {
+        const timeoutId = this.sessionTaskTimeoutMap.get(sessionId);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            this.sessionTaskTimeoutMap.delete(sessionId);
+            console.log(`[TASK TIMEOUT] Timeout cleared for session ${sessionId}`);
+        }
+    }
+    /**
+     * Check if session+task is waiting for push notification
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    isSessionWaitingForPush(sessionId, taskId) {
+        const key = taskId ? this.getPushStateKey(sessionId, taskId) : sessionId;
+        return this.sessionPushPendingMap.get(key) === true;
+    }
+    /**
+     * Mark session+task as waiting for push notification
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    markSessionWaitingForPush(sessionId, taskId) {
+        const key = taskId ? this.getPushStateKey(sessionId, taskId) : sessionId;
+        this.sessionPushPendingMap.set(key, true);
+        const taskInfo = taskId ? `, task ${taskId}` : '';
+        console.log(`[PUSH] Session ${sessionId}${taskInfo} marked as waiting for push`);
+    }
+    /**
+     * Clear the waiting push state for a session+task
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    clearSessionWaitingForPush(sessionId, taskId) {
+        const key = taskId ? this.getPushStateKey(sessionId, taskId) : sessionId;
+        this.sessionPushPendingMap.delete(key);
+        const taskInfo = taskId ? `, task ${taskId}` : '';
+        console.log(`[PUSH] Session ${sessionId}${taskInfo} cleared from waiting for push`);
+    }
+    /**
+     * Clear all task timeout related state for a session
+     */
+    clearTaskTimeoutState(sessionId) {
+        this.clearTaskTimeoutForSession(sessionId);
+        this.clearSessionWaitingForPush(sessionId);
+        console.log(`[TASK TIMEOUT] All timeout state cleared for session ${sessionId}`);
+    }
 }
 exports.XiaoYiRuntime = XiaoYiRuntime;
+// Maximum time a session can be active before we consider it stale (5 minutes)
+XiaoYiRuntime.SESSION_STALE_TIMEOUT_MS = 5 * 60 * 1000;
 // Global runtime instance - use global object to survive module reloads
 // CRITICAL: Use string key instead of Symbol to ensure consistency across module reloads
 const GLOBAL_KEY = '__xiaoyi_runtime_instance__';

package/dist/types.d.ts

@@ -152,6 +152,15 @@ export interface XiaoYiChannelConfig {
     sk: string;
     agentId: string;
     enableStreaming?: boolean;
+    apiId?: string;
+    pushId?: string;
+    taskTimeoutMs?: number;
+    /**
+     * Session cleanup timeout in milliseconds
+     * When user clears context, old sessions are cleaned up after this timeout
+     * Default: 1 hour (60 * 60 * 1000)
+     */
+    sessionCleanupTimeoutMs?: number;
 }
 export interface AuthCredentials {
     ak: string;
@@ -176,6 +185,7 @@ export interface InternalWebSocketConfig {
     ak: string;
     sk: string;
     enableStreaming?: boolean;
+    sessionCleanupTimeoutMs?: number;
 }
 export type ServerId = 'server1' | 'server2';
 export interface ServerConnectionState {
@@ -184,3 +194,14 @@ export interface ServerConnectionState {
     lastHeartbeat: number;
     reconnectAttempts: number;
 }
+/**
+ * Session cleanup state for delayed cleanup
+ */
+export interface SessionCleanupState {
+    sessionId: string;
+    serverId: ServerId;
+    markedForCleanupAt: number;
+    cleanupTimeoutId?: NodeJS.Timeout;
+    reason: 'user_cleared' | 'timeout' | 'error';
+    accumulatedText?: string;
+}

package/dist/websocket.d.ts

@@ -1,11 +1,13 @@
 import { EventEmitter } from "events";
-import { A2AResponseMessage, WebSocketConnectionState, XiaoYiChannelConfig, ServerId, ServerConnectionState } from "./types";
+import { A2AResponseMessage, WebSocketConnectionState, XiaoYiChannelConfig, ServerId, ServerConnectionState, SessionCleanupState } from "./types";
 export declare class XiaoYiWebSocketManager extends EventEmitter {
     private ws1;
     private ws2;
     private state1;
     private state2;
     private sessionServerMap;
+    private sessionCleanupStateMap;
+    private static readonly DEFAULT_CLEANUP_TIMEOUT_MS;
     private auth;
     private config;
     private heartbeatTimeout1?;
@@ -176,4 +178,34 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
      * Remove session mapping
      */
     removeSession(sessionId: string): void;
+    /**
+     * Mark a session for delayed cleanup
+     * @param sessionId The session ID to mark for cleanup
+     * @param serverId The server ID associated with this session
+     * @param timeoutMs Timeout in milliseconds before forcing cleanup
+     */
+    private markSessionForCleanup;
+    /**
+     * Force cleanup a session immediately
+     * @param sessionId The session ID to cleanup
+     */
+    forceCleanupSession(sessionId: string): void;
+    /**
+     * Check if a session is pending cleanup
+     * @param sessionId The session ID to check
+     * @returns True if session is pending cleanup
+     */
+    isSessionPendingCleanup(sessionId: string): boolean;
+    /**
+     * Get cleanup state for a session
+     * @param sessionId The session ID to check
+     * @returns Cleanup state if exists, undefined otherwise
+     */
+    getSessionCleanupState(sessionId: string): SessionCleanupState | undefined;
+    /**
+     * Update accumulated text for a pending cleanup session
+     * @param sessionId The session ID
+     * @param text The accumulated text
+     */
+    updateAccumulatedTextForCleanup(sessionId: string, text: string): void;
 }

package/dist/websocket.js

@@ -30,6 +30,9 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         };
         // ==================== Session → Server Mapping ====================
         this.sessionServerMap = new Map();
+        // ==================== Session Cleanup State ====================
+        // Track sessions that are pending cleanup (user cleared context but task still running)
+        this.sessionCleanupStateMap = new Map();
         // ==================== Active Tasks ====================
         this.activeTasks = new Map();
         // Resolve configuration with defaults and backward compatibility
@@ -107,6 +110,7 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             ak: userConfig.ak,
             sk: userConfig.sk,
             enableStreaming: userConfig.enableStreaming ?? true,
+            sessionCleanupTimeoutMs: userConfig.sessionCleanupTimeoutMs ?? XiaoYiWebSocketManager.DEFAULT_CLEANUP_TIMEOUT_MS,
         };
     }
     /**
@@ -245,6 +249,13 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         this.state2.ready = false;
         this.sessionServerMap.clear();
         this.activeTasks.clear();
+        // Cleanup session cleanup state map
+        for (const [sessionId, state] of this.sessionCleanupStateMap.entries()) {
+            if (state.cleanupTimeoutId) {
+                clearTimeout(state.cleanupTimeoutId);
+            }
+        }
+        this.sessionCleanupStateMap.clear();
         this.emit("disconnected");
     }
     /**
@@ -382,7 +393,14 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     /**
      * Send A2A response message with automatic routing
      */
-    async sendResponse(response, taskId, sessionId, isFinal = true, append = false) {
+    async sendResponse(response, taskId, sessionId, isFinal = true, append = true) {
+        // Check if session is pending cleanup
+        const cleanupState = this.sessionCleanupStateMap.get(sessionId);
+        if (cleanupState) {
+            // Session is pending cleanup, silently discard response
+            console.log(`[RESPONSE] Discarding response for pending cleanup session ${sessionId}`);
+            return;
+        }
         // Find which server this session belongs to
         const targetServer = this.sessionServerMap.get(sessionId);
         if (!targetServer) {
@@ -461,6 +479,13 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
      * This uses "status-update" event type which keeps the conversation active
      */
     async sendStatusUpdate(taskId, sessionId, message, targetServer) {
+        // Check if session is pending cleanup
+        const cleanupState = this.sessionCleanupStateMap.get(sessionId);
+        if (cleanupState) {
+            // Session is pending cleanup, silently discard status updates
+            console.log(`[STATUS] Discarding status update for pending cleanup session ${sessionId}`);
+            return;
+        }
         const serverId = targetServer || this.sessionServerMap.get(sessionId);
         if (!serverId) {
             console.error(`[STATUS] Unknown server for session ${sessionId}`);
@@ -591,8 +616,8 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             id: message.id,
             serverId: sourceServer,
         });
-        // Remove session mapping
-        this.sessionServerMap.delete(sessionId);
+        // Mark session for cleanup instead of immediate deletion
+        this.markSessionForCleanup(sessionId, sourceServer, this.config.sessionCleanupTimeoutMs ?? XiaoYiWebSocketManager.DEFAULT_CLEANUP_TIMEOUT_MS);
     }
     /**
      * Handle clear message (legacy format)
@@ -606,7 +631,8 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             id: message.id,
             serverId: sourceServer,
         });
-        this.sessionServerMap.delete(message.sessionId);
+        // Mark session for cleanup instead of immediate deletion
+        this.markSessionForCleanup(message.sessionId, sourceServer, this.config.sessionCleanupTimeoutMs ?? XiaoYiWebSocketManager.DEFAULT_CLEANUP_TIMEOUT_MS);
     }
     /**
      * Handle tasks/cancel message
@@ -636,7 +662,7 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     /**
      * Convert A2AResponseMessage to JSON-RPC 2.0 format
      */
-    convertToJsonRpcFormat(response, taskId, isFinal = true, append = false) {
+    convertToJsonRpcFormat(response, taskId, isFinal = true, append = true) {
         const artifactId = `artifact_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         if (response.status === "error" && response.error) {
             return {
@@ -650,9 +676,11 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         }
         const parts = [];
         if (response.content.type === "text" && response.content.text) {
+            // When isFinal=true, use empty string for text (no content needed for final chunk)
+            const textContent = isFinal ? "" : response.content.text;
             parts.push({
                 kind: "text",
-                text: response.content.text,
+                text: textContent,
             });
         }
         else if (response.content.type === "file") {
@@ -665,10 +693,11 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
                 },
             });
         }
+        // When isFinal=true, append should be true and text should be empty
         const artifactEvent = {
             taskId: taskId,
             kind: "artifact-update",
-            append: append,
+            append: isFinal ? true : append,
             lastChunk: isFinal,
             final: isFinal,
             artifact: {
@@ -918,6 +947,86 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     removeSession(sessionId) {
         this.sessionServerMap.delete(sessionId);
     }
+    /**
+     * Mark a session for delayed cleanup
+     * @param sessionId The session ID to mark for cleanup
+     * @param serverId The server ID associated with this session
+     * @param timeoutMs Timeout in milliseconds before forcing cleanup
+     */
+    markSessionForCleanup(sessionId, serverId, timeoutMs) {
+        // Check if already marked
+        const existingState = this.sessionCleanupStateMap.get(sessionId);
+        if (existingState) {
+            // Already pending cleanup, reset timeout
+            if (existingState.cleanupTimeoutId) {
+                clearTimeout(existingState.cleanupTimeoutId);
+            }
+            console.log(`[CLEANUP] Session ${sessionId} already pending cleanup, resetting timeout`);
+        }
+        // Create new cleanup state
+        const newState = {
+            sessionId,
+            serverId,
+            markedForCleanupAt: Date.now(),
+            reason: 'user_cleared',
+        };
+        // Start cleanup timeout
+        const timeoutId = setTimeout(() => {
+            console.log(`[CLEANUP] Timeout reached for session ${sessionId}, forcing cleanup`);
+            this.forceCleanupSession(sessionId);
+        }, timeoutMs);
+        newState.cleanupTimeoutId = timeoutId;
+        this.sessionCleanupStateMap.set(sessionId, newState);
+        console.log(`[CLEANUP] Session ${sessionId} marked for cleanup (timeout: ${timeoutMs}ms)`);
+    }
+    /**
+     * Force cleanup a session immediately
+     * @param sessionId The session ID to cleanup
+     */
+    forceCleanupSession(sessionId) {
+        // Check if already cleaned
+        const state = this.sessionCleanupStateMap.get(sessionId);
+        if (!state) {
+            console.log(`[CLEANUP] Session ${sessionId} already cleaned up, skipping`);
+            return;
+        }
+        // Clear timeout
+        if (state.cleanupTimeoutId) {
+            clearTimeout(state.cleanupTimeoutId);
+        }
+        // Remove from both maps
+        this.sessionServerMap.delete(sessionId);
+        this.sessionCleanupStateMap.delete(sessionId);
+        console.log(`[CLEANUP] Session ${sessionId} cleanup completed`);
+    }
+    /**
+     * Check if a session is pending cleanup
+     * @param sessionId The session ID to check
+     * @returns True if session is pending cleanup
+     */
+    isSessionPendingCleanup(sessionId) {
+        return this.sessionCleanupStateMap.has(sessionId);
+    }
+    /**
+     * Get cleanup state for a session
+     * @param sessionId The session ID to check
+     * @returns Cleanup state if exists, undefined otherwise
+     */
+    getSessionCleanupState(sessionId) {
+        return this.sessionCleanupStateMap.get(sessionId);
+    }
+    /**
+     * Update accumulated text for a pending cleanup session
+     * @param sessionId The session ID
+     * @param text The accumulated text
+     */
+    updateAccumulatedTextForCleanup(sessionId, text) {
+        const state = this.sessionCleanupStateMap.get(sessionId);
+        if (state) {
+            state.accumulatedText = text;
+        }
+    }
 }
 exports.XiaoYiWebSocketManager = XiaoYiWebSocketManager;
+XiaoYiWebSocketManager.DEFAULT_CLEANUP_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
 XiaoYiWebSocketManager.STABLE_CONNECTION_THRESHOLD = 10000; // 10 seconds

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi",
-  "version": "2.5.5",
+  "version": "2.5.6",
   "description": "XiaoYi channel plugin for OpenClaw",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -51,6 +51,7 @@
   "devDependencies": {
     "@types/node": "^20.11.0",
     "@types/ws": "^8.5.10",
+    "openclaw": "^2026.2.24",
     "typescript": "^5.3.3"
   },
   "files": [