@ynhcj/xiaoyi 2.0.4 → 2.0.6

package/dist/channel.js

@@ -242,8 +242,8 @@ exports.xiaoyiPlugin = {
                         cfg: config,
                         dispatcherOptions: {
                             deliver: async (payload) => {
-                                console.log("XiaoYi: Delivering response:", payload);
-                                // Send response back through WebSocket
+                                console.log("XiaoYi: Delivering final response:", payload);
+                                // Send final response back through WebSocket
                                 const taskId = runtime.getTaskIdForSession(message.sessionId) || `task_${Date.now()}`;
                                 const response = {
                                     sessionId: message.sessionId,
@@ -264,7 +264,35 @@ exports.xiaoyiPlugin = {
                                 const conn = runtime.getConnection();
                                 if (conn) {
                                     await conn.sendResponse(response, taskId, message.sessionId);
-                                    console.log("XiaoYi: Response sent successfully");
+                                    console.log("XiaoYi: Final response sent successfully");
+                                }
+                            },
+                        },
+                        replyOptions: {
+                            // Enable streaming responses through onPartialReply callback
+                            onPartialReply: async (payload) => {
+                                console.log("XiaoYi: Streaming partial response:", payload.text?.substring(0, 50));
+                                // Send partial response back through WebSocket
+                                const taskId = runtime.getTaskIdForSession(message.sessionId) || `task_${Date.now()}`;
+                                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: payload.text || "",
+                                    },
+                                    status: "processing",
+                                };
+                                const conn = runtime.getConnection();
+                                if (conn) {
+                                    await conn.sendResponse(partialResponse, taskId, message.sessionId);
                                 }
                             },
                         },

package/dist/types.d.ts

@@ -52,6 +52,61 @@ export interface A2AResponseMessage {
         message: string;
     };
 }
+export interface A2AJsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string;
+    result?: A2ATaskArtifactUpdateEvent | A2ATaskStatusUpdateEvent | A2AClearContextResult | A2ATasksCancelResult;
+    error?: {
+        code: number | string;
+        message: string;
+    };
+}
+export interface A2ATaskArtifactUpdateEvent {
+    taskId: string;
+    kind: "artifact-update";
+    append?: boolean;
+    lastChunk?: boolean;
+    final: boolean;
+    artifact: {
+        artifactId: string;
+        parts: Array<{
+            kind: "text" | "file" | "data";
+            text?: string;
+            file?: {
+                name: string;
+                mimeType: string;
+                bytes?: string;
+                uri?: string;
+            };
+            data?: any;
+        }>;
+    };
+}
+export interface A2ATaskStatusUpdateEvent {
+    taskId: string;
+    kind: "status-update";
+    final: boolean;
+    status: {
+        message: {
+            role: "agent";
+            parts: Array<{
+                kind: "text";
+                text: string;
+            }>;
+        };
+        state: "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "unknown";
+    };
+}
+export interface A2AClearContextResult {
+    status: {
+        state: "cleared" | "failed" | "unknown";
+    };
+}
+export interface A2ATasksCancelResult {
+    status: {
+        state: "canceled" | "failed" | "unknown";
+    };
+}
 export interface A2AWebSocketMessage {
     type: "message" | "heartbeat" | "auth" | "error";
     data: A2ARequestMessage | A2AResponseMessage | any;

package/dist/websocket.d.ts

@@ -23,9 +23,24 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
      */
     private sendInitMessage;
     /**
-     * Send A2A response message
+     * Send A2A response message (converts to JSON-RPC 2.0 format)
+     * This method is for regular agent responses only
      */
     sendResponse(response: A2AResponseMessage, taskId: string, sessionId: string): Promise<void>;
+    /**
+     * Send A2A clear context response (uses specific clear context format)
+     * Reference: https://developer.huawei.com/consumer/cn/doc/service/clear-context-0000002537681163
+     */
+    sendClearContextResponse(requestId: string, sessionId: string, success?: boolean): Promise<void>;
+    /**
+     * Send A2A tasks cancel response (uses specific cancel format)
+     * Reference: https://developer.huawei.com/consumer/cn/doc/service/tasks-cancel-0000002537561193
+     */
+    sendTasksCancelResponse(requestId: string, sessionId: string, success?: boolean): Promise<void>;
+    /**
+     * Convert A2AResponseMessage to A2A JSON-RPC 2.0 format
+     */
+    private convertToJsonRpcFormat;
     /**
      * Send generic outbound message
      */

package/dist/websocket.js

@@ -95,21 +95,129 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         console.log("Sent clawd_bot_init message");
     }
     /**
-     * Send A2A response message
+     * Send A2A response message (converts to JSON-RPC 2.0 format)
+     * This method is for regular agent responses only
      */
     async sendResponse(response, taskId, sessionId) {
         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 message = {
             msgType: "agent_response",
             agentId: this.config.agentId,
             sessionId: sessionId,
             taskId: taskId,
-            msgDetail: JSON.stringify(response),
+            msgDetail: JSON.stringify(jsonRpcResponse),
         };
         this.sendMessage(message);
     }
