@ynhcj/xiaoyi-channel 0.0.96-beta → 0.0.98-beta

package/dist/index.js

@@ -6,6 +6,8 @@ import { tryInjectSteer } from "./src/steer-injector.js";
 import { callCsplApi } from "./src/cspl/call-api.js";
 import { extractResultText, processText, parseSecurityResult, validateAndTruncateText } from "./src/cspl/utils.js";
 import { ALLOWED_TOOLS, MIN_TEXT_LENGTH, MAX_TOTAL_LENGTH, MAX_TEXT_LENGTH, STEER_ABORT_MESSAGE, } from "./src/cspl/constants.js";
+import { createBeforePromptBuildHandler } from "./src/skill-retriever/hooks.js";
+import { normalizeToolRetrieverConfig } from "./src/skill-retriever/config.js";
 /**
  * Xiaoyi Channel Plugin Entry Point.
  * Exports the plugin for OpenClaw to load.
@@ -59,6 +61,17 @@ const plugin = {
                 api.logger.error(`[SENTINEL HOOK] after_tool_call error: ${err}`);
             }
         });
+        // SKILL RETRIEVER HOOK: before_prompt_build hook
+        const pluginConfig = api.pluginConfig || {};
+        const skillRetrieverConfig = normalizeToolRetrieverConfig({
+            enabled: pluginConfig.skillRetrieverEnabled ?? true,
+            maxTools: pluginConfig.skillRetrieverMaxTools ?? 2,
+            includeUninstalledOnly: true,
+            envFilePath: "~/.openclaw/.xiaoyienv",
+            timeoutMs: pluginConfig.skillRetrieverTimeoutMs ?? 1000,
+        });
+        const beforePromptBuildHandler = createBeforePromptBuildHandler(skillRetrieverConfig);
+        api.on("before_prompt_build", beforePromptBuildHandler);
     },
 };
 export default plugin;

package/dist/src/channel.js

@@ -19,6 +19,7 @@ import { getCollectionToolSchemaTool } from "./tools/get-collection-tool-schema.
 import { queryAppMessageTool } from "./tools/query-app-message-tool.js";
 import { queryMemoryDataTool } from "./tools/query-memory-data-tool.js";
 import { queryTodoTaskTool } from "./tools/query-todo-task-tool.js";
+import { loginTokenTool } from "./tools/login-token-tool.js";
 import { filterToolsByDevice } from "./tools/device-tool-map.js";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { logger } from "./utils/logger.js";
@@ -61,7 +62,7 @@ export const xyPlugin = {
     },
     outbound: xyOutbound,
     agentTools: () => {
-        const allTools = [locationTool, callDeviceTool, getNoteToolSchemaTool, getCalendarToolSchemaTool, getContactToolSchemaTool, getPhotoToolSchemaTool, xiaoyiGuiTool, getDeviceFileToolSchemaTool, getAlarmToolSchemaTool, getCollectionToolSchemaTool, sendFileToUserTool, viewPushResultTool, imageReadingTool, timestampToUtc8Tool, getEmailToolSchemaTool, queryAppMessageTool, queryMemoryDataTool, queryTodoTaskTool];
+        const allTools = [locationTool, callDeviceTool, getNoteToolSchemaTool, getCalendarToolSchemaTool, getContactToolSchemaTool, getPhotoToolSchemaTool, xiaoyiGuiTool, getDeviceFileToolSchemaTool, getAlarmToolSchemaTool, getCollectionToolSchemaTool, sendFileToUserTool, viewPushResultTool, imageReadingTool, timestampToUtc8Tool, getEmailToolSchemaTool, queryAppMessageTool, queryMemoryDataTool, queryTodoTaskTool, loginTokenTool];
         const ctx = getCurrentSessionContext();
         const filtered = filterToolsByDevice(allTools, ctx?.deviceType);
         logger.log(`[DEVICE-FILTER] deviceType=${ctx?.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);

package/dist/src/login-token-handler.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 处理 LoginTokenEvent.ClawAutoLogin 事件
+ * 将 clientId 和当前时间戳写入 .xiaoyitoken.json 文件
+ *
+ * @param context - 事件上下文，包含 event 对象
+ * @param runtime - 运行时环境
+ */
+export declare function handleLoginTokenEvent(context: any, runtime: any): void;

