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

package/dist/src/task-manager.js

@@ -0,0 +1,136 @@
+// TaskId Manager - 管理session级别的活跃taskId
+// 支持动态切换taskId，用于steer模式下的消息插队
+import { logger } from "./utils/logger.js";
+/**
+ * Session到活跃TaskId的映射
+ * Key: sessionId (注意：这里用sessionId，不是sessionKey)
+ * Value: TaskIdBinding
+ */
+const activeTaskIds = new Map();
+/**
+ * 注册或更新session的活跃taskId
+ * 返回是否是更新（用于判断是否是第二条消息）
+ */
+export function registerTaskId(sessionId, taskId, messageId, options) {
+    logger.log(`[TASK_MANAGER] 📝 Registering/Updating taskId for session: ${sessionId}`);
+    logger.log(`[TASK_MANAGER]   - New taskId: ${taskId}`);
+    logger.log(`[TASK_MANAGER]   - New messageId: ${messageId}`);
+    logger.log(`[TASK_MANAGER]   - incrementRef: ${options?.incrementRef ?? false}`);
+    const existing = activeTaskIds.get(sessionId);
+    if (existing) {
+        logger.log(`[TASK_MANAGER]   - Previous taskId: ${existing.currentTaskId}`);
+        logger.log(`[TASK_MANAGER]   - Previous refCount: ${existing.refCount}`);
+        logger.log(`[TASK_MANAGER]   - 🔄 Switching taskId (steer mode detected)`);
+        // 更新taskId，但保持引用计数
+        existing.currentTaskId = taskId;
+        existing.currentMessageId = messageId;
+        existing.updatedAt = Date.now();
+        if (options?.incrementRef) {
+            existing.refCount++;
+            logger.log(`[TASK_MANAGER]   - Incremented refCount: ${existing.refCount}`);
+        }
+        logger.log(`[TASK_MANAGER]   - ✅ TaskId updated, refCount=${existing.refCount}`);
+        return { isUpdate: true, refCount: existing.refCount };
+    }
+    else {
+        // 新注册
+        const binding = {
+            sessionId,
+            currentTaskId: taskId,
+            currentMessageId: messageId,
+            refCount: 1,
+            updatedAt: Date.now(),
+            locked: false,
+        };
+        activeTaskIds.set(sessionId, binding);
+        logger.log(`[TASK_MANAGER]   - ✅ TaskId registered (new), refCount=1`);
+        return { isUpdate: false, refCount: 1 };
+    }
+}
+/**
+ * 增加引用计数（消息开始处理时调用）
+ */
+export function incrementTaskIdRef(sessionId) {
+    const binding = activeTaskIds.get(sessionId);
+    if (binding) {
+        binding.refCount++;
+        logger.log(`[TASK_MANAGER] ➕ Incremented refCount for ${sessionId}: ${binding.refCount}`);
+    }
+}
+/**
+ * 减少引用计数，当refCount=0时才真正清理
+ */
+export function decrementTaskIdRef(sessionId) {
+    const binding = activeTaskIds.get(sessionId);
+    if (!binding) {
+        logger.log(`[TASK_MANAGER] ⚠️  No binding found for ${sessionId}`);
+        return;
+    }
+    binding.refCount--;
+    logger.log(`[TASK_MANAGER] ➖ Decremented refCount for ${sessionId}: ${binding.refCount}`);
+    if (binding.refCount <= 0 && !binding.locked) {
+        logger.log(`[TASK_MANAGER] 🗑️  RefCount=0 and unlocked, clearing taskId`);
+        activeTaskIds.delete(sessionId);
+    }
+    else {
+        logger.log(`[TASK_MANAGER]   - Keeping binding (refCount=${binding.refCount}, locked=${binding.locked})`);
+    }
+}
+/**
+ * 锁定taskId，防止被清理（第一个消息使用）
+ */
+export function lockTaskId(sessionId) {
+    const binding = activeTaskIds.get(sessionId);
+    if (binding) {
+        binding.locked = true;
+        logger.log(`[TASK_MANAGER] 🔒 Locked taskId for ${sessionId}`);
+    }
+}
+/**
+ * 解锁taskId（第一个消息完成时使用）
+ */
+export function unlockTaskId(sessionId) {
+    const binding = activeTaskIds.get(sessionId);
+    if (binding) {
+        binding.locked = false;
+        logger.log(`[TASK_MANAGER] 🔓 Unlocked taskId for ${sessionId}`);
+        // 解锁后，如果refCount=0，立即清理
+        if (binding.refCount <= 0) {
+            logger.log(`[TASK_MANAGER] 🗑️  Unlocked and refCount=0, clearing taskId`);
+            activeTaskIds.delete(sessionId);
+        }
+    }
+}
+/**
+ * 获取session的当前活跃taskId
+ */
+export function getCurrentTaskId(sessionId) {
+    const binding = activeTaskIds.get(sessionId);
+    return binding?.currentTaskId ?? null;
+}
+/**
+ * 获取session的当前活跃messageId
+ */
+export function getCurrentMessageId(sessionId) {
+    const binding = activeTaskIds.get(sessionId);
+    return binding?.currentMessageId ?? null;
+}
+/**
+ * 检查session是否有活跃的taskId
+ */
+export function hasActiveTask(sessionId) {
+    return activeTaskIds.has(sessionId);
+}
+/**
+ * 获取完整的binding信息（用于调试）
+ */
+export function getTaskIdBinding(sessionId) {
+    return activeTaskIds.get(sessionId) ?? null;
+}
+/**
+ * 强制清理（错误恢复用）
+ */
+export function forceCleanTaskId(sessionId) {
+    logger.log(`[TASK_MANAGER] ⚠️  Force clearing taskId for ${sessionId}`);
+    activeTaskIds.delete(sessionId);
+}

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

