@ynhcj/xiaoyi-channel 0.0.51-beta → 0.0.52-beta

package/dist/src/bot.js

@@ -336,19 +336,3 @@ function buildXYMediaPayload(mediaList) {
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }
-/**
- * Infer OpenClaw media type from file type string.
- */
-function inferMediaType(fileType) {
-    const lower = fileType.toLowerCase();
-    if (lower.includes("image") || /\.(jpg|jpeg|png|gif|bmp|webp)$/i.test(lower)) {
-        return "image";
-    }
-    if (lower.includes("video") || /\.(mp4|avi|mov|mkv|webm)$/i.test(lower)) {
-        return "video";
-    }
-    if (lower.includes("audio") || /\.(mp3|wav|ogg|m4a)$/i.test(lower)) {
-        return "audio";
-    }
-    return "file";
-}

package/dist/src/client.js

@@ -85,8 +85,6 @@ export function diagnoseAllManagers() {
     let orphanCount = 0;
     wsManagerCache.forEach((manager, key) => {
         const diag = manager.getConnectionDiagnostics();
-        console.log(`📌 Manager: ${key}`);
-        console.log(`   Shutting down: ${diag.isShuttingDown}`);
         console.log(`   Total event listeners on manager: ${diag.totalEventListeners}`);
         // Connection
         console.log(`   🔌 Connection:`);

package/dist/src/formatter.js

@@ -52,18 +52,11 @@ export async function sendA2AResponse(params) {
         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] 📤 Sending A2A artifact-update response: taskId: ${taskId}`);
     log(`[A2A_RESPONSE]   - append: ${append}`);
     log(`[A2A_RESPONSE]   - final: ${final}`);
-    log(`[A2A_RESPONSE]   - text length: ${text?.length ?? 0}`);
+    log(`[A2A_RESPONSE]   - text: ${text}`);
     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(`[A2A_RESPONSE] ✅ Message sent successfully`);
 }
@@ -152,15 +145,10 @@ export async function sendStatusUpdate(params) {
     };
     // 📋 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(`[A2A_STATUS] ✅ Status update sent successfully`);
 }
@@ -208,15 +196,7 @@ export async function sendCommand(params) {
         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));
+    log(`[A2A_COMMAND] 📤 Sending A2A command: taskId: ${taskId}`);
     await wsManager.sendMessage(sessionId, outboundMessage);
     log(`[A2A_COMMAND] ✅ Command sent successfully`);
 }

package/dist/src/heartbeat.js

@@ -80,7 +80,6 @@ export class HeartbeatManager {
                 this.error(`Heartbeat timeout for ${this.serverName}`);
                 this.onTimeout();
             }, this.config.timeout);
-            this.log(`[DEBUG] Heartbeat sent for ${this.serverName}`);
         }
         catch (error) {
             this.error(`Failed to send heartbeat for ${this.serverName}:`, error);

package/dist/src/reply-dispatcher.js

@@ -3,6 +3,37 @@ import { getXYRuntime } from "./runtime.js";
 import { sendA2AResponse, sendStatusUpdate, sendReasoningTextUpdate } from "./formatter.js";
 import { resolveXYConfig } from "./config.js";
 import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
+import fs from "fs/promises";
+import path from "path";
+/**
+ * 清理 /tmp/xy_channel 目录中的所有文件
+ */
+async function cleanupTempDir(tempDir = "/tmp/xy_channel") {
+    try {
+        const stats = await fs.stat(tempDir).catch(() => null);
+        if (!stats?.isDirectory()) {
+            return; // 目录不存在，直接返回
+        }
+        const files = await fs.readdir(tempDir);
+        let cleanedCount = 0;
+        for (const file of files) {
+            const filePath = path.join(tempDir, file);
+            try {
+                await fs.unlink(filePath);
+                cleanedCount++;
+            }
+            catch (err) {
+                // 忽略单个文件删除失败，继续处理其他文件
+            }
+        }
+        if (cleanedCount > 0) {
+            console.log(`[CLEANUP] 🧹 Cleaned ${cleanedCount} files from ${tempDir}`);
+        }
+    }
+    catch (err) {
+        console.error(`[CLEANUP] ❌ Failed to cleanup temp dir:`, err);
+    }
+}
 /**
  * Create a reply dispatcher for XY channel messages.
  * Follows feishu pattern with status updates and streaming support.
@@ -206,6 +237,7 @@ export function createXYReplyDispatcher(params) {
                 }
             }
             stopStatusInterval();
+            void cleanupTempDir();
         },
         onCleanup: () => {
             const currentTaskId = getActiveTaskId();

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

@@ -1,7 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentSessionContext } from "./session-manager.js";
-import { logger } from "../utils/logger.js";
 /**
  * XY calendar event tool - creates a calendar event on user's device.
  * Requires title, dtStart (start time), and dtEnd (end time) parameters.
@@ -12,6 +11,8 @@ export const calendarTool = {
     label: "Create Calendar Event",
     description: `在用户设备上创建日程。需要提供日程标题、开始时间和结束时间。时间格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）。注意：该工具执行时间较长（最多60秒），请勿重复调用，超时或失败时最多重试一次。
   注意事项：使用该工具之前需获取当前真实时间
+
+  回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
   `,
     parameters: {
         type: "object",
@@ -32,47 +33,25 @@ export const calendarTool = {
         required: ["title", "dtStart", "dtEnd"],
     },
     async execute(toolCallId, params) {
-        logger.log(`[CALENDAR_TOOL] 🚀 Starting execution`);
-        logger.log(`[CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[CALENDAR_TOOL]   - params:`, JSON.stringify(params));
-        logger.log(`[CALENDAR_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // Validate parameters
         if (!params.title || !params.dtStart || !params.dtEnd) {
-            logger.error(`[CALENDAR_TOOL] ❌ Missing required parameters`);
             throw new Error("Missing required parameters: title, dtStart, and dtEnd are required");
         }
         // Convert time strings to millisecond timestamps
-        logger.log(`[CALENDAR_TOOL] 🕒 Converting time strings to timestamps...`);
-        logger.log(`[CALENDAR_TOOL]   - dtStart input: ${params.dtStart}`);
-        logger.log(`[CALENDAR_TOOL]   - dtEnd input: ${params.dtEnd}`);
         const dtStartMs = new Date(params.dtStart).getTime();
         const dtEndMs = new Date(params.dtEnd).getTime();
         if (isNaN(dtStartMs) || isNaN(dtEndMs)) {
-            logger.error(`[CALENDAR_TOOL] ❌ Invalid time format`);
             throw new Error("Invalid time format. Required format: yyyy-mm-dd hh:mm:ss (e.g., 2024-01-15 14:30:00)");
         }
-        logger.log(`[CALENDAR_TOOL] ✅ Time conversion successful`);
-        logger.log(`[CALENDAR_TOOL]   - dtStart timestamp: ${dtStartMs}`);
-        logger.log(`[CALENDAR_TOOL]   - dtEnd timestamp: ${dtEndMs}`);
         // Get session context
-        logger.log(`[CALENDAR_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[CALENDAR_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[CALENDAR_TOOL]   - toolCallId: ${toolCallId}`);
             throw new Error("No active XY session found. Calendar tool can only be used during an active conversation.");
         }
-        logger.log(`[CALENDAR_TOOL] ✅ Session context found`);
-        logger.log(`[CALENDAR_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[CALENDAR_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[CALENDAR_TOOL]   - messageId: ${sessionContext.messageId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[CALENDAR_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[CALENDAR_TOOL] ✅ WebSocket manager obtained`);
         // Build CreateCalendarEvent command
-        logger.log(`[CALENDAR_TOOL] 📦 Building CreateCalendarEvent command...`);
         const command = {
             header: {
                 namespace: "Common",
@@ -108,25 +87,17 @@ export const calendarTool = {
             },
         };
         // Send command and wait for response (60 second timeout)
-        logger.log(`[CALENDAR_TOOL] ⏳ Setting up promise to wait for calendar event response...`);
-        logger.log(`[CALENDAR_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[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(`[CALENDAR_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "CreateCalendarEvent") {
-                    logger.log(`[CALENDAR_TOOL] 🎯 CreateCalendarEvent event received`);
-                    logger.log(`[CALENDAR_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`[CALENDAR_TOOL] ✅ Calendar event created successfully`);
-                        logger.log(`[CALENDAR_TOOL]   - outputs:`, JSON.stringify(event.outputs));
                         resolve({
                             content: [
                                 {
@@ -137,17 +108,13 @@ export const calendarTool = {
                         });
                     }
                     else {
-                        logger.error(`[CALENDAR_TOOL] ❌ Calendar event creation failed`);
-                        logger.error(`[CALENDAR_TOOL]   - status: ${event.status}`);
                         reject(new Error(`创建日程失败: ${event.status}`));
                     }
                 }
             };
             // Register event handler
-            logger.log(`[CALENDAR_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[CALENDAR_TOOL] 📤 Sending CreateCalendarEvent command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -156,10 +123,8 @@ export const calendarTool = {
                 command,
             })
                 .then(() => {
-                logger.log(`[CALENDAR_TOOL] ✅ Command sent successfully, waiting for response...`);
             })
                 .catch((error) => {
-                logger.error(`[CALENDAR_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);

package/dist/src/tools/call-phone-tool.js

@@ -1,7 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
 import { getCurrentSessionContext } from "./session-manager.js";
-import { logger } from "../utils/logger.js";
 /**
  * XY call phone tool - makes a phone call on user's device.
  * Requires phoneNumber parameter and optional slotId (0 for primary SIM, 1 for secondary SIM).
@@ -9,7 +8,7 @@ import { logger } from "../utils/logger.js";
 export const callPhoneTool = {
     name: "call_phone",
     label: "Call Phone",
-    description: "拨打电话。需要提供要拨打的电话号码。slotId参数可选，默认为0（主卡），如果用户明确要求使用副卡则设置为1。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    description: "拨打电话。需要提供要拨打的电话号码。slotId参数可选，默认为0（主卡），如果用户明确要求使用副卡则设置为1。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。",
     parameters: {
         type: "object",
         properties: {
@@ -26,43 +25,25 @@ export const callPhoneTool = {
         required: ["phoneNumber"],
     },
     async execute(toolCallId, params) {
-        logger.log(`[CALL_PHONE_TOOL] 🚀 Starting execution`);
-        logger.log(`[CALL_PHONE_TOOL]   - toolCallId: ${toolCallId}`);
-        logger.log(`[CALL_PHONE_TOOL]   - params:`, JSON.stringify(params));
-        logger.log(`[CALL_PHONE_TOOL]   - timestamp: ${new Date().toISOString()}`);
         // Validate phoneNumber parameter
         if (!params.phoneNumber || typeof params.phoneNumber !== "string" || params.phoneNumber.trim() === "") {
-            logger.error(`[CALL_PHONE_TOOL] ❌ Missing or invalid phoneNumber parameter`);
             throw new Error("Missing required parameter: phoneNumber must be a non-empty string");
         }
         // Set default slotId if not provided
         const slotId = params.slotId !== undefined && params.slotId !== null ? params.slotId : 0;
         // Validate slotId (must be 0 or 1)
         if (slotId !== 0 && slotId !== 1) {
-            logger.error(`[CALL_PHONE_TOOL] ❌ Invalid slotId: ${slotId}`);
             throw new Error("Invalid slotId: must be 0 (primary SIM) or 1 (secondary SIM)");
         }
-        logger.log(`[CALL_PHONE_TOOL] 📞 Preparing to call phone number: ${params.phoneNumber}`);
-        logger.log(`[CALL_PHONE_TOOL]   - slotId: ${slotId} (${slotId === 0 ? "主卡" : "副卡"})`);
         // Get session context
-        logger.log(`[CALL_PHONE_TOOL] 🔍 Attempting to get session context...`);
         const sessionContext = getCurrentSessionContext();
         if (!sessionContext) {
-            logger.error(`[CALL_PHONE_TOOL] ❌ FAILED: No active session found!`);
-            logger.error(`[CALL_PHONE_TOOL]   - toolCallId: ${toolCallId}`);
             throw new Error("No active XY session found. Call phone tool can only be used during an active conversation.");
         }
-        logger.log(`[CALL_PHONE_TOOL] ✅ Session context found`);
-        logger.log(`[CALL_PHONE_TOOL]   - sessionId: ${sessionContext.sessionId}`);
-        logger.log(`[CALL_PHONE_TOOL]   - taskId: ${sessionContext.taskId}`);
-        logger.log(`[CALL_PHONE_TOOL]   - messageId: ${sessionContext.messageId}`);
         const { config, sessionId, taskId, messageId } = sessionContext;
         // Get WebSocket manager
-        logger.log(`[CALL_PHONE_TOOL] 🔌 Getting WebSocket manager...`);
         const wsManager = getXYWebSocketManager(config);
-        logger.log(`[CALL_PHONE_TOOL] ✅ WebSocket manager obtained`);
         // Build StartCall command
-        logger.log(`[CALL_PHONE_TOOL] 📦 Building StartCall command...`);
         const command = {
             header: {
                 namespace: "Common",
@@ -97,34 +78,22 @@ export const callPhoneTool = {
                 pageControlRelated: false,
             },
         };
-        logger.log(`[CALL_PHONE_TOOL] 📋 Command details:`, JSON.stringify(command, null, 2));
         // Send command and wait for response (60 second timeout)
-        logger.log(`[CALL_PHONE_TOOL] ⏳ Setting up promise to wait for call response...`);
-        logger.log(`[CALL_PHONE_TOOL]   - Timeout: 60 seconds`);
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
-                logger.error(`[CALL_PHONE_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(`[CALL_PHONE_TOOL] 📨 Received data event:`, JSON.stringify(event));
                 if (event.intentName === "StartCall") {
-                    logger.log(`[CALL_PHONE_TOOL] 🎯 StartCall event received`);
-                    logger.log(`[CALL_PHONE_TOOL]   - status: ${event.status}`);
                     clearTimeout(timeout);
                     wsManager.off("data-event", handler);
                     if (event.status === "success" && event.outputs) {
-                        logger.log(`[CALL_PHONE_TOOL] ✅ Call response received`);
-                        logger.log(`[CALL_PHONE_TOOL]   - outputs:`, JSON.stringify(event.outputs));
                         // Check for error code in outputs
                         const code = event.outputs.code !== undefined ? event.outputs.code : null;
                         if (code !== null && code !== 0) {
-                            logger.error(`[CALL_PHONE_TOOL] ❌ Device returned error`);
-                            logger.error(`[CALL_PHONE_TOOL]   - code: ${code}`);
                             const errorMsg = event.outputs.errorMsg || event.outputs.errMsg || "未知错误";
-                            logger.error(`[CALL_PHONE_TOOL]   - errorMsg: ${errorMsg}`);
                             reject(new Error(`拨打电话失败: ${errorMsg} (错误代码: ${code})`));
                             return;
                         }
@@ -136,9 +105,6 @@ export const callPhoneTool = {
                             slotId: slotId,
                             message: "电话拨打成功",
                         };
-                        logger.log(`[CALL_PHONE_TOOL] 🎉 Call initiated successfully`);
-                        logger.log(`[CALL_PHONE_TOOL]   - phoneNumber: ${params.phoneNumber}`);
-                        logger.log(`[CALL_PHONE_TOOL]   - slotId: ${slotId}`);
                         resolve({
                             content: [
                                 {
@@ -149,19 +115,14 @@ export const callPhoneTool = {
                         });
                     }
                     else {
-                        logger.error(`[CALL_PHONE_TOOL] ❌ Call failed`);
-                        logger.error(`[CALL_PHONE_TOOL]   - status: ${event.status}`);
-                        logger.error(`[CALL_PHONE_TOOL]   - outputs:`, JSON.stringify(event.outputs || {}));
                         const errorDetail = event.outputs ? JSON.stringify(event.outputs) : event.status;
                         reject(new Error(`拨打电话失败: ${errorDetail}`));
                     }
                 }
             };
             // Register event handler
-            logger.log(`[CALL_PHONE_TOOL] 📡 Registering data-event handler on WebSocket manager`);
             wsManager.on("data-event", handler);
             // Send the command
-            logger.log(`[CALL_PHONE_TOOL] 📤 Sending StartCall command...`);
             sendCommand({
                 config,
                 sessionId,
@@ -170,10 +131,8 @@ export const callPhoneTool = {
                 command,
             })
                 .then(() => {
-                logger.log(`[CALL_PHONE_TOOL] ✅ Command sent successfully, waiting for response...`);
             })
                 .catch((error) => {
-                logger.error(`[CALL_PHONE_TOOL] ❌ Failed to send command:`, error);
                 clearTimeout(timeout);
                 wsManager.off("data-event", handler);
                 reject(error);