@ynhcj/xiaoyi 2.2.4 → 2.2.6

package/dist/channel.js

@@ -3,57 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.xiaoyiPlugin = void 0;
 const runtime_1 = require("./runtime");
 const file_handler_1 = require("./file-handler");
-// Import agent event functions - will be resolved at runtime
-// Use dynamic require for compatibility
-let onAgentEvent = null;
-let registerAgentRunContext = null;
-try {
-    // Try multiple import paths
-    let agentEvents = null;
-    // Try path 1: openclaw/dist/infra/agent-events
-    try {
-        agentEvents = require("openclaw/dist/infra/agent-events");
-        console.log("XiaoYi: [AGENT EVENT] Imported from openclaw/dist/infra/agent-events");
-    }
-    catch (e1) {
-        console.log("XiaoYi: [AGENT EVENT] Path 1 failed:", e1?.message || e1);
-        // Try path 2: ../openclaw/dist/infra/agent-events
-        try {
-            agentEvents = require("../openclaw/dist/infra/agent-events");
-            console.log("XiaoYi: [AGENT EVENT] Imported from ../openclaw/dist/infra/agent-events");
-        }
-        catch (e2) {
-            console.log("XiaoYi: [AGENT EVENT] Path 2 failed:", e2?.message || e2);
-            // Try path 3: ../../openclaw/dist/infra/agent-events
-            try {
-                agentEvents = require("../../openclaw/dist/infra/agent-events");
-                console.log("XiaoYi: [AGENT EVENT] Imported from ../../openclaw/dist/infra/agent-events");
-            }
-            catch (e3) {
-                console.error("XiaoYi: [AGENT EVENT] All import paths failed:");
-                console.error("  Path 1 (openclaw/dist/infra/agent-events):", e1?.message || e1);
-                console.error("  Path 2 (../openclaw/dist/infra/agent-events):", e2?.message || e2);
-                console.error("  Path 3 (../../openclaw/dist/infra/agent-events):", e3?.message || e3);
-            }
-        }
-    }
-    if (agentEvents) {
-        onAgentEvent = agentEvents.onAgentEvent;
-        registerAgentRunContext = agentEvents.registerAgentRunContext;
-        if (typeof onAgentEvent === "function") {
-            console.log("XiaoYi: [AGENT EVENT] ✓ onAgentEvent function imported successfully");
-        }
-        else {
-            console.error("XiaoYi: [AGENT EVENT] ✗ onAgentEvent is not a function, type:", typeof onAgentEvent);
-        }
-    }
-    else {
-        console.warn("XiaoYi: [AGENT EVENT] Could not import agent event module");
-    }
-}
-catch (error) {
-    console.error("XiaoYi: [AGENT EVENT] Fatal import error:", error?.message || error);
-}
 /**
  * XiaoYi Channel Plugin
  * Implements OpenClaw ChannelPlugin interface for XiaoYi A2A protocol
@@ -358,164 +307,87 @@ exports.xiaoyiPlugin = {
                     SenderId: senderId,
                     OriginatingChannel: "xiaoyi",
                 };
-                // Use the correct API to dispatch the message (streaming via onAgentEvent)
+                // Dispatch message using OpenClaw's reply dispatcher
                 try {
-                    const streamingEnabled = resolvedAccount.config.enableStreaming === true;
-                    const hasAgentEventSupport = typeof onAgentEvent === "function";
                     console.log("\n" + "=".repeat(60));
-                    console.log(`XiaoYi: [STREAMING] Starting message processing`);
+                    console.log(`XiaoYi: [MESSAGE] Processing user message`);
                     console.log(`  Session: ${message.sessionId}`);
                     console.log(`  Task ID: ${message.params.id}`);
                     console.log(`  User input: ${bodyText.substring(0, 50)}${bodyText.length > 50 ? "..." : ""}`);
-                    console.log(`  Config Streaming: ${streamingEnabled ? "ENABLED" : "DISABLED"}`);
-                    console.log(`  Agent Event Support: ${hasAgentEventSupport ? "AVAILABLE" : "NOT AVAILABLE"}`);
-                    console.log(`  Effective Streaming: ${streamingEnabled && hasAgentEventSupport ? "ENABLED (via onAgentEvent)" : "DISABLED"}`);
+                    console.log(`  Images: ${images.length}`);
                     console.log("=".repeat(60) + "\n");
-                    // Track response state for streaming
-                    let accumulatedText = "";
-                    let taskId = runtime.getTaskIdForSession(message.sessionId) || `task_${Date.now()}`;
-                    let frameCount = 0;
-                    let partialCount = 0;
+                    const taskId = runtime.getTaskIdForSession(message.sessionId) || `task_${Date.now()}`;
                     const startTime = Date.now();
-                    // Register agent event listener for streaming (NEW METHOD)
-                    let unsubscribeAgentEvents;
-                    let runId;
-                    let isCompleted = false;
-                    if (streamingEnabled && hasAgentEventSupport) {
-                        // Subscribe to agent events BEFORE dispatching the message
-                        unsubscribeAgentEvents = onAgentEvent((evt) => {
-                            if (isCompleted)
-                                return;
-                            // Get runId from first event
-                            if (!runId && evt.runId) {
-                                runId = evt.runId;
-                                console.log(`XiaoYi: [AGENT EVENT] Registered runId: ${runId}`);
-                            }
-                            // Only process events for this run
-                            if (runId && evt.runId !== runId)
-                                return;
-                            const elapsed = Date.now() - startTime;
-                            // Handle streaming text events
-                            if (evt.stream === "assistant" && typeof evt.data?.text === "string") {
-                                const newText = evt.data.text;
-                                if (!newText)
-                                    return;
-                                // Calculate delta text
-                                const previousLength = accumulatedText.length;
-                                accumulatedText = newText;
-                                const deltaText = newText.slice(previousLength);
-                                console.log(`\n>>> XiaoYi: [AGENT EVENT] Stream frame #${++partialCount} at ${elapsed}ms`);
-                                console.log(`    Run ID: ${evt.runId}`);
-                                console.log(`    Delta length: ${deltaText.length} chars`);
-                                console.log(`    Total length: ${newText.length} chars`);
-                                console.log(`    Delta content: "${deltaText}"`);
-                                // Send PARTIAL frame with delta content
-                                const partialResponse = {
-                                    sessionId: message.sessionId,
-                                    messageId: `partial_${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: deltaText || newText,
-                                    },
-                                    status: "processing",
-                                };
-                                const conn = runtime.getConnection();
-                                if (conn) {
-                                    conn.sendResponse(partialResponse, taskId, message.sessionId, false, true)
-                                        .then(() => {
-                                        console.log(`    ✓ SENT (isFinal=false, append=true)\n`);
-                                    })
-                                        .catch((err) => {
-                                        console.error(`    ✗ Send failed: ${err}\n`);
-                                    });
-                                }
+                    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`);
                             }
-                            // Handle lifecycle events (completion/error)
-                            if (evt.stream === "lifecycle") {
-                                const phase = evt.data?.phase;
-                                if (phase === "end") {
-                                    isCompleted = true;
-                                    console.log("\n" + "-".repeat(60));
-                                    console.log(`XiaoYi: [AGENT EVENT] Lifecycle phase: end`);
-                                    console.log(`  Run ID: ${evt.runId}`);
-                                    console.log(`  Elapsed: ${elapsed}ms`);
-                                    console.log(`  Total frames: ${partialCount}`);
-                                    console.log(`  Final length: ${accumulatedText.length} chars`);
-                                    console.log("-".repeat(60) + "\n");
-                                    // Send FINAL frame
-                                    const response = {
-                                        sessionId: message.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",
-                                    };
-                                    const conn = runtime.getConnection();
-                                    if (conn) {
-                                        conn.sendResponse(response, taskId, message.sessionId, true, false)
-                                            .then(() => {
-                                            console.log(`✓ XiaoYi: FINAL frame sent (isFinal=true, append=false)\n`);
-                                        })
-                                            .catch((err) => {
-                                            console.error(`✗ Final send failed: ${err}\n`);
-                                        });
-                                    }
-                                    // Unsubscribe from events
-                                    if (unsubscribeAgentEvents) {
-                                        unsubscribeAgentEvents();
-                                        unsubscribeAgentEvents = undefined;
-                                    }
-                                }
-                                else if (phase === "error") {
-                                    isCompleted = true;
-                                    console.error(`XiaoYi: [AGENT EVENT] Error phase:`, evt.data?.error);
-                                    // Unsubscribe from events
-                                    if (unsubscribeAgentEvents) {
-                                        unsubscribeAgentEvents();
-                                        unsubscribeAgentEvents = undefined;
-                                    }
-                                }
+                            catch (error) {
+                                console.error(`[TIMEOUT] Failed to send timeout message:`, error);
                             }
-                        });
-                        console.log(`XiaoYi: [AGENT EVENT] Listener registered for streaming`);
-                    }
-                    else if (streamingEnabled && !hasAgentEventSupport) {
-                        console.warn(`XiaoYi: [WARN] Streaming enabled but onAgentEvent not available, falling back to non-streaming mode`);
-                    }
+                        }
+                        else {
+                            console.error(`[TIMEOUT] Connection not available, cannot send timeout message\n`);
+                        }
+                    });
+                    // ==================== END TIMEOUT PROTECTION ====================
                     await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
                         ctx: msgContext,
                         cfg: config,
                         dispatcherOptions: {
                             deliver: async (payload) => {
-                                // NOTE: onAgentEvent does NOT emit "assistant" stream events in production
-                                // Only lifecycle and tool events are emitted
-                                // So we must handle the final result here
                                 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] Final result received`);
+                                console.log(`XiaoYi: [DELIVER] AI response received`);
                                 console.log(`  Elapsed: ${elapsed}ms`);
                                 console.log(`  Length: ${completeText.length} chars`);
-                                console.log(`  Streaming frames sent: ${partialCount}`);
+                                console.log(`  Preview: ${completeText.substring(0, 100)}...`);
                                 console.log("-".repeat(60) + "\n");
-                                // Send FINAL frame
+                                // Send final response to XiaoYi
                                 const response = {
                                     sessionId: message.sessionId,
                                     messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
@@ -535,31 +407,33 @@ exports.xiaoyiPlugin = {
                                 const conn = runtime.getConnection();
                                 if (conn) {
                                     await conn.sendResponse(response, taskId, message.sessionId, true, false);
-                                    console.log(`✓ XiaoYi: FINAL frame sent (isFinal=true, append=false)\n`);
+                                    console.log(`✓ XiaoYi: Response sent successfully\n`);
                                 }
+                                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;
                                 console.log("\n" + "=".repeat(60));
                                 console.log(`XiaoYi: [IDLE] Processing complete`);
                                 console.log(`  Total time: ${elapsed}ms`);
-                                console.log(`  Streaming frames: ${partialCount}`);
                                 console.log(`  Final length: ${accumulatedText.length} chars`);
                                 console.log("=".repeat(60) + "\n");
-                                // Cleanup event listener if still active
-                                if (unsubscribeAgentEvents && !isCompleted) {
-                                    console.log(`XiaoYi: [IDLE] Cleaning up event listener`);
-                                    unsubscribeAgentEvents();
-                                    unsubscribeAgentEvents = undefined;
-                                }
+                                // Clear timeout on completion
+                                runtime.markSessionCompleted(message.sessionId);
                             },
                         },
-                        replyOptions: undefined, // onPartialReply is not used
+                        replyOptions: undefined,
                         images: images.length > 0 ? images : undefined,
                     });
                 }
                 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,83 @@ 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 if any
+        this.clearSessionTimeout(sessionId);
+        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);
+        console.log(`[TIMEOUT] ${this.timeoutConfig.duration}ms timeout started for session ${sessionId}`);
+        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.4",
+  "version": "2.2.6",
   "description": "XiaoYi channel plugin for OpenClaw",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",