@ynhcj/xiaoyi-channel 0.0.5 → 0.0.7

package/dist/src/bot.js

@@ -19,7 +19,8 @@ export async function handleXYMessage(params) {
     try {
         // Check for special messages BEFORE parsing (these have different param structures)
         const messageMethod = message.method;
-        log(`[DEBUG] Received message with method: ${messageMethod}, id: ${message.id}`);
+        log(`[BOT-ENTRY] <<<<<<< Received message with method: ${messageMethod}, id: ${message.id} >>>>>>>`);
+        log(`[BOT-ENTRY] Stack trace for debugging:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
         // Handle clearContext messages (params only has sessionId)
         if (messageMethod === "clearContext" || messageMethod === "clear_context") {
             const sessionId = message.params?.sessionId;
@@ -61,7 +62,7 @@ export async function handleXYMessage(params) {
         // Use sessionId as peer.id to ensure all messages in the same session share context
         let route = core.channel.routing.resolveAgentRoute({
             cfg,
-            channel: "xy",
+            channel: "xiaoyi-channel",
             accountId, // "default"
             peer: {
                 kind: "direct",
@@ -70,6 +71,10 @@ export async function handleXYMessage(params) {
         });
         log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
         // Register session context for tools
+        log(`[BOT] 📝 About to register session for tools...`);
+        log(`[BOT]   - sessionKey: ${route.sessionKey}`);
+        log(`[BOT]   - sessionId: ${parsed.sessionId}`);
+        log(`[BOT]   - taskId: ${parsed.taskId}`);
         registerSession(route.sessionKey, {
             config,
             sessionId: parsed.sessionId,
@@ -77,6 +82,7 @@ export async function handleXYMessage(params) {
             messageId: parsed.messageId,
             agentId: route.accountId,
         });
+        log(`[BOT] ✅ Session registered for tools`);
         // Extract text and files from parts
         const text = extractTextFromParts(parsed.parts);
         const fileParts = extractFileParts(parsed.parts);
@@ -113,13 +119,13 @@ export async function handleXYMessage(params) {
             GroupSubject: undefined,
             SenderName: parsed.sessionId,
             SenderId: parsed.sessionId,
-            Provider: "xy",
-            Surface: "xy",
+            Provider: "xiaoyi-channel",
+            Surface: "xiaoyi-channel",
             MessageSid: parsed.messageId,
             Timestamp: Date.now(),
             WasMentioned: false,
             CommandAuthorized: true,
-            OriginatingChannel: "xy",
+            OriginatingChannel: "xiaoyi-channel",
             OriginatingTo: parsed.sessionId, // Original message target
             ReplyToBody: undefined, // A2A protocol doesn't support reply/quote
             ...mediaPayload,
@@ -150,12 +156,16 @@ export async function handleXYMessage(params) {
         startStatusInterval();
         log(`xy: dispatching to agent (session=${parsed.sessionId})`);
         // Dispatch to OpenClaw core using correct API (following feishu pattern)
+        log(`[BOT] 🚀 Starting dispatcher with session: ${route.sessionKey}`);
         await core.channel.reply.withReplyDispatcher({
             dispatcher,
             onSettled: () => {
+                log(`[BOT] 🏁 onSettled called for session: ${route.sessionKey}`);
+                log(`[BOT]   - About to unregister session...`);
                 markDispatchIdle();
                 // Unregister session context when done
                 unregisterSession(route.sessionKey);
+                log(`[BOT] ✅ Session unregistered in onSettled`);
             },
             run: () => core.channel.reply.dispatchReplyFromConfig({
                 ctx: ctxPayload,
@@ -164,30 +174,36 @@ export async function handleXYMessage(params) {
                 replyOptions,
             }),
         });
+        log(`[BOT] ✅ Dispatcher completed for session: ${parsed.sessionId}`);
         log(`xy: dispatch complete (session=${parsed.sessionId})`);
     }
     catch (err) {
         error("Failed to handle XY message:", err);
         runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
+        log(`[BOT] ❌ Error occurred, attempting cleanup...`);
         // Try to unregister session on error (if route was established)
         try {
             const core = getXYRuntime();
             const params = message.params;
             const sessionId = params?.sessionId;
             if (sessionId) {
+                log(`[BOT] 🧹 Cleaning up session after error: ${sessionId}`);
                 const route = core.channel.routing.resolveAgentRoute({
                     cfg,
-                    channel: "xy",
+                    channel: "xiaoyi-channel",
                     accountId,
                     peer: {
                         kind: "direct",
                         id: sessionId, // ✅ Use sessionId for cleanup consistency
                     },
                 });
+                log(`[BOT]   - Unregistering session: ${route.sessionKey}`);
                 unregisterSession(route.sessionKey);
+                log(`[BOT] ✅ Session unregistered after error`);
             }
         }
-        catch {
+        catch (cleanupErr) {
+            log(`[BOT] ⚠️  Cleanup failed:`, cleanupErr);
             // Ignore cleanup errors
         }
         throw err;

package/dist/src/channel.js

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

package/dist/src/formatter.js

@@ -51,8 +51,21 @@ export async function sendA2AResponse(params) {
         taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
+    // 📋 Log complete response body
+    log(`[A2A_RESPONSE] 📤 Sending A2A artifact-update response:`);
+    log(`[A2A_RESPONSE]   - sessionId: ${sessionId}`);
+    log(`[A2A_RESPONSE]   - taskId: ${taskId}`);
+    log(`[A2A_RESPONSE]   - messageId: ${messageId}`);
+    log(`[A2A_RESPONSE]   - append: ${append}`);
+    log(`[A2A_RESPONSE]   - final: ${final}`);
+    log(`[A2A_RESPONSE]   - text length: ${text?.length ?? 0}`);
+    log(`[A2A_RESPONSE]   - files count: ${files?.length ?? 0}`);
+    log(`[A2A_RESPONSE] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_RESPONSE] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`Sent A2A response: sessionId=${sessionId}, taskId=${taskId}, final=${final}`);
+    log(`[A2A_RESPONSE] ✅ Message sent successfully`);
 }
 /**
  * Send an A2A task status update.
@@ -96,8 +109,19 @@ export async function sendStatusUpdate(params) {
         taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
+    // 📋 Log complete response body
+    log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
+    log(`[A2A_STATUS]   - sessionId: ${sessionId}`);
+    log(`[A2A_STATUS]   - taskId: ${taskId}`);
+    log(`[A2A_STATUS]   - messageId: ${messageId}`);
+    log(`[A2A_STATUS]   - state: ${state}`);
+    log(`[A2A_STATUS]   - text: "${text}"`);
+    log(`[A2A_STATUS] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_STATUS] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`Sent status update: sessionId=${sessionId}, state=${state}, text="${text}"`);
+    log(`[A2A_STATUS] ✅ Status update sent successfully`);
 }
 /**
  * Send a command as an artifact update (final=false).
@@ -139,8 +163,18 @@ export async function sendCommand(params) {
         taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
+    // 📋 Log complete response body
+    log(`[A2A_COMMAND] 📤 Sending A2A command:`);
+    log(`[A2A_COMMAND]   - sessionId: ${sessionId}`);
+    log(`[A2A_COMMAND]   - taskId: ${taskId}`);
+    log(`[A2A_COMMAND]   - messageId: ${messageId}`);
+    log(`[A2A_COMMAND]   - command: ${command.header.namespace}::${command.header.name}`);
+    log(`[A2A_COMMAND] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_COMMAND] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
     await wsManager.sendMessage(sessionId, outboundMessage);
-    log(`Sent command: sessionId=${sessionId}, command=${command.header.name}`);
+    log(`[A2A_COMMAND] ✅ Command sent successfully`);
 }
 /**
  * Send a clearContext response.

package/dist/src/monitor.js

@@ -44,25 +44,9 @@ export async function monitorXYProvider(opts = {}) {
     // Create session queue for ordered message processing
     const enqueue = createSessionQueue();
     return new Promise((resolve, reject) => {
-        const cleanup = () => {
-            log("XY gateway: cleaning up...");
-            wsManager.disconnect();
-            loggedServers.clear();
-        };
-        const handleAbort = () => {
-            log("XY gateway: abort signal received, stopping");
-            cleanup();
-            log("XY gateway stopped");
-            resolve();
-        };
-        if (opts.abortSignal?.aborted) {
-            cleanup();
-            resolve();
-            return;
-        }
-        opts.abortSignal?.addEventListener("abort", handleAbort, { once: true });
-        // Setup event handlers
+        // Event handlers (defined early so they can be referenced in cleanup)
         const messageHandler = (message, sessionId, serverId) => {
+            log(`[MONITOR-HANDLER] ####### messageHandler triggered: serverId=${serverId}, sessionId=${sessionId}, messageId=${message.id} #######`);
             const task = async () => {
                 try {
                     await handleXYMessage({
@@ -95,7 +79,30 @@ export async function monitorXYProvider(opts = {}) {
         const errorHandler = (err, serverId) => {
             error(`XY gateway: ${serverId} error: ${String(err)}`);
         };
-        // Register event handlers
+        const cleanup = () => {
+            log("XY gateway: cleaning up...");
+            // Remove event handlers to prevent duplicate calls on gateway restart
+            wsManager.off("message", messageHandler);
+            wsManager.off("connected", connectedHandler);
+            wsManager.off("disconnected", disconnectedHandler);
+            wsManager.off("error", errorHandler);
+            // Don't disconnect the shared wsManager as it may be used elsewhere
+            // wsManager.disconnect();
+            loggedServers.clear();
+        };
+        const handleAbort = () => {
+            log("XY gateway: abort signal received, stopping");
+            cleanup();
+            log("XY gateway stopped");
+            resolve();
+        };
+        if (opts.abortSignal?.aborted) {
+            cleanup();
+            resolve();
+            return;
+        }
+        opts.abortSignal?.addEventListener("abort", handleAbort, { once: true });
+        // Register event handlers (handlers are defined above in cleanup scope)
         wsManager.on("message", messageHandler);
         wsManager.on("connected", connectedHandler);
         wsManager.on("disconnected", disconnectedHandler);

package/dist/src/onboarding.js

@@ -1,10 +1,10 @@
-const channel = "xy";
+const channel = "xiaoyi-channel";
 /**
  * Check if XY channel is properly configured with required fields
  */
 function isXYConfigured(cfg) {
     try {
-        const xyConfig = cfg.channels?.xy;
+        const xyConfig = cfg.channels?.["xiaoyi-channel"];
         if (!xyConfig) {
             return false;
         }
@@ -26,7 +26,7 @@ function isXYConfigured(cfg) {
  */
 async function getStatus({ cfg }) {
     const configured = isXYConfigured(cfg);
-    const xyConfig = cfg.channels?.xy;
+    const xyConfig = cfg.channels?.["xiaoyi-channel"];
     const statusLines = [];
     if (configured) {
         const wsUrl1 = xyConfig?.wsUrl1 || "ws://localhost:8765/ws/link";
@@ -49,7 +49,7 @@ async function getStatus({ cfg }) {
  */
 async function configure({ cfg, prompter, }) {
     // Note current configuration status
-    const currentConfig = cfg.channels?.xy;
+    const currentConfig = cfg.channels?.["xiaoyi-channel"];
     const isUpdate = Boolean(currentConfig);
     await prompter.note([
         "XY Channel - 小艺 A2A 协议配置",
@@ -117,7 +117,7 @@ async function configure({ cfg, prompter, }) {
         ...cfg,
         channels: {
             ...cfg.channels,
-            xy: {
+            "xiaoyi-channel": {
                 enabled: true,
                 wsUrl1: wsUrl1.trim(),
                 wsUrl2: wsUrl2.trim(),
@@ -164,8 +164,8 @@ export const xyOnboardingAdapter = {
         ...cfg,
         channels: {
             ...cfg.channels,
-            xy: {
-                ...(cfg.channels?.xy || {}),
+            "xiaoyi-channel": {
+                ...(cfg.channels?.["xiaoyi-channel"] || {}),
                 enabled: false,
             },
         },

package/dist/src/outbound.js

@@ -1,6 +1,7 @@
 import { resolveXYConfig } from "./config.js";
 import { XYFileUploadService } from "./file-upload.js";
 import { XYPushService } from "./push.js";
+import { getLatestSessionContext } from "./tools/session-manager.js";
 // Special marker for default push delivery when no target is specified
 const DEFAULT_PUSH_MARKER = "default";
 /**
@@ -14,6 +15,9 @@ export const xyOutbound = {
      * Resolve delivery target for XY channel.
      * When no target is specified (e.g., in cron jobs with announce mode),
      * returns a default marker that will be handled by sendText.
+     *
+     * For message tool calls, if only sessionId is provided, it will look up
+     * the active session context to construct the full "sessionId::taskId" format.
      */
     resolveTarget: ({ cfg, to, accountId, mode }) => {
         // If no target provided, use default marker for push delivery
@@ -24,11 +28,30 @@ export const xyOutbound = {
                 to: DEFAULT_PUSH_MARKER,
             };
         }
-        // Otherwise, use the provided target
-        console.log(`[xyOutbound.resolveTarget] Using provided target:`, to);
+        const trimmedTo = to.trim();
+        // If the target doesn't contain "::", try to enhance it with taskId from session context
+        if (!trimmedTo.includes("::")) {
+            console.log(`[xyOutbound.resolveTarget] Target "${trimmedTo}" missing taskId, looking up session context`);
+            // Try to get the latest session context
+            const sessionContext = getLatestSessionContext();
+            if (sessionContext && sessionContext.sessionId === trimmedTo) {
+                const enhancedTarget = `${trimmedTo}::${sessionContext.taskId}`;
+                console.log(`[xyOutbound.resolveTarget] Enhanced target: ${enhancedTarget}`);
+                return {
+                    ok: true,
+                    to: enhancedTarget,
+                };
+            }
+            else {
+                console.log(`[xyOutbound.resolveTarget] Could not find matching session context for "${trimmedTo}"`);
+                // Still return the original target, but it may fail in sendMedia
+            }
+        }
+        // Otherwise, use the provided target (either already in correct format or for sendText)
+        console.log(`[xyOutbound.resolveTarget] Using provided target:`, trimmedTo);
         return {
             ok: true,
-            to: to.trim(),
+            to: trimmedTo,
         };
     },
     sendText: async ({ cfg, to, text, accountId }) => {
@@ -58,7 +81,7 @@ export const xyOutbound = {
         console.log(`[xyOutbound.sendText] Completed successfully`);
         // Return message info
         return {
-            channel: "xy",
+            channel: "xiaoyi-channel",
             messageId: Date.now().toString(),
             chatId: actualTo,
         };
@@ -135,7 +158,7 @@ export const xyOutbound = {
         console.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
         // Return message info
         return {
-            channel: "xy",
+            channel: "xiaoyi-channel",
             messageId: fileId,
             chatId: to,
         };

package/dist/src/reply-dispatcher.js

@@ -11,6 +11,11 @@ export function createXYReplyDispatcher(params) {
     const { cfg, runtime, sessionId, taskId, messageId, accountId } = params;
     const log = runtime?.log ?? console.log;
     const error = runtime?.error ?? console.error;
+    log(`[DISPATCHER-CREATE] ******* Creating dispatcher for session=${sessionId}, taskId=${taskId}, messageId=${messageId} *******`);
+    log(`[DISPATCHER-CREATE] Stack trace:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
+    log(`[DISPATCHER-CREATE] ======== Creating reply dispatcher ========`);
+    log(`[DISPATCHER-CREATE] sessionId: ${sessionId}, taskId: ${taskId}, messageId: ${messageId}`);
+    log(`[DISPATCHER-CREATE] Stack trace:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
     // Get runtime (already validated in monitor.ts, but get reference for use)
     const core = getXYRuntime();
     // Resolve configuration
@@ -23,6 +28,8 @@ export function createXYReplyDispatcher(params) {
     let hasSentResponse = false;
     // Track if we've sent the final empty message
     let finalSent = false;
+    // Accumulate all text from deliver calls
+    let accumulatedText = "";
     /**
      * Start the status update interval
      * Call this immediately after creating the dispatcher
@@ -76,19 +83,10 @@ export function createXYReplyDispatcher(params) {
                     log(`[DELIVER SKIP] Empty text, skipping`);
                     return;
                 }
-                // Send text with append=true (backend will accumulate)
-                log(`[DELIVER SEND] Sending text, length=${text.length}, kind=${info?.kind || "undefined"}`);
-                await sendA2AResponse({
-                    config,
-                    sessionId,
-                    taskId,
-                    messageId,
-                    text: text,
-                    append: true,
-                    final: false,
-                });
+                // Accumulate text instead of sending immediately
+                accumulatedText += text;
                 hasSentResponse = true;
-                log(`[DELIVER DONE] Sent text, hasSentResponse=${hasSentResponse}`);
+                log(`[DELIVER ACCUMULATE] Accumulated text, current length=${accumulatedText.length}`);
             }
             catch (deliverError) {
                 error(`Failed to deliver message:`, deliverError);
@@ -117,24 +115,24 @@ export function createXYReplyDispatcher(params) {
         },
         onIdle: async () => {
             log(`[ON_IDLE] Reply idle for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
-            // Send final empty message to signal end if we haven't sent it yet
+            // Send accumulated text with append=false and final=true
             if (hasSentResponse && !finalSent) {
-                log(`[ON_IDLE] Sending final empty message`);
+                log(`[ON_IDLE] Sending accumulated text, length=${accumulatedText.length}`);
                 try {
                     await sendA2AResponse({
                         config,
                         sessionId,
                         taskId,
                         messageId,
-                        text: "",
-                        append: true,
+                        text: accumulatedText,
+                        append: false,
                         final: true,
                     });
                     finalSent = true;
-                    log(`[ON_IDLE] Sent final empty message`);
+                    log(`[ON_IDLE] Sent accumulated text`);
                 }
                 catch (err) {
-                    error(`[ON_IDLE] Failed to send final message:`, err);
+                    error(`[ON_IDLE] Failed to send accumulated text:`, err);
                 }
             }
             else {

package/dist/src/tools/location-tool.js

@@ -16,16 +16,31 @@ export const locationTool = {
         required: [],
     },
     async execute(toolCallId, params) {
-        logger.debug("Executing location tool, toolCallId:", toolCallId);
+        logger.log(`[LOCATION_TOOL] 🚀 Starting execution`);
+        logger.log(`[LOCATION_TOOL]   - toolCallId: ${toolCallId}`);
+        logger.log(`[LOCATION_TOOL]   - params:`, JSON.stringify(params));
+        logger.log(`[LOCATION_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // Get session context
+        logger.log(`[LOCATION_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getLatestSessionContext();
         if (!sessionContext) {
+            logger.error(`[LOCATION_TOOL] ❌ FAILED: No active session found!`);
+            logger.error(`[LOCATION_TOOL]   - toolCallId: ${toolCallId}`);
+            logger.error(`[LOCATION_TOOL]   - This suggests the session was not registered or already cleaned up`);
             throw new Error("No active XY session found. Location tool can only be used during an active conversation.");
         }
+        logger.log(`[LOCATION_TOOL] ✅ Session context found`);
+        logger.log(`[LOCATION_TOOL]   - sessionId: ${sessionContext.sessionId}`);
+        logger.log(`[LOCATION_TOOL]   - taskId: ${sessionContext.taskId}`);
+        logger.log(`[LOCATION_TOOL]   - messageId: ${sessionContext.messageId}`);
+        logger.log(`[LOCATION_TOOL]   - agentId: ${sessionContext.agentId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
+        logger.log(`[LOCATION_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
+        logger.log(`[LOCATION_TOOL] ✅ WebSocket manager obtained`);
         // Build GetCurrentLocation command
+        logger.log(`[LOCATION_TOOL] 📦 Building GetCurrentLocation command...`);
         const command = {
             header: {
                 namespace: "Common",
@@ -45,20 +60,27 @@ export const locationTool = {
             },
         };
         // Send command and wait for response (5 second timeout)
+        logger.log(`[LOCATION_TOOL] ⏳ Setting up promise to wait for location response...`);
+        logger.log(`[LOCATION_TOOL]   - Timeout: 5 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
+                logger.error(`[LOCATION_TOOL] ⏰ Timeout: No response received within 5 seconds`);
                 wsManager.off("data-event", handler);
                 reject(new Error("获取位置超时（5秒）"));
             }, 5000);
             // Listen for data events from WebSocket
             const handler = (event) => {
-                logger.debug("Received data event:", event);
+                logger.log(`[LOCATION_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "GetCurrentLocation") {
+                    logger.log(`[LOCATION_TOOL] 🎯 GetCurrentLocation event received`);
+                    logger.log(`[LOCATION_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
                         const { latitude, longitude } = event.outputs;
-                        logger.log(`Location retrieved: lat=${latitude}, lon=${longitude}`);
+                        logger.log(`[LOCATION_TOOL] ✅ Location retrieved successfully`);
+                        logger.log(`[LOCATION_TOOL]   - latitude: ${latitude}`);
+                        logger.log(`[LOCATION_TOOL]   - longitude: ${longitude}`);
                         resolve({
                             content: [
                                 {
@@ -73,21 +95,28 @@ export const locationTool = {
                         });
                     }
                     else {
+                        logger.error(`[LOCATION_TOOL] ❌ Location retrieval failed`);
+                        logger.error(`[LOCATION_TOOL]   - status: ${event.status}`);
                         reject(new Error(`获取位置失败: ${event.status}`));
                     }
                 }
             };
             // Register event handler
             // Note: The WebSocket manager needs to emit 'data-event' when receiving data events
+            logger.log(`[LOCATION_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
+            logger.log(`[LOCATION_TOOL] 📤 Sending GetCurrentLocation command...`);
             sendCommand({
                 config,
                 sessionId,
                 taskId,
                 messageId,
                 command,
+            }).then(() => {
+                logger.log(`[LOCATION_TOOL] ✅ Command sent successfully, waiting for response...`);
             }).catch((error) => {
+                logger.error(`[LOCATION_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);

package/dist/src/tools/note-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XY note tool - creates a note on user's device.
+ * Requires title and content parameters.
+ */
+export declare const noteTool: any;

package/dist/src/tools/note-tool.js

@@ -0,0 +1,130 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getLatestSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY note tool - creates a note on user's device.
+ * Requires title and content parameters.
+ */
+export const noteTool = {
+    name: "create_note",
+    label: "Create Note",
+    description: "在用户设备上创建备忘录。需要提供备忘录标题和内容。",
+    parameters: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "备忘录标题",
+            },
+            content: {
+                type: "string",
+                description: "备忘录内容",
+            },
+        },
+        required: ["title", "content"],
+    },
+    async execute(toolCallId, params) {
+        logger.debug("Executing note tool, toolCallId:", toolCallId);
+        // Validate parameters
+        if (!params.title || !params.content) {
+            throw new Error("Missing required parameters: title and content are required");
+        }
+        // Get session context
+        const sessionContext = getLatestSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Note tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        const wsManager = getXYWebSocketManager(config);
+        // Build CreateNote command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "CreateNote",
+                    bundleName: "com.huawei.hmos.notepad",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    timeOut: 5,
+                    intentParam: {
+                        title: params.title,
+                        content: params.content,
+                    },
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        // Send command and wait for response (5 second timeout)
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("创建备忘录超时（5秒）"));
+            }, 5000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                logger.debug("Received data event:", event);
+                if (event.intentName === "CreateNote") {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        const { result, code } = event.outputs;
+                        logger.log(`Note created: title=${result?.title}, id=${result?.entityId}`);
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        success: true,
+                                        note: {
+                                            entityId: result?.entityId,
+                                            title: result?.title,
+                                            content: result?.content,
+                                            entityName: result?.entityName,
+                                            modifiedDate: result?.modifiedDate,
+                                        },
+                                        code,
+                                    }),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`创建备忘录失败: ${event.status}`));
+                    }
+                }
+            };
+            // Register event handler
+            wsManager.on("data-event", handler);
+            // Send the command
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            }).catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

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

@@ -0,0 +1,5 @@
+/**
+ * XY search note tool - searches notes on user's device.
+ * Returns matching notes based on query string.
+ */
+export declare const searchNoteTool: any;

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

@@ -0,0 +1,130 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getLatestSessionContext } from "./session-manager.js";
+import { logger } from "../utils/logger.js";
+/**
+ * XY search note tool - searches notes on user's device.
+ * Returns matching notes based on query string.
+ */
+export const searchNoteTool = {
+    name: "search_notes",
+    label: "Search Notes",
+    description: "搜索用户设备上的备忘录内容。根据关键词在备忘录的标题、内容和附件名称中进行检索。",
+    parameters: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "搜索关键词，用于在备忘录中检索相关内容",
+            },
+        },
+        required: ["query"],
+    },
+    async execute(toolCallId, params) {
+        logger.debug("Executing search note tool, toolCallId:", toolCallId);
+        // Validate parameters
+        if (!params.query) {
+            throw new Error("Missing required parameter: query is required");
+        }
+        // Get session context
+        const sessionContext = getLatestSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Search note tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        const wsManager = getXYWebSocketManager(config);
+        // Build SearchNote command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SearchNote",
+                    bundleName: "com.huawei.hmos.notepad",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    timeOut: 5,
+                    intentParam: {
+                        query: params.query,
+                    },
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        // Send command and wait for response (5 second timeout)
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("搜索备忘录超时（5秒）"));
+            }, 5000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                logger.debug("Received data event:", event);
+                if (event.intentName === "SearchNote") {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        const { result, code } = event.outputs;
+                        const items = result?.items || [];
+                        logger.log(`Notes found: ${items.length} results for query "${params.query}"`);
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        success: true,
+                                        query: params.query,
+                                        totalResults: items.length,
+                                        notes: items.map((item) => ({
+                                            entityId: item.entityId,
+                                            entityName: item.entityName,
+                                            title: item.title?.replace(/<\/?em>/g, ''), // Remove <em> tags
+                                            content: item.content,
+                                            createdDate: item.createdDate,
+                                            modifiedDate: item.modifiedDate,
+                                        })),
+                                        indexName: result?.indexName,
+                                        code,
+                                    }),
+                                },
+                            ],
+                        });
+                    }
+                    else {
+                        reject(new Error(`搜索备忘录失败: ${event.status}`));
+                    }
+                }
+            };
+            // Register event handler
+            wsManager.on("data-event", handler);
+            // Send the command
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            }).catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/session-manager.js

