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

package/dist/src/skill-retriever/tool-search.js

@@ -0,0 +1,173 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { logger } from "../utils/logger.js";
+const SKILL_ID = "celia_find_skills";
+const PLUGIN_LOG_PREFIX = "[skill-retriever]";
+export function extractUserQuery(fullPrompt) {
+    const lastNewlineIndex = fullPrompt.lastIndexOf("\n");
+    if (lastNewlineIndex === -1) {
+        return fullPrompt.trim();
+    }
+    const afterLastNewline = fullPrompt.slice(lastNewlineIndex + 1).trim();
+    if (!afterLastNewline || afterLastNewline === "```") {
+        return "";
+    }
+    if (fullPrompt.toLowerCase().includes("cron")) {
+        return "";
+    }
+    return afterLastNewline;
+}
+function expandPath(filePath) {
+    if (filePath.startsWith("~")) {
+        return path.join(os.homedir(), filePath.slice(1).replace(/^\/+/, ""));
+    }
+    return filePath;
+}
+export function readEnvFile(filePath) {
+    const expandedPath = expandPath(filePath);
+    const envDict = {};
+    try {
+        const content = fs.readFileSync(expandedPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#")) {
+                continue;
+            }
+            const eqIndex = trimmed.indexOf("=");
+            if (eqIndex > 0) {
+                let key = trimmed.substring(0, eqIndex).trim();
+                const value = trimmed.substring(eqIndex + 1).trim();
+                key = key.replace(/-/g, "_");
+                envDict[key] = value;
+            }
+        }
+    }
+    catch {
+        // File not found or read error - return empty config
+    }
+    return envDict;
+}
+export function getInstalledSkills() {
+    const skillsDir = expandPath("~/.openclaw/workspace/skills");
+    const installedSkills = [];
+    try {
+        if (fs.existsSync(skillsDir) && fs.statSync(skillsDir).isDirectory()) {
+            const entries = fs.readdirSync(skillsDir);
+            for (const entry of entries) {
+                const entryPath = path.join(skillsDir, entry);
+                if (fs.statSync(entryPath).isDirectory()) {
+                    installedSkills.push(entry);
+                }
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist or read error - return empty list
+    }
+    return installedSkills;
+}
+function formatSkillData(rawSkills, installedSkills) {
+    const formattedSkills = [];
+    for (const skill of rawSkills) {
+        const isInstalled = installedSkills.includes(skill.skillId);
+        formattedSkills.push({
+            skillId: skill.skillId,
+            skillName: skill.skillName,
+            skillDesc: skill.skillDesc,
+            downloadPath: skill.packUrl,
+            status: isInstalled ? "已安装" : "未安装",
+            rrfScore: skill.rrfScore,
+        });
+    }
+    return formattedSkills;
+}
+export async function searchTools(options) {
+    const { query, maxTools = 5, includeUninstalledOnly = true, envFilePath = "~/.openclaw/.xiaoyienv", serviceUrl: configServiceUrl, apiKey: configApiKey, uid: configUid, timeoutMs = 1000, } = options;
+    const envConfig = readEnvFile(envFilePath);
+    const hasRequiredConfig = !!envConfig.SERVICE_URL && !!envConfig.PERSONAL_API_KEY && !!envConfig.PERSONAL_UID;
+    const serviceUrl = configServiceUrl ?? envConfig.SERVICE_URL;
+    const apiKey = configApiKey ?? envConfig.PERSONAL_API_KEY;
+    const uid = configUid ?? envConfig.PERSONAL_UID;
+    if (!serviceUrl || !apiKey || !uid) {
+        logger.warn(`${PLUGIN_LOG_PREFIX} Missing required configuration. serviceUrl: "${serviceUrl}", apiKey: "${apiKey ? '(set)' : '(missing)'} ", uid: "${uid ? '(set)' : '(missing)'}"`);
+        return null;
+    }
+    const traceId = crypto.randomUUID();
+    const apiUrl = `${serviceUrl}/celia-claw/v1/rest-api/skill/execute`;
+    const headers = {
+        "Content-Type": "application/json",
+        "x-skill-id": SKILL_ID,
+        "x-hag-trace-id": traceId,
+        "x-uid": uid,
+        "x-api-key": apiKey,
+        "x-request-from": "openclaw",
+    };
+    const payload = { query };
+    try {
+        const response = await fetch(apiUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) {
+            logger.warn(`${PLUGIN_LOG_PREFIX} HTTP error: ${response.status} ${response.statusText}`);
+            return null;
+        }
+        logger.log(`${PLUGIN_LOG_PREFIX} Received response, status: ${response.status}`);
+        const responseData = await response.json();
+        if (responseData.errorCode === "0" &&
+            responseData.content &&
+            responseData.content.skills) {
+            const rawSkills = responseData.content.skills;
+            const installedSkills = getInstalledSkills();
+            const formattedData = formatSkillData(rawSkills, installedSkills);
+            const topTools = formattedData.slice(0, 2);
+            const allInstalled = topTools.every((tool) => tool.status === "已安装");
+            if (allInstalled) {
+                logger.log(`${PLUGIN_LOG_PREFIX} [DEBUG] All top 2 skills are installed, returning null`);
+                return null;
+            }
+            const hasInstalledWithHighScore = topTools.some((tool) => tool.status === "已安装" && (tool.rrfScore ?? 0) >= 0.016);
+            if (hasInstalledWithHighScore) {
+                logger.log(`${PLUGIN_LOG_PREFIX} [DEBUG] Top 2 has installed skill with rrfScore >= 0.016, returning null`);
+                return null;
+            }
+            let filteredTools = topTools.filter((tool) => tool.status === "未安装" && (tool.rrfScore ?? 0) >= 0.016);
+            logger.log(`${PLUGIN_LOG_PREFIX} [DEBUG] After filtering uninstalled with rrfScore >= 0.016: ${filteredTools.length}, details: ${filteredTools.map((t) => `${t.skillId}(rrfScore=${t.rrfScore})`).join(", ")}`);
+            if (filteredTools.length === 0) {
+                logger.log(`${PLUGIN_LOG_PREFIX} [DEBUG] No uninstalled skills with rrfScore >= 0.016, returning null`);
+                return null;
+            }
+            return {
+                tools: filteredTools,
+                query,
+                timestamp: Date.now(),
+            };
+        }
+        logger.warn(`${PLUGIN_LOG_PREFIX} Invalid response format: ${JSON.stringify(responseData).slice(0, 200)}`);
+        return null;
+    }
+    catch (error) {
+        const errorName = error instanceof Error ? error.name : "Unknown";
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorCause = error instanceof Error && error.cause ? JSON.stringify(error.cause) : "N/A";
+        const errorStack = error instanceof Error ? error.stack?.split("\n").slice(0, 3).join(" | ") : "N/A";
+        logger.warn(`${PLUGIN_LOG_PREFIX} [ERROR] Fetch failed - name: ${errorName}, message: ${errorMessage}, cause: ${errorCause}, stack: ${errorStack}`);
+        return null;
+    }
+}
+export function formatToolsForContext(result, includeInstallUrl = true) {
+    if (!result.tools || result.tools.length === 0) {
+        return "";
+    }
+    const toolDescriptions = [];
+    for (const tool of result.tools) {
+        let description = `### ${tool.skillName}\n`;
+        description += `name: ${tool.skillId}\n`;
+        description += `description: ${tool.skillDesc}\n`;
+        toolDescriptions.push(description);
+    }
+    return toolDescriptions.join("\n\n");
+}

package/dist/src/skill-retriever/types.d.ts

@@ -0,0 +1,36 @@
+export interface ToolRetrieverConfig {
+    enabled: boolean;
+    maxTools: number;
+    includeUninstalledOnly: boolean;
+    envFilePath: string;
+    serviceUrl?: string;
+    apiKey?: string;
+    uid?: string;
+    timeoutMs?: number;
+}
+export interface RawSkill {
+    skillId: string;
+    skillName: string;
+    skillDesc: string;
+    packUrl: string;
+    rrfScore?: number;
+}
+export interface FormattedSkill {
+    skillId: string;
+    skillName: string;
+    skillDesc: string;
+    downloadPath: string;
+    status: "已安装" | "未安装";
+    rrfScore?: number;
+}
+export interface ToolSearchResult {
+    tools: FormattedSkill[];
+    query: string;
+    timestamp: number;
+}
+export interface EnvConfig {
+    PERSONAL_API_KEY?: string;
+    PERSONAL_UID?: string;
+    SERVICE_URL?: string;
+    [key: string]: string | undefined;
+}

package/dist/src/skill-retriever/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/steer-injector.js

@@ -57,7 +57,7 @@ export async function tryInjectSteer(sessionKey, message) {
             },
         },
     };
