@ynhcj/xiaoyi 2.4.3 → 2.4.5

package/dist/channel.js

@@ -322,6 +322,7 @@ exports.xiaoyiPlugin = {
                     const taskId = runtime.getTaskIdForSession(sessionId) || `task_${Date.now()}`;
                     const startTime = Date.now();
                     let accumulatedText = "";
+                    let sentTextLength = 0; // Track sent text length for streaming
                     // ==================== CREATE ABORT CONTROLLER ====================
                     // Create AbortController for this session to allow cancelation
                     const { controller: abortController, signal: abortSignal } = runtime.createAbortControllerForSession(sessionId);
@@ -341,36 +342,20 @@ exports.xiaoyiPlugin = {
                             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 {
-                                    // Send timeout message with isFinal=false (not final), append=false (replace)
-                                    await conn.sendResponse(timeoutResponse, taskId, sessionId, false, false);
-                                    console.log(`[TIMEOUT] Timeout message sent successfully to session ${sessionId}\n`);
+                                    // 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 timeout message:`, error);
+                                    console.error(`[TIMEOUT] Failed to send status update:`, error);
                                 }
                             }
                             else {
-                                console.error(`[TIMEOUT] Connection not available, cannot send timeout message\n`);
+                                console.error(`[TIMEOUT] Connection not available, cannot send status update\n`);
                             }
                         };
                     };
