@ynhcj/xiaoyi-channel 0.0.26-beta → 0.0.26-next

package/dist/src/reply-dispatcher.js

@@ -1,8 +1,38 @@
-import { createReplyPrefixContext } from "openclaw/plugin-sdk";
 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.
@@ -32,7 +62,12 @@ export function createXYReplyDispatcher(params) {
     };
     const core = getXYRuntime();
     const config = resolveXYConfig(cfg);
-    const prefixContext = createReplyPrefixContext({ cfg, agentId: accountId });
+    // Simplified prefix context for single-account Xiaoyi channel
+    const prefixContext = {
+        responsePrefix: undefined,
+        responsePrefixContextProvider: undefined,
+        onModelSelected: undefined,
+    };
     let statusUpdateInterval = null;
     let hasSentResponse = false;
     let finalSent = false;
@@ -54,7 +89,7 @@ export function createXYReplyDispatcher(params) {
                 sessionId,
                 taskId: currentTaskId, // 🔑 动态taskId
                 messageId: currentMessageId, // 🔑 动态messageId
-                text: "任务正在处理中，请稍后~",
+                text: "任务正在处理中，请稍候~",
                 state: "working",
             }).catch((err) => {
                 error(`Failed to send status update:`, err);
@@ -206,6 +241,7 @@ export function createXYReplyDispatcher(params) {
                 }
             }
             stopStatusInterval();
+            void cleanupTempDir();
         },
         onCleanup: () => {
             const currentTaskId = getActiveTaskId();
@@ -289,7 +325,6 @@ export function createXYReplyDispatcher(params) {
                 const currentTaskId = getActiveTaskId();
                 const currentMessageId = getActiveMessageId();
                 const text = payload.text ?? "";
-                log(`[PARTIAL REPLY] Partial reply chunk received, taskId: ${currentTaskId}`);
                 try {
                     if (text.length > 0) {
                         await sendReasoningTextUpdate({
@@ -300,7 +335,6 @@ export function createXYReplyDispatcher(params) {
                             text,
                             append: false,
                         });
-                        log(`[PARTIAL REPLY] ✅ Sent partial reply as reasoningText update`);
                     }
                 }
                 catch (err) {

package/dist/src/steer-injector.d.ts

@@ -0,0 +1,16 @@
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+/**
+ * 在 handleXYMessage 入口处调用，缓存 cfg/runtime 供 steer 注入使用。
+ */
+export declare function setCachedContext(cfg: ClawdbotConfig, runtime: RuntimeEnv, accountId: string): void;
+/**
+ * 尝试向当前活跃会话注入 steer 消息。
+ * 两层保险：
+ *   1. getSessionContext(sessionKey) 确认是当前 XY 活跃 session
+ *   2. hasActiveTask(sessionId) 确认任务仍在运行
+ *
+ * @param sessionKey  来自 after_tool_call ctx.sessionKey（per-peer 下精确对应一个 XY session）
+ * @param message     要注入的用户消息文本
+ * @returns           true=已注入，false=跳过
+ */
+export declare function tryInjectSteer(sessionKey: string | undefined, message: string): Promise<boolean>;

package/dist/src/steer-injector.js

@@ -0,0 +1,74 @@
+// Steer message injector for CSPL hook integration
+import { getSessionContext } from "./tools/session-manager.js";
+import { hasActiveTask, getCurrentTaskId } from "./task-manager.js";
+import { handleXYMessage } from "./bot.js";
+import { logger } from "./utils/logger.js";
+import { randomUUID } from "node:crypto";
+let cachedCfg = null;
+let cachedRuntime = null;
+let cachedAccountId = "default";
+/**
+ * 在 handleXYMessage 入口处调用，缓存 cfg/runtime 供 steer 注入使用。
+ */
+export function setCachedContext(cfg, runtime, accountId) {
+    cachedCfg = cfg;
+    cachedRuntime = runtime;
+    cachedAccountId = accountId;
+}
+/**
+ * 尝试向当前活跃会话注入 steer 消息。
+ * 两层保险：
+ *   1. getSessionContext(sessionKey) 确认是当前 XY 活跃 session
+ *   2. hasActiveTask(sessionId) 确认任务仍在运行
+ *
+ * @param sessionKey  来自 after_tool_call ctx.sessionKey（per-peer 下精确对应一个 XY session）
+ * @param message     要注入的用户消息文本
+ * @returns           true=已注入，false=跳过
+ */
+export async function tryInjectSteer(sessionKey, message) {
+    if (!sessionKey) {
+        return false;
+    }
+    const sessionCtx = getSessionContext(sessionKey);
+    if (!sessionCtx) {
+        return false;
+    }
+    const { sessionId } = sessionCtx;
+    const activeTaskId = getCurrentTaskId(sessionId);
+    if (!hasActiveTask(sessionId)) {
+        return false;
+    }
+    if (!cachedCfg || !cachedRuntime) {
+        logger.error("[STEER] No cached cfg/runtime available, cannot inject");
+        return false;
+    }
+    // 3. 构造合成 A2A 消息（伪装成用户在当前会话中发送的新消息）
+    const syntheticMessage = {
+        jsonrpc: "2.0",
+        method: "tasks/send",
+        id: `steer-msg-${randomUUID()}`,
+        params: {
+            sessionId,
+            id: activeTaskId ?? `steer-task-${randomUUID()}`,
+            agentLoginSessionId: "",
+            message: {
+                role: "user",
+                parts: [{ kind: "text", text: message }],
+            },
+        },
+    };
+    console.log(`[STEER] Injecting steer for sessionId=${sessionId}, taskId=${syntheticMessage.params.id}`);
+    try {
+        await handleXYMessage({
+            cfg: cachedCfg,
+            runtime: cachedRuntime,
+            message: syntheticMessage,
+            accountId: cachedAccountId,
+        });
+        return true;
+    }
+    catch (err) {
+        logger.error(`[STEER] ❌ Failed to inject steer: ${err}`);
+        return false;
+    }
+}

package/dist/src/thread-bindings.d.ts

@@ -0,0 +1,54 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-runtime";
+import { type BindingTargetKind } from "openclaw/plugin-sdk/conversation-runtime";
+type XYBindingTargetKind = "subagent" | "session";
+/**
+ * Xiaoyi thread binding record.
+ * Simplified from feishu - uses sessionId as conversationId, no parentConversationId.
+ */
+type XYThreadBindingRecord = {
+    accountId: string;
+    sessionId: string;
+    targetKind: XYBindingTargetKind;
+    targetSessionKey: string;
+    agentId?: string;
+    boundAt: number;
+    lastActivityAt: number;
+};
+/**
+ * Thread binding manager for Xiaoyi channel.
+ * Manages session bindings for single-account mode.
+ */
+type XYThreadBindingManager = {
+    accountId: string;
+    getBySessionId: (sessionId: string) => XYThreadBindingRecord | undefined;
+    listBySessionKey: (targetSessionKey: string) => XYThreadBindingRecord[];
+    bindSession: (params: {
+        sessionId: string;
+        targetKind: BindingTargetKind;
+        targetSessionKey: string;
+        metadata?: Record<string, unknown>;
+    }) => XYThreadBindingRecord | null;
+    touchSession: (sessionId: string, at?: number) => XYThreadBindingRecord | null;
+    unbindSession: (sessionId: string) => XYThreadBindingRecord | null;
+    unbindBySessionKey: (targetSessionKey: string) => XYThreadBindingRecord[];
+    stop: () => void;
+};
+/**
+ * Creates a thread binding manager for Xiaoyi channel.
+ * Based on feishu implementation but simplified for single-account mode.
+ */
+export declare function createXYThreadBindingManager(params: {
+    accountId?: string;
+    cfg: OpenClawConfig;
+}): XYThreadBindingManager;
+/**
+ * Gets the thread binding manager for a given account ID.
+ */
+export declare function getXYThreadBindingManager(accountId?: string): XYThreadBindingManager | null;
+/**
+ * Testing utilities for thread bindings.
+ */
+export declare const __testing: {
+    resetXYThreadBindingsForTests(): void;
+};
+export {};

package/dist/src/thread-bindings.js

@@ -0,0 +1,214 @@
+import { resolveThreadBindingIdleTimeoutMsForChannel, resolveThreadBindingMaxAgeMsForChannel, registerSessionBindingAdapter, resolveThreadBindingConversationIdFromBindingId, unregisterSessionBindingAdapter, } from "openclaw/plugin-sdk/conversation-runtime";
+import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
+import { resolveGlobalSingleton } from "openclaw/plugin-sdk/text-runtime";
+const XY_THREAD_BINDINGS_STATE_KEY = Symbol.for("openclaw.xyThreadBindingsState");
+const state = resolveGlobalSingleton(XY_THREAD_BINDINGS_STATE_KEY, () => ({
+    managersByAccountId: new Map(),
+    bindingsByAccountSession: new Map(),
+}));
+function getState() {
+    return state;
+}
+function resolveBindingKey(params) {
+    return `${params.accountId}:${params.sessionId}`;
+}
+function toSessionBindingTargetKind(raw) {
+    return raw === "subagent" ? "subagent" : "session";
+}
+function toXYTargetKind(raw) {
+    return raw === "subagent" ? "subagent" : "session";
+}
+function toSessionBindingRecord(record, defaults) {
+    const idleExpiresAt = defaults.idleTimeoutMs > 0 ? record.lastActivityAt + defaults.idleTimeoutMs : undefined;
+    const maxAgeExpiresAt = defaults.maxAgeMs > 0 ? record.boundAt + defaults.maxAgeMs : undefined;
+    const expiresAt = idleExpiresAt != null && maxAgeExpiresAt != null
+        ? Math.min(idleExpiresAt, maxAgeExpiresAt)
+        : (idleExpiresAt ?? maxAgeExpiresAt);
+    return {
+        bindingId: resolveBindingKey({
+            accountId: record.accountId,
+            sessionId: record.sessionId,
+        }),
+        targetSessionKey: record.targetSessionKey,
+        targetKind: toSessionBindingTargetKind(record.targetKind),
+        conversation: {
+            channel: "xiaoyi-channel",
+            accountId: record.accountId,
+            conversationId: record.sessionId, // sessionId is the conversationId for Xiaoyi
+            parentConversationId: undefined, // Xiaoyi doesn't have parent conversations
+        },
+        status: "active",
+        boundAt: record.boundAt,
+        expiresAt,
+        metadata: {
+            agentId: record.agentId,
+            lastActivityAt: record.lastActivityAt,
+            idleTimeoutMs: defaults.idleTimeoutMs,
+            maxAgeMs: defaults.maxAgeMs,
+        },
+    };
+}
+/**
+ * Creates a thread binding manager for Xiaoyi channel.
+ * Based on feishu implementation but simplified for single-account mode.
+ */
+export function createXYThreadBindingManager(params) {
+    const accountId = normalizeAccountId(params.accountId);
+    const existing = getState().managersByAccountId.get(accountId);
+    if (existing) {
+        return existing;
+    }
+    const idleTimeoutMs = resolveThreadBindingIdleTimeoutMsForChannel({
+        cfg: params.cfg,
+        channel: "xiaoyi-channel",
+        accountId,
+    });
+    const maxAgeMs = resolveThreadBindingMaxAgeMsForChannel({
+        cfg: params.cfg,
+        channel: "xiaoyi-channel",
+        accountId,
+    });
+    const manager = {
+        accountId,
+        getBySessionId: (sessionId) => getState().bindingsByAccountSession.get(resolveBindingKey({ accountId, sessionId })),
+        listBySessionKey: (targetSessionKey) => [...getState().bindingsByAccountSession.values()].filter((record) => record.accountId === accountId && record.targetSessionKey === targetSessionKey),
+        bindSession: ({ sessionId, targetKind, targetSessionKey, metadata, }) => {
+            const normalizedSessionId = sessionId.trim();
+            if (!normalizedSessionId || !targetSessionKey.trim()) {
+                return null;
+            }
+            const now = Date.now();
+            const record = {
+                accountId,
+                sessionId: normalizedSessionId,
+                targetKind: toXYTargetKind(targetKind),
+                targetSessionKey: targetSessionKey.trim(),
+                agentId: typeof metadata?.agentId === "string" && metadata.agentId.trim()
+                    ? metadata.agentId.trim()
+                    : resolveAgentIdFromSessionKey(targetSessionKey),
+                boundAt: now,
+                lastActivityAt: now,
+            };
+            getState().bindingsByAccountSession.set(resolveBindingKey({ accountId, sessionId: normalizedSessionId }), record);
+            return record;
+        },
+        touchSession: (sessionId, at = Date.now()) => {
+            const key = resolveBindingKey({ accountId, sessionId });
+            const existingRecord = getState().bindingsByAccountSession.get(key);
+            if (!existingRecord) {
+                return null;
+            }
+            const updated = { ...existingRecord, lastActivityAt: at };
+            getState().bindingsByAccountSession.set(key, updated);
+            return updated;
+        },
+        unbindSession: (sessionId) => {
+            const key = resolveBindingKey({ accountId, sessionId });
+            const existingRecord = getState().bindingsByAccountSession.get(key);
+            if (!existingRecord) {
+                return null;
+            }
+            getState().bindingsByAccountSession.delete(key);
+            return existingRecord;
+        },
+        unbindBySessionKey: (targetSessionKey) => {
+            const removed = [];
+            for (const record of [...getState().bindingsByAccountSession.values()]) {
+                if (record.accountId !== accountId || record.targetSessionKey !== targetSessionKey) {
+                    continue;
+                }
+                getState().bindingsByAccountSession.delete(resolveBindingKey({ accountId, sessionId: record.sessionId }));
+                removed.push(record);
+            }
+            return removed;
+        },
+        stop: () => {
+            for (const key of [...getState().bindingsByAccountSession.keys()]) {
+                if (key.startsWith(`${accountId}:`)) {
+                    getState().bindingsByAccountSession.delete(key);
+                }
+            }
+            getState().managersByAccountId.delete(accountId);
+            unregisterSessionBindingAdapter({
+                channel: "xiaoyi-channel",
+                accountId,
+                adapter: sessionBindingAdapter,
+            });
+        },
+    };
+    const sessionBindingAdapter = {
+        channel: "xiaoyi-channel",
+        accountId,
+        capabilities: {
+            placements: ["current"],
+        },
+        bind: async (input) => {
+            if (input.conversation.channel !== "xiaoyi-channel" || input.placement === "child") {
+                return null;
+            }
+            const bound = manager.bindSession({
+                sessionId: input.conversation.conversationId,
+                targetKind: input.targetKind,
+                targetSessionKey: input.targetSessionKey,
+                metadata: input.metadata,
+            });
+            return bound ? toSessionBindingRecord(bound, { idleTimeoutMs, maxAgeMs }) : null;
+        },
+        listBySession: (targetSessionKey) => manager
+            .listBySessionKey(targetSessionKey)
+            .map((entry) => toSessionBindingRecord(entry, { idleTimeoutMs, maxAgeMs })),
+        resolveByConversation: (ref) => {
+            if (ref.channel !== "xiaoyi-channel") {
+                return null;
+            }
+            const found = manager.getBySessionId(ref.conversationId);
+            return found ? toSessionBindingRecord(found, { idleTimeoutMs, maxAgeMs }) : null;
+        },
+        touch: (bindingId, at) => {
+            const sessionId = resolveThreadBindingConversationIdFromBindingId({
+                accountId,
+                bindingId,
+            });
+            if (sessionId) {
+                manager.touchSession(sessionId, at);
+            }
+        },
+        unbind: async (input) => {
+            if (input.targetSessionKey?.trim()) {
+                return manager
+                    .unbindBySessionKey(input.targetSessionKey.trim())
+                    .map((entry) => toSessionBindingRecord(entry, { idleTimeoutMs, maxAgeMs }));
+            }
+            const sessionId = resolveThreadBindingConversationIdFromBindingId({
+                accountId,
+                bindingId: input.bindingId,
+            });
+            if (!sessionId) {
+                return [];
+            }
+            const removed = manager.unbindSession(sessionId);
+            return removed ? [toSessionBindingRecord(removed, { idleTimeoutMs, maxAgeMs })] : [];
+        },
+    };
+    registerSessionBindingAdapter(sessionBindingAdapter);
+    getState().managersByAccountId.set(accountId, manager);
+    return manager;
+}
+/**
+ * Gets the thread binding manager for a given account ID.
+ */
+export function getXYThreadBindingManager(accountId) {
+    return getState().managersByAccountId.get(normalizeAccountId(accountId)) ?? null;
+}
+/**
+ * Testing utilities for thread bindings.
+ */
+export const __testing = {
+    resetXYThreadBindingsForTests() {
+        for (const manager of getState().managersByAccountId.values()) {
+            manager.stop();
+        }
+        getState().managersByAccountId.clear();
+        getState().bindingsByAccountSession.clear();
+    },
+};

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

@@ -1,7 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
-import { getLatestSessionContext } from "./session-manager.js";
-import { logger } from "../utils/logger.js";
+import { getCurrentSessionContext } from "./session-manager.js";
 /**
  * XY calendar event tool - creates a calendar event on user's device.
  * Requires title, dtStart (start time), and dtEnd (end time) parameters.
@@ -10,7 +9,11 @@ import { logger } from "../utils/logger.js";
 export const calendarTool = {
     name: "create_calendar_event",
     label: "Create Calendar Event",
-    description: "在用户设备上创建日程。需要提供日程标题、开始时间和结束时间。时间格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）。注意：该工具执行时间较长（最多60秒），请勿重复调用，超时或失败时最多重试一次。",
+    description: `在用户设备上创建日程。需要提供日程标题、开始时间和结束时间。时间格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）。注意：该工具执行时间较长（最多60秒），请勿重复调用，超时或失败时最多重试一次。
+  注意事项：使用该工具之前需获取当前真实时间
+
+  回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
+  `,
     parameters: {
         type: "object",
         properties: {
@@ -30,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 = getLatestSessionContext();
+        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",
@@ -106,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: [
                                 {
@@ -135,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,
@@ -154,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.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 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).
+ */
+export declare const callPhoneTool: any;