+    /**
+     * Send A2A clear context response (uses specific clear context format)
+     * Reference: https://developer.huawei.com/consumer/cn/doc/service/clear-context-0000002537681163
+     */
+    async sendClearContextResponse(requestId, sessionId, success = true) {
+        if (!this.isReady()) {
+            throw new Error("WebSocket not ready");
+        }
+        const jsonRpcResponse = {
+            jsonrpc: "2.0",
+            id: requestId,
+            result: {
+                status: {
+                    state: success ? "cleared" : "failed"
+                }
+            },
+        };
+        const message = {
+            msgType: "agent_response",
+            agentId: this.config.agentId,
+            sessionId: sessionId,
+            taskId: requestId,
+            msgDetail: JSON.stringify(jsonRpcResponse),
+        };
+        this.sendMessage(message);
+    }
+    /**
+     * Send A2A tasks cancel response (uses specific cancel format)
+     * Reference: https://developer.huawei.com/consumer/cn/doc/service/tasks-cancel-0000002537561193
+     */
+    async sendTasksCancelResponse(requestId, sessionId, success = true) {
+        if (!this.isReady()) {
+            throw new Error("WebSocket not ready");
+        }
+        const jsonRpcResponse = {
+            jsonrpc: "2.0",
+            id: requestId,
+            result: {
+                status: {
+                    state: success ? "canceled" : "failed"
+                }
+            },
+        };
+        const message = {
+            msgType: "agent_response",
+            agentId: this.config.agentId,
+            sessionId: sessionId,
+            taskId: requestId,
+            msgDetail: JSON.stringify(jsonRpcResponse),
+        };
+        this.sendMessage(message);
+    }
+    /**
+     * Convert A2AResponseMessage to A2A JSON-RPC 2.0 format
+     */
+    convertToJsonRpcFormat(response, taskId) {
+        // Generate artifact ID
+        const artifactId = `artifact_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        // Check if there's an error
+        if (response.status === "error" && response.error) {
+            return {
+                jsonrpc: "2.0",
+                id: response.messageId,
+                error: {
+                    code: response.error.code,
+                    message: response.error.message,
+                },
+            };
+        }
+        // Convert content to artifact parts
+        const parts = [];
+        if (response.content.type === "text" && response.content.text) {
+            parts.push({
+                kind: "text",
+                text: response.content.text,
+            });
+        }
+        else if (response.content.type === "file") {
+            parts.push({
+                kind: "file",
+                file: {
+                    name: response.content.fileName || "file",
+                    mimeType: response.content.mimeType || "application/octet-stream",
+                    uri: response.content.mediaUrl,
+                },
+            });
+        }
+        // Create TaskArtifactUpdateEvent
+        const artifactEvent = {
+            taskId: taskId,
+            kind: "artifact-update",
+            append: false,
+            lastChunk: true,
+            final: true, // Mark as final since this is the complete response
+            artifact: {
+                artifactId: artifactId,
+                parts: parts,
+            },
+        };
+        return {
+            jsonrpc: "2.0",
+            id: response.messageId,
+            result: artifactEvent,
+        };
+    }
     /**
      * Send generic outbound message
      */
@@ -212,25 +320,8 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
      */
     handleClearMessage(message) {
         console.log(`Received clear message for session: ${message.sessionId}`);
-        // Send success response according to A2A spec
-        const response = {
-            sessionId: message.sessionId,
-            messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-            timestamp: Date.now(),
-            agentId: this.config.agentId,
-            sender: {
-                id: this.config.agentId,
-                name: "OpenClaw Agent",
-                type: "agent",
-            },
-            content: {
-                type: "text",
-                text: "Context cleared successfully",
-            },
-            status: "success",
-        };
-        // Send response
-        this.sendResponse(response, message.id, message.sessionId).catch(error => {
+        // Send success response according to A2A spec using the correct format
+        this.sendClearContextResponse(message.id, message.sessionId, true).catch(error => {
             console.error("Failed to send clear response:", error);
         });
         // Emit clear event for application to handle
@@ -258,23 +349,8 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
      * Send tasks/cancel success response
      */
     async sendCancelSuccessResponse(sessionId, taskId, requestId) {
-        const response = {
-            sessionId: sessionId,
-            messageId: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-            timestamp: Date.now(),
-            agentId: this.config.agentId,
-            sender: {
-                id: this.config.agentId,
-                name: "OpenClaw Agent",
-                type: "agent",
-            },
-            content: {
-                type: "text",
-                text: "Task cancelled successfully",
-            },
-            status: "success",
-        };
-        await this.sendResponse(response, requestId, sessionId);
+        // Use the dedicated tasks cancel response method with correct format
+        await this.sendTasksCancelResponse(requestId, sessionId, true);
         // Remove from active tasks
         this.activeTasks.delete(taskId);
     }

package/package.json

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