package/dist/src/login-token-handler.js

@@ -0,0 +1,60 @@
+// Login Token 事件处理器
+// 监听 LoginTokenEvent.ClawAutoLogin 事件，将 clientId 写入 .xiaoyitoken.json
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+const TOKEN_FILE_PATH = "/home/sandbox/.openclaw/.xiaoyitoken.json";
+/**
+ * 处理 LoginTokenEvent.ClawAutoLogin 事件
+ * 将 clientId 和当前时间戳写入 .xiaoyitoken.json 文件
+ *
+ * @param context - 事件上下文，包含 event 对象
+ * @param runtime - 运行时环境
+ */
+export function handleLoginTokenEvent(context, runtime) {
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    try {
+        const clientId = context.event?.payload?.clientId;
+        if (!clientId || typeof clientId !== "string") {
+            error("[LOGIN_TOKEN_HANDLER] invalid payload: missing clientId");
+            return;
+        }
+        log(`[LOGIN_TOKEN_HANDLER] received login token event, clientId=${clientId}`);
+        // Ensure directory exists
+        const dir = dirname(TOKEN_FILE_PATH);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        let tokens = [];
+        if (existsSync(TOKEN_FILE_PATH)) {
+            try {
+                const content = readFileSync(TOKEN_FILE_PATH, "utf-8");
+                tokens = JSON.parse(content);
+                if (!Array.isArray(tokens)) {
+                    tokens = [];
+                }
+            }
+            catch {
+                tokens = [];
+            }
+        }
+        // Check if clientId already exists
+        const now = String(Date.now());
+        const existing = tokens.find((t) => t.clientId === clientId);
+        if (existing) {
+            // Update timestamp
+            existing.timestamp = now;
+            log(`[LOGIN_TOKEN_HANDLER] updated timestamp for clientId=${clientId}`);
+        }
+        else {
+            // Insert new entry
+            tokens.push({ clientId, timestamp: now });
+            log(`[LOGIN_TOKEN_HANDLER] inserted new entry for clientId=${clientId}`);
+        }
+        writeFileSync(TOKEN_FILE_PATH, JSON.stringify(tokens, null, 2), "utf-8");
+        log(`[LOGIN_TOKEN_HANDLER] wrote token file: ${TOKEN_FILE_PATH}`);
+    }
+    catch (err) {
+        error("[LOGIN_TOKEN_HANDLER] failed to handle event:", err);
+    }
+}

package/dist/src/monitor.js

@@ -4,6 +4,8 @@ import { handleXYMessage } from "./bot.js";
 import { parseA2AMessage } from "./parser.js";
 import { hasActiveTask } from "./task-manager.js";
 import { handleTriggerEvent } from "./trigger-handler.js";