-    console.log(`[STEER] Injecting steer for sessionId=${sessionId}, taskId=${syntheticMessage.params.id}`);
+    logger.log(`[STEER] Injecting steer for sessionId=${sessionId}, taskId=${syntheticMessage.params.id}`);
     try {
         await handleXYMessage({
             cfg: cachedCfg,

package/dist/src/task-manager.d.ts

@@ -48,6 +48,10 @@ export declare function hasActiveTask(sessionId: string): boolean;
  * 获取完整的binding信息（用于调试）
  */
 export declare function getTaskIdBinding(sessionId: string): TaskIdBinding | null;
+/**
+ * 获取所有活跃的 task bindings（用于 gateway_stop 通知等场景）
+ */
+export declare function getAllActiveTaskBindings(): TaskIdBinding[];
 /**
  * 强制清理（错误恢复用）
  */

package/dist/src/task-manager.js

@@ -5,8 +5,13 @@ import { logger } from "./utils/logger.js";
  * Session到活跃TaskId的映射
  * Key: sessionId (注意：这里用sessionId，不是sessionKey)
  * Value: TaskIdBinding
+ * Uses globalThis to ensure a single Map across all module copies.
  */
-const activeTaskIds = new Map();
+const _g = globalThis;
+if (!_g.__xyActiveTaskIds) {
+    _g.__xyActiveTaskIds = new Map();
+}
+const activeTaskIds = _g.__xyActiveTaskIds;
 /**
  * 注册或更新session的活跃taskId
  * 返回是否是更新（用于判断是否是第二条消息）
@@ -127,6 +132,12 @@ export function hasActiveTask(sessionId) {
 export function getTaskIdBinding(sessionId) {
     return activeTaskIds.get(sessionId) ?? null;
 }
+/**
+ * 获取所有活跃的 task bindings（用于 gateway_stop 通知等场景）
+ */
+export function getAllActiveTaskBindings() {
+    return Array.from(activeTaskIds.values());
+}
 /**
  * 强制清理（错误恢复用）
  */

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

@@ -1,6 +1,7 @@
+import type { SessionContext } 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.
  * Time format must be: yyyy-mm-dd hh:mm:ss
  */
-export declare const calendarTool: any;
+export declare function createCalendarTool(ctx: SessionContext): any;

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

@@ -1,134 +1,130 @@
 import { getXYWebSocketManager } from "../client.js";
 import { sendCommand } from "../formatter.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.
  * Time format must be: yyyy-mm-dd hh:mm:ss
  */
-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秒），请勿重复调用，超时或失败时最多重试一次。
+export function createCalendarTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "create_calendar_event",
+        label: "Create Calendar Event",
+        description: `在用户设备上创建日程。需要提供日程标题、开始时间和结束时间。时间格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）。注意：该工具执行时间较长（最多60秒），请勿重复调用，超时或失败时最多重试一次。
   注意事项：使用该工具之前需获取当前真实时间
 
   回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
   `,
-    parameters: {
-        type: "object",
-        properties: {
-            title: {
-                type: "string",
-                description: "日程标题/名称",
-            },
-            dtStart: {
-                type: "string",
-                description: "日程开始时间，格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）",
-            },
-            dtEnd: {
-                type: "string",
-                description: "日程结束时间，格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 17:30:00）",
+        parameters: {
+            type: "object",
+            properties: {
+                title: {
+                    type: "string",
+                    description: "日程标题/名称",
+                },
+                dtStart: {
+                    type: "string",
+                    description: "日程开始时间，格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 14:30:00）",
+                },
+                dtEnd: {
+                    type: "string",
+                    description: "日程结束时间，格式必须为：yyyy-mm-dd hh:mm:ss（例如：2024-01-15 17:30:00）",
+                },
             },
+            required: ["title", "dtStart", "dtEnd"],
         },
-        required: ["title", "dtStart", "dtEnd"],
-    },
-    async execute(toolCallId, params) {
-        // Validate parameters
-        if (!params.title || !params.dtStart || !params.dtEnd) {
-            throw new Error("Missing required parameters: title, dtStart, and dtEnd are required");
-        }
-        // Convert time strings to millisecond timestamps
-        const dtStartMs = new Date(params.dtStart).getTime();
-        const dtEndMs = new Date(params.dtEnd).getTime();
-        if (isNaN(dtStartMs) || isNaN(dtEndMs)) {
-            throw new Error("Invalid time format. Required format: yyyy-mm-dd hh:mm:ss (e.g., 2024-01-15 14:30:00)");
-        }
-        // Get session context
-        const sessionContext = getCurrentSessionContext();
-        if (!sessionContext) {
-            throw new Error("No active XY session found. Calendar tool can only be used during an active conversation.");
-        }
-        const { config, sessionId, taskId, messageId } = sessionContext;
-        // Get WebSocket manager
-        const wsManager = getXYWebSocketManager(config);
-        // Build CreateCalendarEvent command
-        const command = {
-            header: {
-                namespace: "Common",
-                name: "ActionAndResult",
-            },
-            payload: {
-                cardParam: {},
-                executeParam: {
-                    executeMode: "background",
-                    intentName: "CreateCalendarEvent",
-                    bundleName: "com.huawei.hmos.calendardata",
-                    dimension: "",
-                    needUnlock: true,
-                    actionResponse: true,
-                    timeOut: 5,
-                    intentParam: {
-                        title: params.title,
-                        dtStart: dtStartMs,
-                        dtEnd: dtEndMs,
-                    },
-                    achieveType: "INTENT",
+        async execute(toolCallId, params) {
+            // Validate parameters
+            if (!params.title || !params.dtStart || !params.dtEnd) {
+                throw new Error("Missing required parameters: title, dtStart, and dtEnd are required");
+            }
+            // Convert time strings to millisecond timestamps
+            const dtStartMs = new Date(params.dtStart).getTime();
+            const dtEndMs = new Date(params.dtEnd).getTime();
+            if (isNaN(dtStartMs) || isNaN(dtEndMs)) {
+                throw new Error("Invalid time format. Required format: yyyy-mm-dd hh:mm:ss (e.g., 2024-01-15 14:30:00)");
+            }
+            // Get WebSocket manager
+            const wsManager = getXYWebSocketManager(config);
+            // Build CreateCalendarEvent command
+            const command = {
+                header: {
+                    namespace: "Common",
+                    name: "ActionAndResult",
                 },
-                responses: [
-                    {
-                        resultCode: "",
-                        displayText: "",
-                        ttsText: "",
+                payload: {
+                    cardParam: {},
+                    executeParam: {
+                        executeMode: "background",
+                        intentName: "CreateCalendarEvent",
+                        bundleName: "com.huawei.hmos.calendardata",
+                        dimension: "",
+                        needUnlock: true,
+                        actionResponse: true,
+                        timeOut: 5,
+                        intentParam: {
+                            title: params.title,
+                            dtStart: dtStartMs,
+                            dtEnd: dtEndMs,
+                        },
+                        achieveType: "INTENT",
                     },
-                ],
-                needUploadResult: true,
-                noHalfPage: false,
-                pageControlRelated: false,
-            },
-        };
-        // Send command and wait for response (60 second timeout)
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                wsManager.off("data-event", handler);
-                reject(new Error("创建日程超时（60秒）"));
-            }, 60000);
-            // Listen for data events from WebSocket
-            const handler = (event) => {
-                if (event.intentName === "CreateCalendarEvent") {
-                    clearTimeout(timeout);
+                    responses: [
+                        {
+                            resultCode: "",
+                            displayText: "",
+                            ttsText: "",
+                        },
+                    ],
+                    needUploadResult: true,
+                    noHalfPage: false,
+                    pageControlRelated: false,
+                },
+            };
+            // Send command and wait for response (60 second timeout)
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
                     wsManager.off("data-event", handler);
-                    if (event.status === "success" && event.outputs) {
-                        resolve({
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify(event.outputs),
-                                },
-                            ],
-                        });
-                    }
-                    else {
-                        reject(new Error(`创建日程失败: ${event.status}`));
+                    reject(new Error("创建日程超时（60秒）"));
+                }, 60000);
+                // Listen for data events from WebSocket
+                const handler = (event) => {
+                    if (event.intentName === "CreateCalendarEvent") {
+                        clearTimeout(timeout);
+                        wsManager.off("data-event", handler);
+                        if (event.status === "success" && event.outputs) {
+                            resolve({
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify(event.outputs),
+                                    },
+                                ],
+                            });
+                        }
+                        else {
+                            reject(new Error(`创建日程失败: ${event.status}`));
+                        }
                     }
-                }
-            };
-            // Register event handler
-            wsManager.on("data-event", handler);
-            // Send the command
-            sendCommand({
-                config,
-                sessionId,
-                taskId,
-                messageId,
-                command,
-            })
-                .then(() => {
-            })
-                .catch((error) => {
-                clearTimeout(timeout);
-                wsManager.off("data-event", handler);
-                reject(error);
+                };
+                // Register event handler
+                wsManager.on("data-event", handler);
+                // Send the command
+                sendCommand({
+                    config,
+                    sessionId,
+                    taskId,
+                    messageId,
+                    command,
+                })
+                    .then(() => {
+                })
+                    .catch((error) => {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    reject(error);
+                });
             });
-        });
-    },
-};
+        },
+    };
+}

package/dist/src/tools/call-device-tool.d.ts

@@ -1,5 +1,6 @@
+import type { SessionContext } from "./session-manager.js";
 /**
  * call_device_tool - 通用端工具调度器。
  * LLM 必须先通过 get_xxx_tool_schema 获取具体工具 schema，再用本工具执行。
  */
-export declare const callDeviceTool: any;
+export declare function createCallDeviceTool(ctx: SessionContext): any;