@ynhcj/xiaoyi 2.0.8 → 2.1.0

package/dist/channel.js

@@ -245,16 +245,22 @@ exports.xiaoyiPlugin = {
                     SenderId: senderId,
                     OriginatingChannel: "xiaoyi",
                 };
-                // Use the correct API to dispatch the message (non-streaming mode)
+                // Use the correct API to dispatch the message (streaming mode enabled)
                 try {
+                    // Track response state for streaming
+                    let accumulatedText = "";
+                    let taskId = runtime.getTaskIdForSession(message.sessionId) || `task_${Date.now()}`;
+                    let frameCount = 0;
                     await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
                         ctx: msgContext,
                         cfg: config,
                         dispatcherOptions: {
                             deliver: async (payload) => {
                                 console.log("XiaoYi: Delivering final response:", payload.text?.substring(0, 100) + "...");
-                                // Send final response back through WebSocket (non-streaming, complete message)
-                                const taskId = runtime.getTaskIdForSession(message.sessionId) || `task_${Date.now()}`;
+                                // Get the complete text
+                                const completeText = payload.text || "";
+                                accumulatedText = completeText;
+                                // Send FINAL frame with complete content
                                 const response = {
                                     sessionId: message.sessionId,
                                     messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
@@ -267,20 +273,58 @@ exports.xiaoyiPlugin = {
                                     },
                                     content: {
                                         type: "text",
-                                        text: payload.text || "",
+                                        text: accumulatedText, // Complete content
                                     },
                                     status: "success",
                                 };
                                 const conn = runtime.getConnection();
                                 if (conn) {
-                                    await conn.sendResponse(response, taskId, message.sessionId);
-                                    console.log("XiaoYi: Final response sent successfully (non-streaming mode)");
+                                    // Use append=false for final frame (complete content)
+                                    await conn.sendResponse(response, taskId, message.sessionId, true, false);
+                                    console.log(`XiaoYi: Final frame sent (#${++frameCount}, isFinal=true, append=false, total length: ${accumulatedText.length})`);
                                 }
                             },
+                            onIdle: async () => {
+                                console.log("XiaoYi: OpenClaw processing complete");
+                                // All frames already sent, nothing more to do
+                            },
                         },
                         replyOptions: {
-                        // Disable streaming by removing onPartialReply callback
-                        // This ensures all responses are buffered and delivered only once at the end
+                            // Enable streaming responses through onPartialReply callback
+                            onPartialReply: async (payload) => {
+                                const newText = payload.text || "";
+                                if (!newText) {
+                                    return; // Skip empty responses
+                                }
+                                console.log("XiaoYi: Streaming partial response:", newText.substring(0, 30) + "...");
+                                // Calculate delta text (增量部分)
+                                const previousLength = accumulatedText.length;
+                                accumulatedText = newText;
+                                const deltaText = newText.slice(previousLength);
+                                // 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, // Send delta only (or full if delta is empty)
+                                    },
+                                    status: "processing", // Mark as processing
+                                };
+                                const conn = runtime.getConnection();
+                                if (conn) {
+                                    // Use append=true for streaming frames (服务端会追加)
+                                    await conn.sendResponse(partialResponse, taskId, message.sessionId, false, true);
+                                    console.log(`XiaoYi: Partial frame sent (#${++frameCount}, isFinal=false, append=true, delta length: ${deltaText.length || newText.length})`);
+                                }
+                            },
                         },
                     });
                 }

package/dist/websocket.d.ts

@@ -25,8 +25,13 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
     /**
      * Send A2A response message (converts to JSON-RPC 2.0 format)
      * This method is for regular agent responses only
+     * @param response - The response message
+     * @param taskId - The task ID
+     * @param sessionId - The session ID
+     * @param isFinal - Whether this is the final frame (default: true)
+     * @param append - Whether to append to previous content (default: false for complete content)
      */
-    sendResponse(response: A2AResponseMessage, taskId: string, sessionId: string): Promise<void>;
+    sendResponse(response: A2AResponseMessage, taskId: string, sessionId: string, isFinal?: boolean, append?: boolean): Promise<void>;
     /**
      * Send A2A clear context response (uses specific clear context format)
      * Reference: https://developer.huawei.com/consumer/cn/doc/service/clear-context-0000002537681163
@@ -39,6 +44,10 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
     sendTasksCancelResponse(requestId: string, sessionId: string, success?: boolean): Promise<void>;
     /**
      * Convert A2AResponseMessage to A2A JSON-RPC 2.0 format
+     * @param response - The response message
+     * @param taskId - The task ID
+     * @param isFinal - Whether this is the final frame (default: true)
+     * @param append - Whether to append to previous content (default: false)
      */
     private convertToJsonRpcFormat;
     /**

package/dist/websocket.js

@@ -42,11 +42,7 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             });
             this.setupWebSocketHandlers();
             return new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => {
-                    reject(new Error("Connection timeout"));
-                }, 30000); // Increased timeout to 30 seconds
                 this.ws.once("open", () => {
-                    clearTimeout(timeout);
                     this.state.connected = true;
                     this.state.authenticated = true; // Authenticated via headers
                     this.state.reconnectAttempts = 0;
@@ -59,7 +55,6 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
                     resolve();
                 });
                 this.ws.once("error", (error) => {
-                    clearTimeout(timeout);
                     reject(error);
                 });
             });
@@ -97,13 +92,18 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     /**
      * Send A2A response message (converts to JSON-RPC 2.0 format)
      * This method is for regular agent responses only
+     * @param response - The response message
+     * @param taskId - The task ID
+     * @param sessionId - The session ID
+     * @param isFinal - Whether this is the final frame (default: true)
+     * @param append - Whether to append to previous content (default: false for complete content)
      */
-    async sendResponse(response, taskId, sessionId) {
+    async sendResponse(response, taskId, sessionId, isFinal = true, append = false) {
         if (!this.isReady()) {
             throw new Error("WebSocket not ready");
         }
         // Convert A2AResponseMessage to A2A JSON-RPC 2.0 format
-        const jsonRpcResponse = this.convertToJsonRpcFormat(response, taskId);
+        const jsonRpcResponse = this.convertToJsonRpcFormat(response, taskId, isFinal, append);
         const message = {
             msgType: "agent_response",
             agentId: this.config.agentId,
@@ -167,8 +167,12 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     }
     /**
      * Convert A2AResponseMessage to A2A JSON-RPC 2.0 format
+     * @param response - The response message
+     * @param taskId - The task ID
+     * @param isFinal - Whether this is the final frame (default: true)
+     * @param append - Whether to append to previous content (default: false)
      */
-    convertToJsonRpcFormat(response, taskId) {
+    convertToJsonRpcFormat(response, taskId, isFinal = true, append = false) {
         // Generate artifact ID
         const artifactId = `artifact_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         // Check if there's an error
@@ -200,13 +204,13 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
                 },
             });
         }
-        // Create TaskArtifactUpdateEvent
+        // Create TaskArtifactUpdateEvent with configurable flags
         const artifactEvent = {
             taskId: taskId,
             kind: "artifact-update",
-            append: false,
-            lastChunk: true,
-            final: true, // Mark as final since this is the complete response
+            append: append, // Controls whether to append or replace content
+            lastChunk: isFinal, // Set based on isFinal parameter
+            final: isFinal, // Set based on isFinal parameter
             artifact: {
                 artifactId: artifactId,
                 parts: parts,

package/package.json

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