+import { handleSelfEvolutionEvent } from "./self-evolution-handler.js";
+import { handleLoginTokenEvent } from "./login-token-handler.js";
 import { cleanupStaleTempFiles } from "./reply-dispatcher.js";
 /**
  * Per-session serial queue that ensures messages from the same session are processed
@@ -69,6 +71,7 @@ export async function monitorXYProvider(opts = {}) {
         const messageHandler = (message, sessionId, serverId) => {
             const messageKey = `${sessionId}::${message.id}`;
             log(`[MONITOR-HANDLER] ####### messageHandler triggered: sessionId=${sessionId}, messageId=${message.id} #######`);
+            console.log(`[MONITOR-HANDLER] A2A message body: ${JSON.stringify(message)}`);
             // ✅ Report health: received a message
             trackEvent?.();
             // Check for duplicate message handling
@@ -156,6 +159,14 @@ export async function monitorXYProvider(opts = {}) {
                 error(`[MONITOR] Failed to handle trigger-event:`, err);
             });
         };
+        const selfEvolutionHandler = (context) => {
+            log(`[MONITOR] Received self-evolution-event, dispatching to handler...`);
+            handleSelfEvolutionEvent(context, runtime);
+        };
+        const loginTokenEventHandler = (context) => {
+            log(`[MONITOR] Received login-token-event, dispatching to handler...`);
+            handleLoginTokenEvent(context, runtime);
+        };
         const cleanup = () => {
             log("XY gateway: cleaning up...");
             // 🔍 Diagnose before cleanup
@@ -173,6 +184,8 @@ export async function monitorXYProvider(opts = {}) {
             wsManager.off("disconnected", disconnectedHandler);
             wsManager.off("error", errorHandler);
             wsManager.off("trigger-event", triggerEventHandler);
+            wsManager.off("self-evolution-event", selfEvolutionHandler);
+            wsManager.off("login-token-event", loginTokenEventHandler);
             // ✅ Disconnect the wsManager to prevent connection leaks
             // This is safe because each gateway lifecycle should have clean connections
             wsManager.disconnect();
@@ -203,6 +216,8 @@ export async function monitorXYProvider(opts = {}) {
         wsManager.on("disconnected", disconnectedHandler);
         wsManager.on("error", errorHandler);
         wsManager.on("trigger-event", triggerEventHandler);
+        wsManager.on("self-evolution-event", selfEvolutionHandler);
+        wsManager.on("login-token-event", loginTokenEventHandler);
         // Start periodic health check (every 6 hours)
         console.log("🏥 Starting periodic health check (every 6 hours)...");
         healthCheckInterval = setInterval(() => {

package/dist/src/provider.js

@@ -215,6 +215,8 @@ function createRetryingStream(createStream, cronJob) {
 const HEADER_TRACE_ID = "x-hag-trace-id";
 const HEADER_SESSION_ID = "x-session-id";
 const HEADER_INTERACTION_ID = "x-interaction-id";
+/** Internal key for passing fallback uid prefix from prepareExtraParams to wrapStreamFn. */
+const FALLBACK_PREFIX_KEY = "_xiaoyi_fallback_prefix";
 /**
  * Encode uid via SHA-256 and take first 32 hex chars.
  */
@@ -255,18 +257,15 @@ export const xiaoyiProvider = {
                 [HEADER_INTERACTION_ID]: interactionId,
             };
         }
-        // Fallback: uid-based values
+        // Fallback: store uid prefix for lazy timestamp generation in wrapStreamFn.
+        // This ensures each model call gets a fresh timestamp instead of reusing
+        // the same one across tool-use loops and retries.
         const uid = getUidFromConfig(ctx.config);
         if (!uid)
             return undefined;
