@ynhcj/xiaoyi 2.0.5 → 2.0.7

package/dist/channel.js

@@ -211,28 +211,38 @@ exports.xiaoyiPlugin = {
                 const { getXiaoYiRuntime } = require("./runtime");
                 const runtime = getXiaoYiRuntime();
                 console.log(`XiaoYi: [Message Handler] Using runtime instance: ${runtime.getInstanceId()}`);
-                // Store sessionId -> taskId mapping in runtime
-                runtime.setTaskIdForSession(message.sessionId, message.id);
+                // Store sessionId -> taskId mapping in runtime (use params.id as taskId)
+                runtime.setTaskIdForSession(message.sessionId, message.params.id);
                 // Get PluginRuntime from our runtime wrapper
                 const pluginRuntime = runtime.getPluginRuntime();
                 if (!pluginRuntime) {
                     console.error("PluginRuntime not available");
                     return;
                 }
+                // Extract text content from parts array (ignore kind: "data" as per user request)
+                let bodyText = "";
+                for (const part of message.params.message.parts) {
+                    if (part.kind === "text" && part.text) {
+                        bodyText += part.text;
+                    }
+                    // TODO: Handle file parts if needed in the future
+                }
+                // Determine sender ID from role
+                const senderId = message.params.message.role === "user" ? "user" : message.agentId;
                 // Build MsgContext for OpenClaw's message pipeline
                 const msgContext = {
-                    Body: message.content.text || "",
-                    From: message.sender.id,
+                    Body: bodyText,
+                    From: senderId,
                     To: message.sessionId,
                     SessionKey: `xiaoyi:${resolvedAccount.accountId}:${message.sessionId}`,
                     AccountId: resolvedAccount.accountId,
-                    MessageSid: message.messageId,
-                    Timestamp: message.timestamp,
+                    MessageSid: message.id, // Use top-level id as message sequence number
+                    Timestamp: Date.now(), // Generate timestamp since new format doesn't include it
                     Provider: "xiaoyi",
                     Surface: "xiaoyi",
                     ChatType: "direct",
-                    SenderName: message.sender.name,
-                    SenderId: message.sender.id,
+                    SenderName: message.params.message.role, // Use role as sender name
+                    SenderId: senderId,
                     OriginatingChannel: "xiaoyi",
                 };
                 // Use the correct API to dispatch the message

package/dist/types.d.ts

@@ -1,26 +1,27 @@
 export interface A2ARequestMessage {
     agentId: string;
     sessionId: string;
+    jsonrpc: "2.0";
     id: string;
-    messageId: string;
-    timestamp: number;
-    sender: {
+    method: "message/stream";
+    params: {
         id: string;
-        name?: string;
-        type: "user" | "agent";
-    };
-    content: {
-        type: "text" | "image" | "audio" | "video" | "file";
-        text?: string;
-        mediaUrl?: string;
-        fileName?: string;
-        fileSize?: number;
-        mimeType?: string;
-    };
-    context?: {
-        conversationId?: string;
-        threadId?: string;
-        replyToMessageId?: string;
+        sessionId: string;
+        agentLoginSessionId?: string;
+        message: {
+            role: "user" | "agent";
+            parts: Array<{
+                kind: "text" | "file" | "data";
+                text?: string;
+                file?: {
+                    name: string;
+                    mimeType: string;
+                    bytes?: string;
+                    uri?: string;
+                };
+                data?: any;
+            }>;
+        };
     };
 }
 export interface A2AResponseMessage {
@@ -52,6 +53,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
      */
@@ -61,7 +76,7 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
      */
     sendCancelSuccessResponse(sessionId: string, taskId: string, requestId: string): Promise<void>;
     /**
-     * Type guard for A2A request messages
+     * Type guard for A2A request messages (JSON-RPC 2.0 format)
      */
     private isA2ARequestMessage;
     /**

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,38 +349,27 @@ 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);
     }
     /**
-     * Type guard for A2A request messages
+     * Type guard for A2A request messages (JSON-RPC 2.0 format)
      */
     isA2ARequestMessage(data) {
         return data &&
             typeof data.agentId === "string" &&
             typeof data.sessionId === "string" &&
+            data.jsonrpc === "2.0" &&
             typeof data.id === "string" &&
-            typeof data.messageId === "string" &&
-            typeof data.timestamp === "number" &&
-            data.sender &&
-            data.content;
+            data.method === "message/stream" &&
+            data.params &&
+            typeof data.params.id === "string" &&
+            typeof data.params.sessionId === "string" &&
+            data.params.message &&
+            typeof data.params.message.role === "string" &&
+            Array.isArray(data.params.message.parts);
     }
     /**
      * Start protocol-level heartbeat (ping/pong)

package/package.json

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