@ynhcj/xiaoyi-channel 1.1.0 → 1.1.2

package/dist/src/channel.js

@@ -6,6 +6,7 @@ import { locationTool } from "./tools/location-tool.js";
 import { noteTool } from "./tools/note-tool.js";
 import { searchNoteTool } from "./tools/search-note-tool.js";
 import { calendarTool } from "./tools/calendar-tool.js";
+import { searchCalendarTool } from "./tools/search-calendar-tool.js";
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -45,7 +46,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     onboarding: xyOnboardingAdapter,
-    agentTools: [locationTool, noteTool, searchNoteTool, calendarTool],
+    agentTools: [locationTool, noteTool, searchNoteTool, calendarTool, searchCalendarTool],
     messaging: {
         normalizeTarget: (raw) => {
             const trimmed = raw.trim();

package/dist/src/formatter.d.ts

@@ -20,6 +20,23 @@ export interface SendA2AResponseParams {
  * Send an A2A artifact update response.
  */
 export declare function sendA2AResponse(params: SendA2AResponseParams): Promise<void>;
+/**
+ * Parameters for sending a reasoning text update (intermediate, streamed).
+ */
+export interface SendReasoningTextUpdateParams {
+    config: XYChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    text: string;
+    append?: boolean;
+}
+/**
+ * Send an A2A artifact-update with reasoningText part.
+ * Used for onToolStart, onToolResult, onReasoningStream, onReasoningEnd, onPartialReply.
+ * append=true, final=false, lastChunk=true, text is suffixed with newline for markdown rendering.
+ */
+export declare function sendReasoningTextUpdate(params: SendReasoningTextUpdateParams): Promise<void>;
 /**
  * Parameters for sending a status update.
  */

package/dist/src/formatter.js

@@ -67,6 +67,49 @@ export async function sendA2AResponse(params) {
     await wsManager.sendMessage(sessionId, outboundMessage);
     log(`[A2A_RESPONSE] ✅ Message sent successfully`);
 }
+/**
+ * Send an A2A artifact-update with reasoningText part.
+ * Used for onToolStart, onToolResult, onReasoningStream, onReasoningEnd, onPartialReply.
+ * append=true, final=false, lastChunk=true, text is suffixed with newline for markdown rendering.
+ */
+export async function sendReasoningTextUpdate(params) {
+    const { config, sessionId, taskId, messageId, text, append = true } = params;
+    const runtime = getXYRuntime();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    const artifact = {
+        taskId,
+        kind: "artifact-update",
+        append,
+        lastChunk: true,
+        final: false,
+        artifact: {
+            artifactId: uuidv4(),
+            parts: [
+                {
+                    kind: "reasoningText",
+                    reasoningText: text,
+                },
+            ],
+        },
+    };
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: artifact,
+    };
+    const wsManager = getXYWebSocketManager(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    log(`[REASONING_TEXT] 📤 Sending reasoningText update: sessionId=${sessionId}, taskId=${taskId}, text.length=${text.length}`);
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[REASONING_TEXT] ✅ Sent successfully`);
+}
 /**
  * Send an A2A task status update.
  * Follows A2A protocol standard format with nested status object.

package/dist/src/reply-dispatcher.js

@@ -1,6 +1,6 @@
 import { createReplyPrefixContext } from "openclaw/plugin-sdk";
 import { getXYRuntime } from "./runtime.js";
-import { sendA2AResponse, sendStatusUpdate } from "./formatter.js";
+import { sendA2AResponse, sendStatusUpdate, sendReasoningTextUpdate } from "./formatter.js";
 import { resolveXYConfig } from "./config.js";
 /**
  * Create a reply dispatcher for XY channel messages.
@@ -87,6 +87,15 @@ export function createXYReplyDispatcher(params) {
                 accumulatedText += text;
                 hasSentResponse = true;
                 log(`[DELIVER ACCUMULATE] Accumulated text, current length=${accumulatedText.length}`);
+                // Also stream text as reasoningText for real-time display
+                await sendReasoningTextUpdate({
+                    config,
+                    sessionId,
+                    taskId,
+                    messageId,
+                    text,
+                });
+                log(`[DELIVER] ✅ Sent deliver text as reasoningText update`);
             }
             catch (deliverError) {
                 error(`Failed to deliver message:`, deliverError);
@@ -119,6 +128,16 @@ export function createXYReplyDispatcher(params) {
             if (hasSentResponse && !finalSent) {
                 log(`[ON_IDLE] Sending accumulated text, length=${accumulatedText.length}`);
                 try {
+                    // Send status update before final message
+                    await sendStatusUpdate({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务处理已完成~",
+                        state: "completed",
+                    });
+                    log(`[ON_IDLE] ✅ Sent completion status update`);
                     await sendA2AResponse({
                         config,
                         sessionId,
@@ -137,14 +156,38 @@ export function createXYReplyDispatcher(params) {
             }
             else {
                 log(`[ON_IDLE] Skipping final message: hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+                // Task was interrupted - send failure status and error response
+                try {
+                    await sendStatusUpdate({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务处理中断了~",
+                        state: "failed",
+                    });
+                    log(`[ON_IDLE] ✅ Sent failure status update`);
+                    await sendA2AResponse({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务执行异常，请重试~",
+                        append: false,
+                        final: true,
+                    });
+                    finalSent = true;
+                    log(`[ON_IDLE] ✅ Sent error response`);
+                }
+                catch (err) {
+                    error(`[ON_IDLE] Failed to send failure status and error response:`, err);
+                }
             }
             // Stop status updates
             stopStatusInterval();
         },
         onCleanup: () => {
             log(`[ON_CLEANUP] Reply cleanup for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
-            // Stop status updates
-            stopStatusInterval();
         },
     });
     return {
@@ -152,6 +195,106 @@ export function createXYReplyDispatcher(params) {
         replyOptions: {
             ...replyOptions,
             onModelSelected: prefixContext.onModelSelected,
+            // 🔧 Tool execution start callback
+            onToolStart: async ({ name, phase }) => {
+                log(`[TOOL START] 🔧 Tool execution started/updated: name=${name}, phase=${phase}, session=${sessionId}, taskId=${taskId}`);
+                if (phase === "start") {
+                    const toolName = name || "unknown";
+                    try {
+                        await sendStatusUpdate({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text: `正在使用工具: ${toolName}...`,
+                            state: "working",
+                        });
+                        log(`[TOOL START] ✅ Sent status update for tool start: ${toolName}`);
+                    }
+                    catch (err) {
+                        error(`[TOOL START] ❌ Failed to send tool start status:`, err);
+                    }
+                }
+            },
+            // 🔧 Tool execution result callback
+            onToolResult: async (payload) => {
+                const text = payload.text ?? "";
+                const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+                log(`[TOOL RESULT] 🔧 Tool execution result received: session=${sessionId}, taskId=${taskId}`);
+                log(`[TOOL RESULT]   - text.length=${text.length}`);
+                log(`[TOOL RESULT]   - hasMedia=${hasMedia}`);
+                log(`[TOOL RESULT]   - isError=${payload.isError}`);
+                if (text.length > 0) {
+                    log(`[TOOL RESULT]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                try {
+                    if (text.length > 0 || hasMedia) {
+                        const resultText = text.length > 0 ? text : "工具执行完成";
+                        await sendStatusUpdate({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text: resultText,
+                            state: "working",
+                        });
+                        log(`[TOOL RESULT] ✅ Sent tool result as status update`);
+                    }
+                }
+                catch (err) {
+                    error(`[TOOL RESULT] ❌ Failed to send tool result status:`, err);
+                }
+            },
+            // 🧠 Reasoning/thinking process streaming callback
+            onReasoningStream: async (payload) => {
+                const text = payload.text ?? "";
+                log(`[REASONING STREAM] 🧠 Reasoning/thinking chunk received: session=${sessionId}, taskId=${taskId}`);
+                log(`[REASONING STREAM]   - text.length=${text.length}`);
+                if (text.length > 0) {
+                    log(`[REASONING STREAM]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                // try {
+                //   if (text.length > 0) {
+                //     await sendReasoningTextUpdate({
+                //       config,
+                //       sessionId,
+                //       taskId,
+                //       messageId,
+                //       text,
+                //     });
+                //     log(`[REASONING STREAM] ✅ Sent reasoning chunk as reasoningText update`);
+                //   }
+                // } catch (err) {
+                //   error(`[REASONING STREAM] ❌ Failed to send reasoning chunk reasoningText:`, err);
+                // }
+            },
+            // 📝 Partial reply streaming callback (real-time preview)
+            onPartialReply: async (payload) => {
+                const text = payload.text ?? "";
+                const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+                log(`[PARTIAL REPLY] 📝 Partial reply chunk received: session=${sessionId}, taskId=${taskId}`);
+                log(`[PARTIAL REPLY]   - text.length=${text.length}`);
+                log(`[PARTIAL REPLY]   - hasMedia=${hasMedia}`);
+                if (text.length > 0) {
+                    log(`[PARTIAL REPLY]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                try {
+                    if (text.length > 0) {
+                        await sendReasoningTextUpdate({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text,
+                            append: false,
+                        });
+                        log(`[PARTIAL REPLY] ✅ Sent partial reply as reasoningText update (append=false)`);
+                    }
+                }
+                catch (err) {
+                    error(`[PARTIAL REPLY] ❌ Failed to send partial reply reasoningText:`, err);
+                }
+            },
         },
         markDispatchIdle,
         startStatusInterval, // Expose this to be called immediately

package/dist/src/tools/search-calendar-tool.d.ts

@@ -0,0 +1,12 @@
+/**
+ * XY search calendar event tool - searches calendar events on user's device.
+ * Returns matching events based on time range and optional title filter.
+ *
+ * Time range guidelines:
+ * - For a specific day: use 00:00:00 to 23:59:59 of that day
+ * - For morning: 06:00:00 to 12:00:00
+ * - For afternoon: 12:00:00 to 18:00:00
+ * - For evening: 18:00:00 to 24:00:00
+ * - For a specific time: use ±1 hour range (e.g., for 3PM, use 14:00:00 to 16:00:00)
+ */
+export declare const searchCalendarTool: any;

package/dist/src/tools/search-calendar-tool.js

@@ -0,0 +1,220 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getLatestSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY search calendar event tool - searches calendar events on user's device.
+ * Returns matching events based on time range and optional title filter.
+ *
+ * Time range guidelines:
+ * - For a specific day: use 00:00:00 to 23:59:59 of that day
+ * - For morning: 06:00:00 to 12:00:00
+ * - For afternoon: 12:00:00 to 18:00:00
+ * - For evening: 18:00:00 to 24:00:00
+ * - For a specific time: use ±1 hour range (e.g., for 3PM, use 14:00:00 to 16:00:00)
+ */
+export const searchCalendarTool = {
+    name: "search_calendar_event",
+    label: "Search Calendar Event",
+    description: `检索用户日历中的日程安排。根据时间范围和可选的日程标题进行检索。时间格式必须为：YYYYMMDD hhmmss（例如：20240115 143000）。
+
+时间范围说明：
+- 查询某一天的日程：使用该天的 00:00:00 到 23:59:59（例如：20240115 000000 到 20240115 235959）
+- 查询上午的日程：使用 06:00:00 到 12:00:00
+- 查询下午的日程：使用 12:00:00 到 18:00:00
+- 查询晚上的日程：使用 18:00:00 到 23:59:59
+- 查询某个时刻附近的日程：使用该时刻前后1小时的区间（例如：查询3点左右的日程，使用 14:00:00 到 16:00:00）
+
+注意：该工具执行时间较长（最多60秒），请勿重复调用，超时或失败时最多重试一次。`,
+    parameters: {
+        type: "object",
+        properties: {
+            startTime: {
+                type: "string",
+                description: "日程起始时间，格式必须为：YYYYMMDD hhmmss（例如：20240115 143000 表示 2024年1月15日 14:30:00）",
+            },
+            endTime: {
+                type: "string",
+                description: "日程结束时间，格式必须为：YYYYMMDD hhmmss（例如：20240115 173000 表示 2024年1月15日 17:30:00）",
+            },
+            title: {
+                type: "string",
+                description: "日程标题/类型（可选），用于过滤特定类型的日程",
+            },
+        },
+        required: ["startTime", "endTime"],
+    },
+    async execute(toolCallId, params) {
+        logger.log(`[SEARCH_CALENDAR_TOOL] 🚀 Starting execution`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - timestamp: ${new Date().toISOString()}`);
+        // Validate parameters
+        if (!params.startTime || !params.endTime) {
+            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Missing required parameters`);
+            throw new Error("Missing required parameters: startTime and endTime are required");
+        }
+        // Convert time strings to millisecond timestamps
+        logger.log(`[SEARCH_CALENDAR_TOOL] 🕒 Converting time strings to timestamps...`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - startTime input: ${params.startTime}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - endTime input: ${params.endTime}`);
+        // Parse YYYYMMDD hhmmss format
+        const parseTimeString = (timeStr) => {
+            // Remove any extra spaces and split
+            const cleaned = timeStr.trim().replace(/\s+/g, ' ');
+            const parts = cleaned.split(' ');
+            if (parts.length !== 2) {
+                throw new Error(`Invalid time format: ${timeStr}. Expected format: YYYYMMDD hhmmss`);
+            }
+            const datePart = parts[0]; // YYYYMMDD
+            const timePart = parts[1]; // hhmmss
+            if (datePart.length !== 8 || timePart.length !== 6) {
+                throw new Error(`Invalid time format: ${timeStr}. Expected format: YYYYMMDD hhmmss`);
+            }
+            const year = parseInt(datePart.substring(0, 4), 10);
+            const month = parseInt(datePart.substring(4, 6), 10) - 1; // Month is 0-indexed
+            const day = parseInt(datePart.substring(6, 8), 10);
+            const hours = parseInt(timePart.substring(0, 2), 10);
+            const minutes = parseInt(timePart.substring(2, 4), 10);
+            const seconds = parseInt(timePart.substring(4, 6), 10);
+            const date = new Date(year, month, day, hours, minutes, seconds);
+            return date.getTime();
+        };
+        let startTimeMs;
+        let endTimeMs;
+        try {
+            startTimeMs = parseTimeString(params.startTime);
+            endTimeMs = parseTimeString(params.endTime);
+        }
+        catch (error) {
+            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Time parsing error:`, error);
+            throw new Error(`Invalid time format. Required format: YYYYMMDD hhmmss (e.g., 20240115 143000). Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (isNaN(startTimeMs) || isNaN(endTimeMs)) {
+            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Invalid time format`);
+            throw new Error("Invalid time format. Required format: YYYYMMDD hhmmss (e.g., 20240115 143000)");
+        }
+        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Time conversion successful`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - startTime timestamp: ${startTimeMs}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - endTime timestamp: ${endTimeMs}`);
+        // Get session context
+        logger.log(`[SEARCH_CALENDAR_TOOL] 🔍 Attempting to get session context...`);
+        const sessionContext = getLatestSessionContext();
+        if (!sessionContext) {
+            logger.error(`[SEARCH_CALENDAR_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[SEARCH_CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);
+            throw new Error("No active XY session found. Search calendar tool can only be used during an active conversation.");
+        }
+        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Session context found`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - messageId: ${sessionContext.messageId}`);
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        logger.log(`[SEARCH_CALENDAR_TOOL] 🔌 Getting WebSocket manager...`);
+        const wsManager = getXYWebSocketManager(config);
+        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ WebSocket manager obtained`);
+        // Build SearchCalendarEvent command
+        logger.log(`[SEARCH_CALENDAR_TOOL] 📦 Building SearchCalendarEvent command...`);
+        // Build intentParam with timeInterval and optional title
+        const intentParam = {
+            timeInterval: [startTimeMs, endTimeMs],
+        };
+        if (params.title) {
+            intentParam.title = params.title;
+            logger.log(`[SEARCH_CALENDAR_TOOL]   - Including title filter: ${params.title}`);
+        }
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SearchCalendarEvent",
+                    bundleName: "com.huawei.hmos.calendardata",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    intentParam,
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        // Send command and wait for response (60 second timeout)
+        logger.log(`[SEARCH_CALENDAR_TOOL] ⏳ Setting up promise to wait for calendar search response...`);
+        logger.log(`[SEARCH_CALENDAR_TOOL]   - Timeout: 60 seconds`);
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                logger.error(`[SEARCH_CALENDAR_TOOL] ⏰ Timeout: No response received within 60 seconds`);
+                wsManager.off("data-event", handler);
+                reject(new Error("检索日程超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                logger.log(`[SEARCH_CALENDAR_TOOL] 📨 Received data event:`, JSON.stringify(event));
+                if (event.intentName === "SearchCalendarEvent") {
+                    logger.log(`[SEARCH_CALENDAR_TOOL] 🎯 SearchCalendarEvent event received`);
+                    logger.log(`[SEARCH_CALENDAR_TOOL]   - status: ${event.status}`);
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Calendar events retrieved successfully`);
+                        logger.log(`[SEARCH_CALENDAR_TOOL]   - outputs:`, JSON.stringify(event.outputs));
+                        // Return the result directly as requested
+                        const result = event.outputs.result;
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(result),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Calendar event search failed`);
+                        logger.error(`[SEARCH_CALENDAR_TOOL]   - status: ${event.status}`);
+                        reject(new Error(`检索日程失败: ${event.status}`));
+                    }
+                }
+            };
+            // Register event handler
+            logger.log(`[SEARCH_CALENDAR_TOOL] 📡 Registering data-event handler on WebSocket manager`);
+            wsManager.on("data-event", handler);
+            // Send the command
+            logger.log(`[SEARCH_CALENDAR_TOOL] 📤 Sending SearchCalendarEvent command...`);
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+                logger.log(`[SEARCH_CALENDAR_TOOL] ✅ Command sent successfully, waiting for response...`);
+            })
+                .catch((error) => {
+                logger.error(`[SEARCH_CALENDAR_TOOL] ❌ Failed to send command:`, error);
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/types.d.ts

@@ -75,7 +75,11 @@ export interface A2AArtifact {
     artifactId: string;
     parts: A2AArtifactPart[];
 }
-export type A2AArtifactPart = A2ATextPart | A2ADataPart | A2ACommandPart;
+export interface A2AReasoningTextPart {
+    kind: "reasoningText";
+    reasoningText: string;
+}
+export type A2AArtifactPart = A2ATextPart | A2ADataPart | A2ACommandPart | A2AReasoningTextPart;
 export interface A2ACommandPart {
     kind: "command";
     command: A2ACommand;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",