@ynhcj/xiaoyi 2.2.5 → 2.2.7

package/dist/channel.js

@@ -319,6 +319,49 @@ exports.xiaoyiPlugin = {
                     const taskId = runtime.getTaskIdForSession(message.sessionId) || `task_${Date.now()}`;
                     const startTime = Date.now();
                     let accumulatedText = "";
+                    // ==================== START TIMEOUT PROTECTION ====================
+                    // Start 60-second timeout timer
+                    const timeoutConfig = runtime.getTimeoutConfig();
+                    console.log(`[TIMEOUT] Starting ${timeoutConfig.duration}ms timeout protection for session ${message.sessionId}`);
+                    runtime.setTimeoutForSession(message.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 ${message.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: message.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, message.sessionId, true, false);
+                                console.log(`[TIMEOUT] Timeout message sent successfully to session ${message.sessionId}\n`);
+                            }
+                            catch (error) {
+                                console.error(`[TIMEOUT] Failed to send timeout message:`, error);
+                            }
+                        }
+                        else {
+                            console.error(`[TIMEOUT] Connection not available, cannot send timeout message\n`);
+                        }
+                    });
+                    // ==================== END TIMEOUT PROTECTION ====================
                     await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
                         ctx: msgContext,
                         cfg: config,
@@ -327,6 +370,17 @@ exports.xiaoyiPlugin = {
                                 const elapsed = Date.now() - startTime;
                                 const completeText = payload.text || "";
                                 accumulatedText = completeText;
+                                // ==================== CHECK TIMEOUT ====================
+                                // If timeout already sent, discard this response
+                                if (runtime.isSessionTimeout(message.sessionId)) {
+                                    console.log("\n" + "=".repeat(60));
+                                    console.log(`[TIMEOUT] Response received AFTER timeout`);
+                                    console.log(`  Session: ${message.sessionId}`);
+                                    console.log(`  Elapsed: ${elapsed}ms`);
+                                    console.log(`  Action: DISCARDING (timeout message already sent)`);
+                                    console.log("=".repeat(60) + "\n");
+                                    return;
+                                }
                                 console.log("\n" + "-".repeat(60));
                                 console.log(`XiaoYi: [DELIVER] AI response received`);
                                 console.log(`  Elapsed: ${elapsed}ms`);
@@ -358,6 +412,8 @@ exports.xiaoyiPlugin = {
                                 else {
                                     console.error(`✗ XiaoYi: Connection not available\n`);
                                 }
+                                // Clear timeout as response was sent successfully
+                                runtime.markSessionCompleted(message.sessionId);
                             },
                             onIdle: async () => {
                                 const elapsed = Date.now() - startTime;
@@ -366,6 +422,8 @@ exports.xiaoyiPlugin = {
                                 console.log(`  Total time: ${elapsed}ms`);
                                 console.log(`  Final length: ${accumulatedText.length} chars`);
                                 console.log("=".repeat(60) + "\n");
+                                // Clear timeout on completion
+                                runtime.markSessionCompleted(message.sessionId);
                             },
                         },
                         replyOptions: undefined,
@@ -374,6 +432,8 @@ exports.xiaoyiPlugin = {
                 }
                 catch (error) {
                     console.error("XiaoYi: [ERROR] Error dispatching message:", error);
+                    // Clear timeout on error
+                    runtime.clearSessionTimeout(message.sessionId);
                 }
             });
             // Setup cancel handler

package/dist/config-schema.d.ts