@@ -1,3 +1,4 @@
+import { logger } from "../utils/logger.js";
 // Map of sessionKey -> SessionContext
 const activeSessions = new Map();
 /**
@@ -5,21 +6,42 @@ const activeSessions = new Map();
  * Should be called when starting to process a message.
  */
 export function registerSession(sessionKey, context) {
+    logger.log(`[SESSION_MANAGER] 📝 Registering session: ${sessionKey}`);
+    logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
+    logger.log(`[SESSION_MANAGER]   - taskId: ${context.taskId}`);
+    logger.log(`[SESSION_MANAGER]   - messageId: ${context.messageId}`);
+    logger.log(`[SESSION_MANAGER]   - agentId: ${context.agentId}`);
+    logger.log(`[SESSION_MANAGER]   - Active sessions before: ${activeSessions.size}`);
     activeSessions.set(sessionKey, context);
+    logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
+    logger.log(`[SESSION_MANAGER]   - All session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
 }
 /**
  * Unregister a session context.
  * Should be called when message processing is complete.
  */
 export function unregisterSession(sessionKey) {
-    activeSessions.delete(sessionKey);
+    logger.log(`[SESSION_MANAGER] 🗑️  Unregistering session: ${sessionKey}`);
+    logger.log(`[SESSION_MANAGER]   - Active sessions before: ${activeSessions.size}`);
+    logger.log(`[SESSION_MANAGER]   - Session existed: ${activeSessions.has(sessionKey)}`);
+    const existed = activeSessions.delete(sessionKey);
+    logger.log(`[SESSION_MANAGER]   - Deleted: ${existed}`);
+    logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
+    logger.log(`[SESSION_MANAGER]   - Remaining session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
 }
 /**
  * Get session context by sessionKey.
  * Returns null if session not found.
  */
 export function getSessionContext(sessionKey) {
-    return activeSessions.get(sessionKey) ?? null;
+    logger.log(`[SESSION_MANAGER] 🔍 Getting session by key: ${sessionKey}`);
+    logger.log(`[SESSION_MANAGER]   - Active sessions: ${activeSessions.size}`);
+    const context = activeSessions.get(sessionKey) ?? null;
+    logger.log(`[SESSION_MANAGER]   - Found: ${context !== null}`);
+    if (context) {
+        logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
+    }
+    return context;
 }
 /**
  * Get the most recent session context.
@@ -27,9 +49,19 @@ export function getSessionContext(sessionKey) {
  * Returns null if no sessions are active.
  */
 export function getLatestSessionContext() {
-    if (activeSessions.size === 0)
+    logger.log(`[SESSION_MANAGER] 🔍 Getting latest session context`);
+    logger.log(`[SESSION_MANAGER]   - Active sessions count: ${activeSessions.size}`);
+    logger.log(`[SESSION_MANAGER]   - Active session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
+    if (activeSessions.size === 0) {
+        logger.error(`[SESSION_MANAGER]   - ❌ No active sessions found!`);
         return null;
+    }
     // Return the last added session
     const sessions = Array.from(activeSessions.values());
-    return sessions[sessions.length - 1];
+    const latestSession = sessions[sessions.length - 1];
+    logger.log(`[SESSION_MANAGER]   - ✅ Found latest session:`);
+    logger.log(`[SESSION_MANAGER]     - sessionId: ${latestSession.sessionId}`);
+    logger.log(`[SESSION_MANAGER]     - taskId: ${latestSession.taskId}`);
+    logger.log(`[SESSION_MANAGER]     - messageId: ${latestSession.messageId}`);
+    return latestSession;
 }

package/dist/src/websocket.js

@@ -274,6 +274,7 @@ export class XYWebSocketManager extends EventEmitter {
      * Handle incoming message from server.
      */
     handleMessage(serverId, data) {
+        console.log(`[WEBSOCKET-HANDLE] >>>>>>> serverId: ${serverId}, receiving message... <<<<<<<`);
         try {
             const messageStr = data.toString();
             const parsed = JSON.parse(messageStr);
@@ -324,6 +325,7 @@ export class XYWebSocketManager extends EventEmitter {
                     return; // Don't emit message event
                 }
                 // Emit message event for non-data-only messages
+                console.log(`[XY-${serverId}] *** EMITTING message event (Direct A2A path) ***`);
                 this.emit("message", a2aRequest, sessionId, serverId);
                 return;
             }
@@ -377,6 +379,7 @@ export class XYWebSocketManager extends EventEmitter {
             }
             console.log(`[XY-${serverId}] Session ID: ${sessionId}`);
             // Emit message event
+            console.log(`[XY-${serverId}] *** EMITTING message event (Wrapped path) ***`);
             this.emit("message", a2aRequest, sessionId, serverId);
         }
         catch (error) {

package/package.json

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