@ynhcj/xiaoyi 2.4.2 → 2.4.4

package/dist/channel.js

@@ -330,44 +330,36 @@ exports.xiaoyiPlugin = {
                     // Start 60-second timeout timer
                     const timeoutConfig = runtime.getTimeoutConfig();
                     console.log(`[TIMEOUT] Starting ${timeoutConfig.duration}ms timeout protection for session ${sessionId}`);
-                    runtime.setTimeoutForSession(sessionId, async () => {
-                        // Timeout callback - send timeout message to user
-                        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("=".repeat(60) + "\n");
-                        const conn = runtime.getConnection();
-                        if (conn) {
-                            const timeoutResponse = {
-                                sessionId: sessionId,
-                                messageId: `timeout_${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: timeoutConfig.message,
-                                },
-                                status: "success",
-                            };
-                            try {
-                                await conn.sendResponse(timeoutResponse, taskId, sessionId, true, false);
-                                console.log(`[TIMEOUT] Timeout message sent successfully to session ${sessionId}\n`);
+                    // Define recursive timeout handler
+                    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("=".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);
+                                    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);
+                                }
                             }
-                            catch (error) {
-                                console.error(`[TIMEOUT] Failed to send timeout message:`, error);
+                            else {
+                                console.error(`[TIMEOUT] Connection not available, cannot send status update\n`);
                             }
-                        }
-                        else {
-                            console.error(`[TIMEOUT] Connection not available, cannot send timeout message\n`);
-                        }
-                    });
+                        };
+                    };
+                    // Start initial timeout
+                    runtime.setTimeoutForSession(sessionId, createTimeoutHandler());
                     // ==================== END TIMEOUT PROTECTION ====================
                     await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
                         ctx: msgContext,

package/dist/websocket.d.ts

@@ -70,6 +70,11 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
      * Send clear context response to specific server
      */
     sendClearContextResponse(requestId: string, sessionId: string, success?: boolean, targetServer?: ServerId): Promise<void>;
+    /**
+     * Send status update (for intermediate status messages, e.g., timeout warnings)
+     * This uses "status-update" event type which keeps the conversation active
+     */
+    sendStatusUpdate(taskId: string, sessionId: string, message: string, targetServer?: ServerId): Promise<void>;
     /**
      * Send tasks cancel response to specific server
      */

package/dist/websocket.js

@@ -456,6 +456,64 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             throw error;
         }
     }
+    /**
+     * Send status update (for intermediate status messages, e.g., timeout warnings)
+     * This uses "status-update" event type which keeps the conversation active
+     */
+    async sendStatusUpdate(taskId, sessionId, message, targetServer) {
+        const serverId = targetServer || this.sessionServerMap.get(sessionId);
+        if (!serverId) {
+            console.error(`[STATUS] Unknown server for session ${sessionId}`);
+            throw new Error(`Cannot send status update: unknown session ${sessionId}`);
+        }
+        const ws = serverId === 'server1' ? this.ws1 : this.ws2;
+        if (!ws || ws.readyState !== ws_1.default.OPEN) {
+            console.error(`[STATUS] ${serverId} not connected`);
+            throw new Error(`${serverId} is not available`);
+        }
+        // Create unique ID for this status update
+        const messageId = `status_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const jsonRpcResponse = {
+            jsonrpc: "2.0",
+            id: messageId,
+            result: {
+                taskId: taskId,
+                kind: "status-update",
+                final: false, // IMPORTANT: Not final, keeps conversation active
+                status: {
+                    message: {
+                        role: "agent",
+                        parts: [
+                            {
+                                kind: "text",
+                                text: message,
+                            },
+                        ],
+                    },
+                    state: "working", // Indicates task is still being processed
+                },
+            },
+        };
+        const outboundMessage = {
+            msgType: "agent_response",
+            agentId: this.config.agentId,
+            sessionId: sessionId,
+            taskId: taskId,
+            msgDetail: JSON.stringify(jsonRpcResponse),
+        };
+        console.log(`[STATUS] Sending status update to ${serverId}:`);
+        console.log(`  sessionId: ${sessionId}`);
+        console.log(`  taskId: ${taskId}`);
+        console.log(`  message: ${message}`);
+        console.log(`  final: false, state: working\n`);
+        try {
+            ws.send(JSON.stringify(outboundMessage));
+        }
+        catch (error) {
+            console.error(`[STATUS] Failed to send to ${serverId}:`, error);
+            throw error;
+        }
+    }
     /**
      * Send tasks cancel response to specific server
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi",
-  "version": "2.4.2",
+  "version": "2.4.4",
   "description": "XiaoYi channel plugin for OpenClaw",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,6 +29,11 @@
       "blurb": "小艺 A2A 协议支持，通过 WebSocket 连接。",
       "order": 80,
       "aliases": ["xy"]
+    },
+    "install": {
+      "npmSpec": "@ynhcj/xiaoyi",
+      "localPath": ".",
+      "defaultChoice": "npm"
     }
   },
   "peerDependencies": {