@@ -1,6 +1,6 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.js";
-import { getLatestSessionContext } from "./session-manager.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.
@@ -10,7 +10,9 @@ 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: {
@@ -54,7 +56,7 @@ export const calendarTool = {
         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}`);

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;

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

@@ -0,0 +1,183 @@
+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).
+ */
+export const callPhoneTool = {
+    name: "call_phone",
+    label: "Call Phone",
+    description: "拨打电话。需要提供要拨打的电话号码。slotId参数可选，默认为0（主卡），如果用户明确要求使用副卡则设置为1。注意:操作超时时间为60秒,请勿重复调用此工具,如果超时或失败,最多重试一次。",
+    parameters: {
+        type: "object",
+        properties: {
+            phoneNumber: {
+                type: "string",
+                description: "要拨打的电话号码",
+            },
+            slotId: {
+                type: "number",
+                description: "SIM卡槽ID，默认为0（主卡），设置为1表示副卡。仅当用户明确要求使用副卡时才设置为1",
+                default: 0,
+            },
+        },
+        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",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "StartCall",
+                    bundleName: "com.huawei.hmos.aidispatchservice",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    timeOut: 5,
+                    intentParam: {
+                        phoneNumber: params.phoneNumber.trim(),
+                        slotId: slotId,
+                    },
+                    permissionId: [],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                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;
+                        }
+                        // Return the outputs directly
+                        const result = {
+                            success: true,
+                            code: code,
+                            phoneNumber: params.phoneNumber,
+                            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: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(result),
+                                },
+                            ],
+                        });
+                    }
+                    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,
+                taskId,
+                messageId,
+                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);
+            });
+        });
+    },
+};

package/dist/src/tools/create-alarm-tool.d.ts

@@ -0,0 +1,7 @@
+/**
+ * XY create alarm tool - creates an alarm on user's device.
+ * Requires alarmTime parameter. Other parameters are optional with sensible defaults.
+ *
+ * Time format: YYYYMMDD hhmmss (e.g., 20240315 143000)
+ */
+export declare const createAlarmTool: any;