@ynhcj/xiaoyi 2.3.4 → 2.3.6

package/dist/channel.js

@@ -215,7 +215,7 @@ exports.xiaoyiPlugin = {
                 const runtime = getXiaoYiRuntime();
                 console.log(`XiaoYi: [Message Handler] Using runtime instance: ${runtime.getInstanceId()}`);
                 // Store sessionId -> taskId mapping in runtime (use params.id as taskId)
-                runtime.setTaskIdForSession(message.sessionId, message.params.id);
+                runtime.setTaskIdForSession(message.params.sessionId, message.params.id);
                 // Get PluginRuntime from our runtime wrapper
                 const pluginRuntime = runtime.getPluginRuntime();
                 if (!pluginRuntime) {
@@ -291,8 +291,8 @@ exports.xiaoyiPlugin = {
                 const msgContext = {
                     Body: bodyText,
                     From: senderId,
-                    To: message.sessionId,
-                    SessionKey: `xiaoyi:${resolvedAccount.accountId}:${message.sessionId}`,
+                    To: message.params.sessionId,
+                    SessionKey: `xiaoyi:${resolvedAccount.accountId}:${message.params.sessionId}`,
                     AccountId: resolvedAccount.accountId,
                     MessageSid: message.id, // Use top-level id as message sequence number
                     Timestamp: Date.now(), // Generate timestamp since new format doesn't include it
@@ -307,30 +307,34 @@ exports.xiaoyiPlugin = {
                 try {
                     console.log("\n" + "=".repeat(60));
                     console.log(`XiaoYi: [MESSAGE] Processing user message`);
-                    console.log(`  Session: ${message.sessionId}`);
+                    console.log(`  Session: ${message.params.sessionId}`);
                     console.log(`  Task ID: ${message.params.id}`);
                     console.log(`  User input: ${bodyText.substring(0, 50)}${bodyText.length > 50 ? "..." : ""}`);
                     console.log(`  Images: ${images.length}`);
                     console.log("=".repeat(60) + "\n");
-                    const taskId = runtime.getTaskIdForSession(message.sessionId) || `task_${Date.now()}`;
+                    const taskId = runtime.getTaskIdForSession(message.params.sessionId) || `task_${Date.now()}`;
                     const startTime = Date.now();
                     let accumulatedText = "";
+                    // ==================== CREATE ABORT CONTROLLER ====================
+                    // Create AbortController for this session to allow cancelation
+                    const { controller: abortController, signal: abortSignal } = runtime.createAbortControllerForSession(message.params.sessionId);
+                    // ================================================================
                     // ==================== 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 () => {
+                    console.log(`[TIMEOUT] Starting ${timeoutConfig.duration}ms timeout protection for session ${message.params.sessionId}`);
+                    runtime.setTimeoutForSession(message.params.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(`[TIMEOUT] Timeout triggered for session ${message.params.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,
+                                sessionId: message.params.sessionId,
                                 messageId: `timeout_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
                                 timestamp: Date.now(),
                                 agentId: resolvedAccount.config.agentId,
@@ -346,8 +350,8 @@ exports.xiaoyiPlugin = {
                                 status: "success",
                             };
                             try {
-                                await conn.sendResponse(timeoutResponse, taskId, message.sessionId, true, false);
-                                console.log(`[TIMEOUT] Timeout message sent successfully to session ${message.sessionId}\n`);
+                                await conn.sendResponse(timeoutResponse, taskId, message.params.sessionId, true, false);
+                                console.log(`[TIMEOUT] Timeout message sent successfully to session ${message.params.sessionId}\n`);
                             }
                             catch (error) {
                                 console.error(`[TIMEOUT] Failed to send timeout message:`, error);
@@ -366,12 +370,22 @@ exports.xiaoyiPlugin = {
                                 const elapsed = Date.now() - startTime;
                                 const completeText = payload.text || "";
                                 accumulatedText = completeText;
+                                // Check if session was aborted
+                                if (runtime.isSessionAborted(message.params.sessionId)) {
+                                    console.log("\n" + "=".repeat(60));
+                                    console.log(`[ABORT] Response received AFTER abort`);
+                                    console.log(`  Session: ${message.params.sessionId}`);
+                                    console.log(`  Elapsed: ${elapsed}ms`);
+                                    console.log(`  Action: DISCARDING (session was canceled)`);
+                                    console.log("=".repeat(60) + "\n");
+                                    return;
+                                }
                                 // ==================== CHECK TIMEOUT ====================
                                 // If timeout already sent, discard this response
-                                if (runtime.isSessionTimeout(message.sessionId)) {
+                                if (runtime.isSessionTimeout(message.params.sessionId)) {
                                     console.log("\n" + "=".repeat(60));
                                     console.log(`[TIMEOUT] Response received AFTER timeout`);
-                                    console.log(`  Session: ${message.sessionId}`);
+                                    console.log(`  Session: ${message.params.sessionId}`);
                                     console.log(`  Elapsed: ${elapsed}ms`);
                                     console.log(`  Action: DISCARDING (timeout message already sent)`);
                                     console.log("=".repeat(60) + "\n");
@@ -382,7 +396,7 @@ exports.xiaoyiPlugin = {
                                 if (!completeText || completeText.length === 0) {
                                     console.log("\n" + "=".repeat(60));
                                     console.log(`[TIMEOUT] Empty response detected`);
-                                    console.log(`  Session: ${message.sessionId}`);
+                                    console.log(`  Session: ${message.params.sessionId}`);
                                     console.log(`  Elapsed: ${elapsed}ms`);
                                     console.log(`  Action: KEEPING TIMEOUT (session conflict detected)`);
                                     console.log("=".repeat(60) + "\n");
@@ -397,7 +411,7 @@ exports.xiaoyiPlugin = {
                                 console.log("-".repeat(60) + "\n");
                                 // Send final response to XiaoYi
                                 const response = {
-                                    sessionId: message.sessionId,
+                                    sessionId: message.params.sessionId,
                                     messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
                                     timestamp: Date.now(),
                                     agentId: resolvedAccount.config.agentId,
@@ -414,14 +428,14 @@ exports.xiaoyiPlugin = {
                                 };
                                 const conn = runtime.getConnection();
                                 if (conn) {
-                                    await conn.sendResponse(response, taskId, message.sessionId, true, false);
+                                    await conn.sendResponse(response, taskId, message.params.sessionId, true, false);
                                     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);
+                                runtime.markSessionCompleted(message.params.sessionId);
                             },
                             onIdle: async () => {
                                 const elapsed = Date.now() - startTime;
@@ -432,7 +446,8 @@ exports.xiaoyiPlugin = {
                                 // Only clear timeout if we have a valid response
                                 // If empty, keep timeout running to handle session conflict
                                 if (accumulatedText.length > 0) {
-                                    runtime.markSessionCompleted(message.sessionId);
+                                    runtime.markSessionCompleted(message.params.sessionId);
+                                    runtime.clearAbortControllerForSession(message.params.sessionId);
                                     console.log(`[TIMEOUT] Timeout cleared (valid response)\n`);
                                 }
                                 else {
@@ -441,26 +456,39 @@ exports.xiaoyiPlugin = {
                                 console.log("=".repeat(60) + "\n");
                             },
                         },
-                        replyOptions: undefined,
+                        replyOptions: {
+                            abortSignal: abortSignal, // Pass abort signal to allow cancellation
+                        },
                         images: images.length > 0 ? images : undefined,
                     });
                 }
                 catch (error) {
                     console.error("XiaoYi: [ERROR] Error dispatching message:", error);
                     // Clear timeout on error
-                    runtime.clearSessionTimeout(message.sessionId);
+                    runtime.clearSessionTimeout(message.params.sessionId);
+                    // Clear abort controller on error
+                    runtime.clearAbortControllerForSession(message.params.sessionId);
                 }
             });
             // Setup cancel handler
-            // Note: The response is already sent in websocket.ts, this is just for logging
+            // When tasks/cancel is received, abort the current session's agent run
             connection.on("cancel", async (data) => {
+                const { sessionId } = data;
                 console.log("\n" + "=".repeat(60));
-                console.log(`XiaoYi: [CANCEL] Cancel event received (response already sent)`);
-                console.log(`  Session: ${data.sessionId}`);
+                console.log(`XiaoYi: [CANCEL] Cancel event received`);
+                console.log(`  Session: ${sessionId}`);
                 console.log(`  Task ID: ${data.taskId || "N/A"}`);
                 console.log("=".repeat(60) + "\n");
-                // NOTE: The cancel response has already been sent to XiaoYi in websocket.ts.
-                // Actual cancellation of the agent run depends on OpenClaw's internal mechanisms.
+                // Abort the session's agent run
+                const aborted = runtime.abortSession(sessionId);
+                if (aborted) {
+                    console.log(`[CANCEL] Successfully triggered abort for session ${sessionId}`);
+                }
+                else {
+                    console.log(`[CANCEL] No active agent run found for session ${sessionId}`);
+                }
+                // Clear timeout as the session is being canceled
+                runtime.markSessionCompleted(sessionId);
             });
             console.log("XiaoYi: Event handlers registered");
             console.log("XiaoYi: startAccount() completed - END");

package/dist/runtime.d.ts

@@ -21,6 +21,7 @@ export declare class XiaoYiRuntime {
     private sessionTimeoutMap;
     private sessionTimeoutSent;
     private timeoutConfig;
+    private sessionAbortControllerMap;
     constructor();
     getInstanceId(): string;
     /**
@@ -97,6 +98,36 @@ export declare class XiaoYiRuntime {
      * Clear taskId for a session
      */
     clearTaskIdForSession(sessionId: string): void;
+    /**
+     * Create and register an AbortController for a session
+     * @param sessionId - Session ID
+     * @returns The AbortController and its signal
+     */
+    createAbortControllerForSession(sessionId: string): {
+        controller: AbortController;
+        signal: AbortSignal;
+    };
+    /**
+     * Abort a session's agent run
+     * @param sessionId - Session ID
+     * @returns true if a controller was found and aborted, false otherwise
+     */
+    abortSession(sessionId: string): boolean;
+    /**
+     * Check if a session has been aborted
+     * @param sessionId - Session ID
+     * @returns true if the session's abort signal was triggered
+     */
+    isSessionAborted(sessionId: string): boolean;
+    /**
+     * Clear the AbortController for a session (call when agent completes successfully)
+     * @param sessionId - Session ID
+     */
+    clearAbortControllerForSession(sessionId: string): void;
+    /**
+     * Clear all AbortControllers
+     */
+    clearAllAbortControllers(): void;
 }
 export declare function getXiaoYiRuntime(): XiaoYiRuntime;
 export declare function setXiaoYiRuntime(runtime: any): void;

package/dist/runtime.js

@@ -26,6 +26,8 @@ class XiaoYiRuntime {
         this.sessionTimeoutMap = new Map();
         this.sessionTimeoutSent = new Set();
         this.timeoutConfig = DEFAULT_TIMEOUT_CONFIG;
+        // AbortController management for canceling agent runs
+        this.sessionAbortControllerMap = new Map();
         this.instanceId = `runtime_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         console.log(`XiaoYi: Created new runtime instance: ${this.instanceId}`);
     }
@@ -100,6 +102,8 @@ class XiaoYiRuntime {
         this.sessionToTaskIdMap.clear();
         // Clear all timeouts
         this.clearAllTimeouts();
+        // Clear all abort controllers
+        this.clearAllAbortControllers();
     }
     /**
      * Set timeout configuration
@@ -220,6 +224,62 @@ class XiaoYiRuntime {
     clearTaskIdForSession(sessionId) {
         this.sessionToTaskIdMap.delete(sessionId);
     }
+    /**
+     * Create and register an AbortController for a session
+     * @param sessionId - Session ID
+     * @returns The AbortController and its signal
+     */
+    createAbortControllerForSession(sessionId) {
+        // Abort any existing controller for this session
+        this.abortSession(sessionId);
+        const controller = new AbortController();
+        this.sessionAbortControllerMap.set(sessionId, controller);
+        console.log(`[ABORT] Created AbortController for session ${sessionId}`);
+        return { controller, signal: controller.signal };
+    }
+    /**
+     * Abort a session's agent run
+     * @param sessionId - Session ID
+     * @returns true if a controller was found and aborted, false otherwise
+     */
+    abortSession(sessionId) {
+        const controller = this.sessionAbortControllerMap.get(sessionId);
+        if (controller) {
+            console.log(`[ABORT] Aborting session ${sessionId}`);
+            controller.abort();
+            this.sessionAbortControllerMap.delete(sessionId);
+            return true;
+        }
+        console.log(`[ABORT] No AbortController found for session ${sessionId}`);
+        return false;
+    }
+    /**
+     * Check if a session has been aborted
+     * @param sessionId - Session ID
+     * @returns true if the session's abort signal was triggered
+     */
+    isSessionAborted(sessionId) {
+        const controller = this.sessionAbortControllerMap.get(sessionId);
+        return controller ? controller.signal.aborted : false;
+    }
+    /**
+     * Clear the AbortController for a session (call when agent completes successfully)
+     * @param sessionId - Session ID
+     */
+    clearAbortControllerForSession(sessionId) {
+        const controller = this.sessionAbortControllerMap.get(sessionId);
+        if (controller) {
+            this.sessionAbortControllerMap.delete(sessionId);
+            console.log(`[ABORT] Cleared AbortController for session ${sessionId}`);
+        }
+    }
+    /**
+     * Clear all AbortControllers
+     */
+    clearAllAbortControllers() {
+        this.sessionAbortControllerMap.clear();
+        console.log("[ABORT] All AbortControllers cleared");
+    }
 }
 exports.XiaoYiRuntime = XiaoYiRuntime;
 // Global runtime instance - use global object to survive module reloads

package/dist/types.d.ts

@@ -1,12 +1,11 @@
 export interface A2ARequestMessage {
     agentId: string;
-    sessionId: string;
     jsonrpc: "2.0";
     id: string;
     method: "message/stream";
     params: {
         id: string;
-        sessionId?: string;
+        sessionId: string;
         agentLoginSessionId?: string;
         message: {
             role: "user" | "agent";

package/dist/websocket.js

@@ -320,9 +320,9 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
                 return;
             }
             // Record session → server mapping
-            if (message.sessionId) {
-                this.sessionServerMap.set(message.sessionId, sourceServer);
-                console.log(`[MAP] Session ${message.sessionId} -> ${sourceServer}`);
+            if (message.params.sessionId) {
+                this.sessionServerMap.set(message.params.sessionId, sourceServer);
+                console.log(`[MAP] Session ${message.params.sessionId} -> ${sourceServer}`);
             }
             // Handle special messages (clearContext, tasks/cancel)
             if (message.method === "clearContext") {
@@ -341,7 +341,7 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             if (this.isA2ARequestMessage(message)) {
                 // Store task for potential cancellation
                 this.activeTasks.set(message.id, {
-                    sessionId: message.sessionId,
+                    sessionId: message.params.sessionId,
                     timestamp: Date.now(),
                 });
                 // Emit with server info
@@ -476,16 +476,16 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
      * Handle clearContext method
      */
     handleClearContext(message, sourceServer) {
-        console.log(`[${sourceServer}] Received clearContext for session: ${message.sessionId}`);
-        this.sendClearContextResponse(message.id, message.sessionId, true, sourceServer)
+        console.log(`[${sourceServer}] Received clearContext for session: ${message.params.sessionId}`);
+        this.sendClearContextResponse(message.id, message.params.sessionId, true, sourceServer)
             .catch(error => console.error(`[${sourceServer}] Failed to send clearContext response:`, error));
         this.emit("clear", {
-            sessionId: message.sessionId,
+            sessionId: message.params.sessionId,
             id: message.id,
             serverId: sourceServer,
         });
         // Remove session mapping
-        this.sessionServerMap.delete(message.sessionId);
+        this.sessionServerMap.delete(message.params.sessionId);
     }
     /**
      * Handle clear message (legacy format)
@@ -770,14 +770,12 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     isA2ARequestMessage(data) {
         return data &&
             typeof data.agentId === "string" &&
-            typeof data.sessionId === "string" &&
             data.jsonrpc === "2.0" &&
             typeof data.id === "string" &&
             data.method === "message/stream" &&
             data.params &&
             typeof data.params.id === "string" &&
-            // params.sessionId is optional - not sent by actual server
-            (data.params.sessionId === undefined || typeof data.params.sessionId === "string") &&
+            typeof data.params.sessionId === "string" &&
             data.params.message &&
             typeof data.params.message.role === "string" &&
             Array.isArray(data.params.message.parts);

package/package.json

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