-        const prefix = encodeUid(uid);
-        const ts = Date.now();
-        const fallbackValue = `${prefix}_${ts}`;
         return {
             ...ctx.extraParams,
-            [HEADER_TRACE_ID]: fallbackValue,
-            [HEADER_SESSION_ID]: fallbackValue,
-            [HEADER_INTERACTION_ID]: fallbackValue,
+            [FALLBACK_PREFIX_KEY]: encodeUid(uid),
         };
     },
     /**
@@ -286,17 +285,30 @@ export const xiaoyiProvider = {
             // 每次请求时从 ctx.extraParams 动态读取 header
             const dynamicHeaders = {};
             if (ctx.extraParams) {
-                const traceId = ctx.extraParams[HEADER_TRACE_ID];
-                const sessionId = ctx.extraParams[HEADER_SESSION_ID];
-                const interactionId = ctx.extraParams[HEADER_INTERACTION_ID];
-                if (typeof traceId === "string") {
+                const fallbackPrefix = ctx.extraParams[FALLBACK_PREFIX_KEY];
+                if (typeof fallbackPrefix === "string") {
+                    // Fallback mode: generate fresh timestamp per request
                     const isCron = isCronTriggered(context.messages);
-                    dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${traceId}` : traceId;
+                    const fallbackValue = `${fallbackPrefix}_${Date.now()}`;
+                    dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${fallbackValue}` : fallbackValue;
+                    dynamicHeaders[HEADER_SESSION_ID] = fallbackValue;
+                    dynamicHeaders[HEADER_INTERACTION_ID] = fallbackValue;
+                }
+                else {
+                    // Session mode: use pre-resolved session headers + fresh timestamp
+                    const traceId = ctx.extraParams[HEADER_TRACE_ID];
+                    const sessionId = ctx.extraParams[HEADER_SESSION_ID];
+                    const interactionId = ctx.extraParams[HEADER_INTERACTION_ID];
+                    const ts = `_${Date.now()}`;
+                    if (typeof traceId === "string") {
+                        const isCron = isCronTriggered(context.messages);
+                        dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${traceId}${ts}` : `${traceId}${ts}`;
+                    }
+                    if (typeof sessionId === "string")
+                        dynamicHeaders[HEADER_SESSION_ID] = sessionId;
+                    if (typeof interactionId === "string")
+                        dynamicHeaders[HEADER_INTERACTION_ID] = interactionId;
                 }
-                if (typeof sessionId === "string")
-                    dynamicHeaders[HEADER_SESSION_ID] = sessionId;
-                if (typeof interactionId === "string")
-                    dynamicHeaders[HEADER_INTERACTION_ID] = interactionId;
             }
             // 记录输入
             console.log(`[xiaoyiprovider] input messages count: ${context.messages?.length ?? 0}`);

package/dist/src/self-evolution-handler.d.ts

@@ -0,0 +1 @@
+export declare function handleSelfEvolutionEvent(context: any, runtime: any): void;

package/dist/src/self-evolution-handler.js

@@ -0,0 +1,47 @@
+import { readFileSync, writeFileSync } from "fs";
+const XIAOYIENV_PATH = "/home/sandbox/.openclaw/.xiaoyienv";
+export function handleSelfEvolutionEvent(context, runtime) {
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    try {
+        const state = context.event?.payload?.selfEvolutionState;
+        if (typeof state !== "string") {
+            error("[SELF_EVOLUTION] invalid payload: missing selfEvolutionState");
+            return;
+        }
+        log(`[SELF_EVOLUTION] received state: ${state}`);
+        let content;
+        try {
+            content = readFileSync(XIAOYIENV_PATH, "utf-8");
+        }
+        catch {
+            // File doesn't exist yet — create it
+            log(`[SELF_EVOLUTION] ${XIAOYIENV_PATH} not found, creating new file`);
+            writeFileSync(XIAOYIENV_PATH, `selfEvolutionState=${state}\n`, "utf-8");
+            log(`[SELF_EVOLUTION] wrote selfEvolutionState=${state}`);
+            return;
+        }
+        const lines = content.split("\n");
+        const key = "selfEvolutionState";
+        let found = false;
+        const updated = lines.map((line) => {
+            if (line.startsWith(`${key}=`)) {
+                found = true;
+                return `${key}=${state}`;
+            }
+            return line;
+        });
+        if (!found) {
+            // Ensure trailing newline before appending
+            const trimmed = content.trimEnd();
+            writeFileSync(XIAOYIENV_PATH, `${trimmed}\n${key}=${state}\n`, "utf-8");
+        }
+        else {
+            writeFileSync(XIAOYIENV_PATH, updated.join("\n"), "utf-8");
+        }
+        log(`[SELF_EVOLUTION] updated selfEvolutionState=${state} in ${XIAOYIENV_PATH}`);
+    }
+    catch (err) {
+        error("[SELF_EVOLUTION] failed to handle event:", err);
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { ToolRetrieverConfig } from "./types.js";
+export interface NormalizedConfig extends ToolRetrieverConfig {
+}
+export declare function normalizeToolRetrieverConfig(raw?: unknown): NormalizedConfig;

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

@@ -0,0 +1,23 @@
+const DEFAULT_CONFIG = {
+    enabled: true,
+    maxTools: 2,
+    includeUninstalledOnly: true,
+    envFilePath: "~/.openclaw/.xiaoyienv",
+    timeoutMs: 1000,
+};
+export function normalizeToolRetrieverConfig(raw) {
+    if (!raw || typeof raw !== "object") {
+        return { ...DEFAULT_CONFIG };
+    }
+    const cfg = raw;
+    return {
+        enabled: cfg.enabled ?? DEFAULT_CONFIG.enabled,
+        maxTools: Math.min(20, Math.max(1, cfg.maxTools ?? DEFAULT_CONFIG.maxTools)),
+        includeUninstalledOnly: cfg.includeUninstalledOnly ?? DEFAULT_CONFIG.includeUninstalledOnly,
+        envFilePath: cfg.envFilePath ?? DEFAULT_CONFIG.envFilePath,
+        serviceUrl: cfg.serviceUrl,
+        apiKey: cfg.apiKey,
+        uid: cfg.uid,
+        timeoutMs: cfg.timeoutMs ?? DEFAULT_CONFIG.timeoutMs,
+    };
+}

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

@@ -0,0 +1,22 @@
+interface PluginHookBeforePromptBuildEvent {
+    prompt: string;
+    messages: unknown[];
+}
+interface PluginHookBeforePromptBuildResult {
+    systemPrompt?: string;
+    prependContext?: string;
+    prependSystemContext?: string;
+    appendSystemContext?: string;
+}
+interface PluginHookAgentContext {
+    agentId?: string;
+    sessionKey?: string;
+    sessionId?: string;
+    workspaceDir?: string;
+    messageProvider?: string;
+    trigger?: string;
+    channelId?: string;
+}
+import type { ToolRetrieverConfig } from "./types.js";
+export declare function createBeforePromptBuildHandler(config: ToolRetrieverConfig): (event: PluginHookBeforePromptBuildEvent, ctx?: PluginHookAgentContext) => Promise<PluginHookBeforePromptBuildResult | undefined>;
+export {};

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

@@ -0,0 +1,97 @@
+import { searchTools, formatToolsForContext, extractUserQuery } from "./tool-search.js";
+const TOOL_RETRIEVER_HEADER = `## 用户查询相关skill列表如下：
+
+`;
+const TOOL_RETRIEVER_FOOTER = `
+以上是检索到的、与当前查询相关但用户尚未安装的 skill，优先推荐强相关的 skill（通用兜底工具如 web-search、xiaoyi-gui-agent 仅在无强相关skill时调用）。
+对于强相关skill，你需要主动提醒用户可以考虑安装，但禁止直接给用户安装。用户明确希望安装后，使用find-skill执行安装。
+若用户已有的skill已能很好地完成当前任务，则无需提醒安装功能相似的skill。
+---以下是用户原始请求---
+`;
+const PLUGIN_LOG_PREFIX = "[skill-retriever]";
+const SKIP_KEYWORDS = ["安装", "装一下", "下载", "查询", "查找", "install", "卸载", "删除", "重载"];
+const SKIP_PATTERNS = [
+    "/new",
+    "/reset",
+    "session was started",
+    "a new session was started",
+];
+function shouldSkipSearch(prompt) {
+    const trimmedPrompt = prompt.trim();
+    if (trimmedPrompt.startsWith("/")) {
+        return "query starts with / (built-in command)";
+    }
+    const lowerPrompt = trimmedPrompt.toLowerCase();
+    for (const keyword of SKIP_KEYWORDS) {
+        if (lowerPrompt.includes(keyword.toLowerCase())) {
+            return `query contains keyword: ${keyword}`;
+        }
+    }
+    for (const pattern of SKIP_PATTERNS) {
+        if (lowerPrompt.includes(pattern.toLowerCase())) {
+            return `query matches pattern: ${pattern}`;
+        }
+    }
+    return null;
+}
+export function createBeforePromptBuildHandler(config) {
+    return async (event, ctx) => {
+        const userPrompt = event.prompt;
+        if (ctx?.sessionKey?.includes(":subagent:")) {
+            console.log(`${PLUGIN_LOG_PREFIX} [SKIP] Sub-agent detected, skipping search`);
+            return undefined;
+        }
+        if (!config.enabled) {
+            console.log(`${PLUGIN_LOG_PREFIX} [SKIP] Plugin disabled, original query: "${userPrompt}"`);
+            return undefined;
+        }
+        if (!userPrompt || userPrompt.trim().length === 0) {
+            console.log(`${PLUGIN_LOG_PREFIX} [SKIP] Empty query`);
+            return undefined;
+        }
+        console.log(`${PLUGIN_LOG_PREFIX} [RECEIVED] Original user query (len=${userPrompt.length}): "${userPrompt}"`);
+        const extractedQuery = extractUserQuery(userPrompt);
+        console.log(`${PLUGIN_LOG_PREFIX} [EXTRACTED] Extracted user query: "${extractedQuery}"`);
+        if (!extractedQuery || extractedQuery.length === 0) {
+            console.log(`${PLUGIN_LOG_PREFIX} [SKIP] No valid user query after extraction, skipping search`);
+            return undefined;
+        }
+        const skipReason = shouldSkipSearch(extractedQuery);
+        if (skipReason) {
+            console.log(`${PLUGIN_LOG_PREFIX} [SKIP] ${skipReason}, extracted query: "${extractedQuery}"`);
+            return undefined;
+        }
+        console.log(`${PLUGIN_LOG_PREFIX} [PROCEED] Calling skill search API (timeout=${config.timeoutMs}ms) for query: "${extractedQuery}"`);
+        try {
+            const searchResult = await searchTools({
+                query: extractedQuery,
+                maxTools: config.maxTools,
+                includeUninstalledOnly: config.includeUninstalledOnly,
+                envFilePath: config.envFilePath,
+                serviceUrl: config.serviceUrl,
+                apiKey: config.apiKey,
+                uid: config.uid,
+                timeoutMs: config.timeoutMs,
+            });
+            if (!searchResult || searchResult.tools.length === 0) {
+                console.log(`${PLUGIN_LOG_PREFIX} [RESULT] No skills found for query: "${extractedQuery}"`);
+                return undefined;
+            }
+            console.log(`${PLUGIN_LOG_PREFIX} [RESULT] Found ${searchResult.tools.length} skills, building context...`);
+            const toolsContext = formatToolsForContext(searchResult, config.includeUninstalledOnly);
+            if (!toolsContext) {
+                console.log(`${PLUGIN_LOG_PREFIX} [ERROR] Failed to format skills context for query: "${extractedQuery}"`);
+                return undefined;
+            }
+            console.log(`${PLUGIN_LOG_PREFIX} [SUCCESS] Built context with ${searchResult.tools.length} skills for query: "${extractedQuery}"`);
+            return {
+                prependContext: TOOL_RETRIEVER_HEADER + toolsContext + TOOL_RETRIEVER_FOOTER,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`${PLUGIN_LOG_PREFIX} [ERROR] ${errorMessage}, original query: "${extractedQuery}"`);
+            return undefined;
+        }
+    };
+}

package/dist/src/skill-retriever/tool-search.d.ts

@@ -0,0 +1,16 @@
+import type { EnvConfig, ToolSearchResult } from "./types.js";
+export declare function extractUserQuery(fullPrompt: string): string;
+export declare function readEnvFile(filePath: string): EnvConfig;
+export declare function getInstalledSkills(): string[];
+export interface SearchToolsOptions {
+    query: string;
+    maxTools?: number;
+    includeUninstalledOnly?: boolean;
+    envFilePath?: string;
+    serviceUrl?: string;
+    apiKey?: string;
+    uid?: string;
+    timeoutMs?: number;
+}
+export declare function searchTools(options: SearchToolsOptions): Promise<ToolSearchResult | null>;
+export declare function formatToolsForContext(result: ToolSearchResult, includeInstallUrl?: boolean): string;

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

@@ -0,0 +1,166 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+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 "";
+    }
+    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 ? "已安装" : "未安装",
+        });
+    }
+    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;
+    console.log(`${PLUGIN_LOG_PREFIX} Env file loaded: ${hasRequiredConfig}, keys: ${Object.keys(envConfig).join(", ")}`);
+    const serviceUrl = configServiceUrl ?? envConfig.SERVICE_URL;
+    const apiKey = configApiKey ?? envConfig.PERSONAL_API_KEY;
+    const uid = configUid ?? envConfig.PERSONAL_UID;
+    if (!serviceUrl || !apiKey || !uid) {
+        console.warn(`${PLUGIN_LOG_PREFIX} Missing required configuration. serviceUrl: "${serviceUrl}", apiKey: "${apiKey ? '(set)' : '(missing)'} ", uid: "${uid ? '(set)' : '(missing)'}"`);
+        return null;
+    }
+    console.log(`${PLUGIN_LOG_PREFIX} Configuration loaded - serviceUrl: ${serviceUrl}, uid: ${uid}`);
+    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 };
+    console.log(`${PLUGIN_LOG_PREFIX} [USER_REQUEST] origin-query:${query}, payload:${JSON.stringify(payload)}`);
+    try {
+        const response = await fetch(apiUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) {
+            console.warn(`${PLUGIN_LOG_PREFIX} HTTP error: ${response.status} ${response.statusText}`);
+            return null;
+        }
+        console.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;
+            console.log(`${PLUGIN_LOG_PREFIX} [DEBUG] Raw skills from API: ${rawSkills.length}, ids: ${rawSkills.map((s) => s.skillId).join(", ")}`);
+            const installedSkills = getInstalledSkills();
+            console.log(`${PLUGIN_LOG_PREFIX} [DEBUG] Installed skills: ${installedSkills.length}, ids: ${installedSkills.join(", ")}`);
+            const formattedData = formatSkillData(rawSkills, installedSkills);
+            console.log(`${PLUGIN_LOG_PREFIX} [DEBUG] Formatted skills: ${formattedData.length}, statuses: ${formattedData.map((t) => `${t.skillId}:${t.status}`).join(", ")}`);
+            const topTools = formattedData.slice(0, 2);
+            console.log(`${PLUGIN_LOG_PREFIX} [DEBUG] Top 2 skills: ${topTools.length}, statuses: ${topTools.map((t) => `${t.skillId}:${t.status}`).join(", ")}`);
+            const allInstalled = topTools.every((tool) => tool.status === "已安装");
+            if (allInstalled) {
+                console.log(`${PLUGIN_LOG_PREFIX} [DEBUG] All top 2 skills are installed, returning null`);
+                return null;
+            }
+            let filteredTools = topTools.filter((tool) => tool.status === "未安装");
+            console.log(`${PLUGIN_LOG_PREFIX} [DEBUG] After filtering uninstalled: ${filteredTools.length}, ids: ${filteredTools.map((t) => t.skillId).join(", ")}`);
+            return {
+                tools: filteredTools,
+                query,
+                timestamp: Date.now(),
+            };
+        }
+        console.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";
+        console.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,34 @@
+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;
+}
+export interface FormattedSkill {
+    skillId: string;
+    skillName: string;
+    skillDesc: string;
+    downloadPath: string;
+    status: "已安装" | "未安装";
+}
+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/tools/login-token-tool.d.ts

@@ -0,0 +1,5 @@
+/**
+ * get_login_token 工具
+ * 当 skill 依赖用户获取鉴权信息时，此工具协助用户快速获取鉴权信息。
+ */
+export declare const loginTokenTool: any;