@@ -381,15 +366,17 @@ exports.xiaoyiPlugin = {
                         ctx: msgContext,
                         cfg: config,
                         dispatcherOptions: {
-                            deliver: async (payload) => {
+                            deliver: async (payload, info) => {
                                 const elapsed = Date.now() - startTime;
                                 const completeText = payload.text || "";
                                 accumulatedText = completeText;
+                                const kind = info.kind; // "tool" | "block" | "final"
                                 // Check if session was aborted
                                 if (runtime.isSessionAborted(sessionId)) {
                                     console.log("\n" + "=".repeat(60));
                                     console.log(`[ABORT] Response received AFTER abort`);
                                     console.log(`  Session: ${sessionId}`);
+                                    console.log(`  Kind: ${kind}`);
                                     console.log(`  Elapsed: ${elapsed}ms`);
                                     console.log(`  Action: DISCARDING (session was canceled)`);
                                     console.log("=".repeat(60) + "\n");
@@ -401,6 +388,7 @@ exports.xiaoyiPlugin = {
                                     console.log("\n" + "=".repeat(60));
                                     console.log(`[TIMEOUT] Response received AFTER timeout`);
                                     console.log(`  Session: ${sessionId}`);
+                                    console.log(`  Kind: ${kind}`);
                                     console.log(`  Elapsed: ${elapsed}ms`);
                                     console.log(`  Action: DISCARDING (timeout message already sent)`);
                                     console.log("=".repeat(60) + "\n");
@@ -410,47 +398,105 @@ exports.xiaoyiPlugin = {
                                 // If response is empty, don't clear timeout (let it trigger)
                                 if (!completeText || completeText.length === 0) {
                                     console.log("\n" + "=".repeat(60));
-                                    console.log(`[TIMEOUT] Empty response detected`);
+                                    console.log(`[STREAM] Empty ${kind} response detected`);
                                     console.log(`  Session: ${sessionId}`);
                                     console.log(`  Elapsed: ${elapsed}ms`);
-                                    console.log(`  Action: KEEPING TIMEOUT (session conflict detected)`);
+                                    console.log(`  Action: SKIPPING (empty response)`);
                                     console.log("=".repeat(60) + "\n");
                                     // Don't send anything, and don't clear timeout
                                     return;
                                 }
-                                console.log("\n" + "-".repeat(60));
-                                console.log(`XiaoYi: [DELIVER] AI response received`);
-                                console.log(`  Elapsed: ${elapsed}ms`);
-                                console.log(`  Length: ${completeText.length} chars`);
-                                console.log(`  Preview: ${completeText.substring(0, 100)}...`);
-                                console.log("-".repeat(60) + "\n");
-                                // Send final response to XiaoYi
-                                const response = {
-                                    sessionId: 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) {
+                                if (!conn) {
+                                    console.error(`✗ XiaoYi: Connection not available\n`);
+                                    return;
+                                }
+                                // ==================== STREAMING LOGIC ====================
+                                // For "block" kind: send incremental text (streaming)
+                                // For "final" kind: send complete text (final message)
+                                if (kind === "block") {
+                                    // Calculate incremental text
+                                    const incrementalText = completeText.slice(sentTextLength);
+                                    if (incrementalText.length > 0) {
+                                        console.log("\n" + "-".repeat(60));
+                                        console.log(`XiaoYi: [STREAM] Incremental block received`);
+                                        console.log(`  Session: ${sessionId}`);
+                                        console.log(`  Elapsed: ${elapsed}ms`);
+                                        console.log(`  Total length: ${completeText.length} chars`);
+                                        console.log(`  Incremental: +${incrementalText.length} chars (sent: ${sentTextLength})`);
+                                        console.log(`  Preview: "${incrementalText.substring(0, 50)}${incrementalText.length > 50 ? "..." : ""}"`);
+                                        console.log("-".repeat(60) + "\n");
+                                        const response = {
+                                            sessionId: 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: incrementalText,
+                                            },
+                                            status: "success",
+                                        };
+                                        // Send incremental text, NOT final, append mode
+                                        await conn.sendResponse(response, taskId, sessionId, false, true);
+                                        console.log(`✓ XiaoYi: Stream chunk sent (+${incrementalText.length} chars)\n`);
+                                        // Update sent length
+                                        sentTextLength = completeText.length;
+                                    }
+                                    else {
+                                        console.log("\n" + "-".repeat(60));
+                                        console.log(`XiaoYi: [STREAM] No new text to send`);
+                                        console.log(`  Session: ${sessionId}`);
+                                        console.log(`  Total length: ${completeText.length} chars`);
+                                        console.log(`  Already sent: ${sentTextLength} chars`);
+                                        console.log("-".repeat(60) + "\n");
+                                    }
+                                }
+                                else if (kind === "final") {
+                                    console.log("\n" + "=".repeat(60));
+                                    console.log(`XiaoYi: [STREAM] Final response received`);
+                                    console.log(`  Session: ${sessionId}`);
+                                    console.log(`  Elapsed: ${elapsed}ms`);
+                                    console.log(`  Total length: ${completeText.length} chars`);
+                                    console.log(`  Preview: "${completeText.substring(0, 100)}..."`);
+                                    console.log("=".repeat(60) + "\n");
+                                    const response = {
+                                        sessionId: 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: completeText,
+                                        },
+                                        status: "success",
+                                    };
+                                    // Send complete text as FINAL, NOT append
                                     await conn.sendResponse(response, taskId, sessionId, true, false);
-                                    console.log(`✓ XiaoYi: Response sent successfully\n`);
+                                    console.log(`✓ XiaoYi: Final response sent (${completeText.length} chars)\n`);
+                                    // Clear timeout and abort controller on final
+                                    runtime.markSessionCompleted(sessionId);
+                                    // Note: Don't clear abort controller here, let onIdle handle it
+                                    // This ensures we can still abort if there's any pending cleanup
                                 }
-                                else {
-                                    console.error(`✗ XiaoYi: Connection not available\n`);
+                                else if (kind === "tool") {
+                                    // Tool results - typically not sent as messages
+                                    console.log("\n" + "-".repeat(60));
+                                    console.log(`XiaoYi: [STREAM] Tool result received (not forwarded)`);
+                                    console.log(`  Session: ${sessionId}`);
+                                    console.log(`  Elapsed: ${elapsed}ms`);
+                                    console.log("-".repeat(60) + "\n");
                                 }
-                                // Clear timeout as response was sent successfully
-                                runtime.markSessionCompleted(sessionId);
                             },
                             onIdle: async () => {
                                 const elapsed = Date.now() - startTime;

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.3",
+  "version": "2.4.5",
   "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": {