@@ -33,8 +33,8 @@ export declare const XiaoYiConfigSchema: z.ZodObject<{
     agentId?: string | undefined;
     accounts?: Record<string, unknown> | undefined;
 }, {
-    name?: string | undefined;
     enabled?: boolean | undefined;
+    name?: string | undefined;
     wsUrl?: string | undefined;
     ak?: string | undefined;
     sk?: string | undefined;

package/dist/runtime.d.ts

@@ -1,5 +1,13 @@
 import { XiaoYiWebSocketManager } from "./websocket";
 import { XiaoYiChannelConfig } from "./types";
+/**
+ * Timeout configuration
+ */
+export interface TimeoutConfig {
+    enabled: boolean;
+    duration: number;
+    message: string;
+}
 /**
  * Runtime state for XiaoYi channel
  * Manages single WebSocket connection (single account mode)
@@ -10,6 +18,9 @@ export declare class XiaoYiRuntime {
     private config;
     private sessionToTaskIdMap;
     private instanceId;
+    private sessionTimeoutMap;
+    private sessionTimeoutSent;
+    private timeoutConfig;
     constructor();
     getInstanceId(): string;
     /**
@@ -28,6 +39,40 @@ export declare class XiaoYiRuntime {
      * Stop connection
      */
     stop(): void;
+    /**
+     * Set timeout configuration
+     */
+    setTimeoutConfig(config: Partial<TimeoutConfig>): void;
+    /**
+     * Get timeout configuration
+     */
+    getTimeoutConfig(): TimeoutConfig;
+    /**
+     * Set timeout for a session
+     * @param sessionId - Session ID
+     * @param callback - Function to call when timeout occurs
+     * @returns The timeout ID (for cancellation)
+     */
+    setTimeoutForSession(sessionId: string, callback: () => void): NodeJS.Timeout | undefined;
+    /**
+     * Clear timeout for a session
+     * @param sessionId - Session ID
+     */
+    clearSessionTimeout(sessionId: string): void;
+    /**
+     * Check if timeout has been sent for a session
+     * @param sessionId - Session ID
+     */
+    isSessionTimeout(sessionId: string): boolean;
+    /**
+     * Mark session as completed (clear timeout and timeout flag)
+     * @param sessionId - Session ID
+     */
+    markSessionCompleted(sessionId: string): void;
+    /**
+     * Clear all timeouts
+     */
+    clearAllTimeouts(): void;
     /**
      * Get WebSocket manager
      */

package/dist/runtime.js

@@ -4,6 +4,14 @@ exports.XiaoYiRuntime = void 0;
 exports.getXiaoYiRuntime = getXiaoYiRuntime;
 exports.setXiaoYiRuntime = setXiaoYiRuntime;
 const websocket_1 = require("./websocket");
+/**
+ * Default timeout configuration
+ */
+const DEFAULT_TIMEOUT_CONFIG = {
+    enabled: true,
+    duration: 60000, // 60 seconds
+    message: "任务还在处理中，请稍后回来查看",
+};
 /**
  * Runtime state for XiaoYi channel
  * Manages single WebSocket connection (single account mode)
@@ -14,6 +22,10 @@ class XiaoYiRuntime {
         this.pluginRuntime = null; // Store PluginRuntime from OpenClaw
         this.config = null;
         this.sessionToTaskIdMap = new Map(); // Map sessionId to taskId
+        // Timeout management
+        this.sessionTimeoutMap = new Map();
+        this.sessionTimeoutSent = new Set();
+        this.timeoutConfig = DEFAULT_TIMEOUT_CONFIG;
         this.instanceId = `runtime_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         console.log(`XiaoYi: Created new runtime instance: ${this.instanceId}`);
     }
@@ -73,6 +85,91 @@ class XiaoYiRuntime {
         }
         // Clear session mappings
         this.sessionToTaskIdMap.clear();
+        // Clear all timeouts
+        this.clearAllTimeouts();
+    }
+    /**
+     * Set timeout configuration
+     */
+    setTimeoutConfig(config) {
+        this.timeoutConfig = { ...this.timeoutConfig, ...config };
+        console.log(`XiaoYi: Timeout config updated:`, this.timeoutConfig);
+    }
+    /**
+     * Get timeout configuration
+     */
+    getTimeoutConfig() {
+        return { ...this.timeoutConfig };
+    }
+    /**
+     * Set timeout for a session
+     * @param sessionId - Session ID
+     * @param callback - Function to call when timeout occurs
+     * @returns The timeout ID (for cancellation)
+     */
+    setTimeoutForSession(sessionId, callback) {
+        if (!this.timeoutConfig.enabled) {
+            console.log(`[TIMEOUT] Timeout disabled, skipping for session ${sessionId}`);
+            return undefined;
+        }
+        // Clear existing timeout AND timeout flag if any (reuse session scenario)
+        const hadExistingTimeout = this.sessionTimeoutMap.has(sessionId);
+        const hadSentTimeout = this.sessionTimeoutSent.has(sessionId);
+        this.clearSessionTimeout(sessionId);
+        // Also clear the timeout sent flag to allow this session to timeout again
+        if (hadSentTimeout) {
+            this.sessionTimeoutSent.delete(sessionId);
+            console.log(`[TIMEOUT] Previous timeout flag cleared for session ${sessionId} (session reuse)`);
+        }
+        const timeoutId = setTimeout(() => {
+            console.log(`[TIMEOUT] Timeout triggered for session ${sessionId}`);
+            this.sessionTimeoutMap.delete(sessionId);
+            this.sessionTimeoutSent.add(sessionId);
+            callback();
+        }, this.timeoutConfig.duration);
+        this.sessionTimeoutMap.set(sessionId, timeoutId);
+        const logSuffix = hadExistingTimeout ? " (replacing existing timeout)" : "";
+        console.log(`[TIMEOUT] ${this.timeoutConfig.duration}ms timeout started for session ${sessionId}${logSuffix}`);
+        return timeoutId;
+    }
+    /**
+     * Clear timeout for a session
+     * @param sessionId - Session ID
+     */
+    clearSessionTimeout(sessionId) {
+        const timeoutId = this.sessionTimeoutMap.get(sessionId);
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+            this.sessionTimeoutMap.delete(sessionId);
+            console.log(`[TIMEOUT] Timeout cleared for session ${sessionId}`);
+        }
+    }
+    /**
+     * Check if timeout has been sent for a session
+     * @param sessionId - Session ID
+     */
+    isSessionTimeout(sessionId) {
+        return this.sessionTimeoutSent.has(sessionId);
+    }
+    /**
+     * Mark session as completed (clear timeout and timeout flag)
+     * @param sessionId - Session ID
+     */
+    markSessionCompleted(sessionId) {
+        this.clearSessionTimeout(sessionId);
+        this.sessionTimeoutSent.delete(sessionId);
+        console.log(`[TIMEOUT] Session ${sessionId} marked as completed`);
+    }
+    /**
+     * Clear all timeouts
+     */
+    clearAllTimeouts() {
+        for (const [sessionId, timeoutId] of this.sessionTimeoutMap.entries()) {
+            clearTimeout(timeoutId);
+        }
+        this.sessionTimeoutMap.clear();
+        this.sessionTimeoutSent.clear();
+        console.log("[TIMEOUT] All timeouts cleared");
     }
     /**
      * Get WebSocket manager

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi",
-  "version": "2.2.5",
+  "version": "2.2.7",
   "description": "XiaoYi channel plugin for OpenClaw",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",