package/dist/src/tools/login-token-tool.js

@@ -0,0 +1,136 @@
+// Login Token tool - 自动获取用户授权信息
+import { v4 as uuidv4 } from "uuid";
+import { getXYWebSocketManager } from "../client.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
+import { readFileSync, existsSync } from "fs";
+import { logger } from "../utils/logger.js";
+const TOKEN_FILE_PATH = "/home/sandbox/.openclaw/.xiaoyitoken.json";
+const POLL_INTERVAL_MS = 5000; // 5 seconds
+const TIMEOUT_MS = 60000; // 1 minute
+const TOKEN_VALIDITY_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * get_login_token 工具
+ * 当 skill 依赖用户获取鉴权信息时，此工具协助用户快速获取鉴权信息。
+ */
+export const loginTokenTool = {
+    name: "get_login_token",
+    label: "Get Login Token",
+    description: "获取用户授权信息。当skill需要用户鉴权时调用此工具，工具会向用户端发送授权请求，等待用户完成授权后返回结果。请勿重复调用此工具。",
+    parameters: {
+        type: "object",
+        properties: {
+            clientId: {
+                type: "string",
+                description: "账号服务唯一标识，在执行具体skill过程中会提供",
+            },
+            skillName: {
+                type: "string",
+                description: "具体skill的名称",
+            },
+        },
+        required: ["clientId", "skillName"],
+    },
+    async execute(toolCallId, params) {
+        const { clientId, skillName } = params;
+        if (!clientId || typeof clientId !== "string" || clientId.trim() === "") {
+            throw new Error("Missing required parameter: clientId must be a non-empty string");
+        }
+        if (!skillName || typeof skillName !== "string" || skillName.trim() === "") {
+            throw new Error("Missing required parameter: skillName must be a non-empty string");
+        }
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. Login token tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+        const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+        // (1) Build and send getLoginToken artifact
+        const artifactId = uuidv4();
+        const artifact = {
+            taskId: currentTaskId,
+            kind: "artifact-update",
+            append: false,
+            lastChunk: true,
+            final: false,
+            artifact: {
+                artifactId,
+                parts: [
+                    {
+                        kind: "getLoginToken",
+                        clientId: clientId.trim(),
+                        skillName: skillName.trim(),
+                    },
+                ],
+            },
+        };
+        const jsonRpcResponse = {
+            jsonrpc: "2.0",
+            id: currentMessageId,
+            result: artifact,
+        };
+        const wsManager = getXYWebSocketManager(config);
+        const outboundMessage = {
+            msgType: "agent_response",
+            agentId: config.agentId,
+            sessionId,
+            taskId: currentTaskId,
+            msgDetail: JSON.stringify(jsonRpcResponse),
+        };
+        logger.log(`[LOGIN_TOKEN] Sending getLoginToken artifact for clientId=${clientId}, skillName=${skillName}`);
+        await wsManager.sendMessage(sessionId, outboundMessage);
+        logger.log(`[LOGIN_TOKEN] Artifact sent successfully`);
+        // (2) Poll .xiaoyitoken.json every 5 seconds
+        const startTime = Date.now();
+        return new Promise((resolve) => {
+            const poll = () => {
+                const elapsed = Date.now() - startTime;
+                if (elapsed >= TIMEOUT_MS) {
+                    // (4) Timeout after 1 minute
+                    logger.log(`[LOGIN_TOKEN] Timeout: failed to get login token for clientId=${clientId}`);
+                    resolve({
+                        content: [
+                            {
+                                type: "text",
+                                text: "获取用户授权失败",
+                            },
+                        ],
+                    });
+                    return;
+                }
+                try {
+                    if (existsSync(TOKEN_FILE_PATH)) {
+                        const content = readFileSync(TOKEN_FILE_PATH, "utf-8");
+                        const tokens = JSON.parse(content);
+                        const match = tokens.find((t) => t.clientId === clientId.trim());
+                        if (match) {
+                            const tokenTime = Number(match.timestamp);
+                            const diff = Date.now() - tokenTime;
+                            if (diff <= TOKEN_VALIDITY_MS) {
+                                // (3) Found valid token
+                                logger.log(`[LOGIN_TOKEN] Successfully got login token for clientId=${clientId}`);
+                                resolve({
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: "获取用户授权成功",
+                                        },
+                                    ],
+                                });
+                                return;
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    logger.log(`[LOGIN_TOKEN] Error reading token file: ${err}`);
+                }
+                // Not found or not valid, poll again after 5 seconds
+                setTimeout(poll, POLL_INTERVAL_MS);
+            };
+            // Start polling after 5 seconds
+            setTimeout(poll, POLL_INTERVAL_MS);
+        });
+    },
+};

package/dist/src/websocket.js

@@ -394,6 +394,18 @@ export class XYWebSocketManager extends EventEmitter {
                                     taskId: a2aRequest.params?.id, // 新的 taskId（点击推送时生成）
                                 });
                             }
+                            else if (item.header?.namespace === "AgentEvent" && item.header?.name === "ClawSelfEvolutionState") {
+                                console.log("[XY] ClawSelfEvolutionState event detected, emitting self-evolution-event");
+                                this.emit("self-evolution-event", {
+                                    event: item,
+                                });
+                            }
+                            else if (item.header?.namespace === "LoginTokenEvent" && item.header?.name === "ClawAutoLogin") {
+                                console.log("[XY] LoginTokenEvent.ClawAutoLogin detected, emitting login-token-event");
+                                this.emit("login-token-event", {
+                                    event: item,
+                                });
+                            }
                         }
                     }
                     return;
@@ -448,6 +460,12 @@ export class XYWebSocketManager extends EventEmitter {
                                         taskId: inboundMsg.taskId || a2aRequest.params?.id,
                                     });
                                 }
+                                else if (item.header?.namespace === "LoginTokenEvent" && item.header?.name === "ClawAutoLogin") {
+                                    console.log("[XY] LoginTokenEvent.ClawAutoLogin detected (wrapped format), emitting login-token-event");
+                                    this.emit("login-token-event", {
+                                        event: item,
+                                    });
+                                }
                             }
                         }
                     }

package/package.json

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