@ynhcj/xiaoyi-channel 0.0.67-next → 0.0.68-next

package/dist/index.js

@@ -5,7 +5,24 @@ import { setXYRuntime } from "./src/runtime.js";
 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 { selfEvolutionManager } from "./src/utils/self-evolution-manager.js";
+import { TOOL_CALL_NUDGE_THRESHOLD, toolCallNudgeManager } from "./src/utils/tool-call-nudge-manager.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";
+const SELF_EVOLUTION_NUDGE_MESSAGE = `[系统消息，非用户发送] 当前任务已经调用了较多工具。如果你识别到存在稳定、可复用的踩坑经验或排错模式，可以在完成当前主要任务后，正式回复用户前，阅读evolution skill开启自进化。注意，不要打断当前主任务，已完成任务为最高优先级。`;
+function shouldCountToolCall(toolName) {
+    if (toolName === "save_self_evolution_skill") {
+        return false;
+    }
+    if (toolName === "call_device_tool") {
+        return false;
+    }
+    if (toolName.endsWith("_tool_schema")) {
+        return false;
+    }
+    return true;
+}
 /**
  * Xiaoyi Channel Plugin Entry Point.
  * Exports the plugin for OpenClaw to load.
@@ -23,6 +40,21 @@ const plugin = {
         // SENTINEL HOOK after_tool_call hook: 监听工具结果，发送至安全检测 API 进行安全检测
         // 如果响应为 REJECT，注入 steer 消息中止当前对话
         api.on("after_tool_call", async (event, ctx) => {
+            if (ctx.sessionKey &&
+                await selfEvolutionManager.isEnabled() &&
+                shouldCountToolCall(event.toolName)) {
+                try {
+                    const { count, shouldNudge } = toolCallNudgeManager.recordToolCall(ctx.sessionKey);
+                    api.logger.debug?.(`[SELF_EVOLUTION] Tool call counted: tool=${event.toolName}, count=${count}, threshold=${TOOL_CALL_NUDGE_THRESHOLD}, sessionKey=${ctx.sessionKey}`);
+                    if (shouldNudge) {
+                        api.logger.info?.(`[SELF_EVOLUTION] Tool call threshold reached, injecting nudge: count=${count}, sessionKey=${ctx.sessionKey}`);
+                        await tryInjectSteer(ctx.sessionKey, SELF_EVOLUTION_NUDGE_MESSAGE);
+                    }
+                }
+                catch (err) {
+                    api.logger.error(`[SELF_EVOLUTION] after_tool_call nudge error: ${err}`);
+                }
+            }
             if (!ALLOWED_TOOLS.includes(event.toolName)) {
                 return;
             }
@@ -59,6 +91,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

@@ -7,6 +7,7 @@ import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
 import { viewPushResultTool } from "./tools/view-push-result-tool.js";
 import { imageReadingTool } from "./tools/image-reading-tool.js";
 import { timestampToUtc8Tool } from "./tools/timestamp-to-utc8-tool.js";
+import { saveSelfEvolutionSkillTool } from "./tools/save-self-evolution-skill-tool.js";
 import { getEmailToolSchemaTool } from "./tools/get-email-tool-schema.js";
 import { callDeviceTool } from "./tools/call-device-tool.js";
 import { getNoteToolSchemaTool } from "./tools/get-note-tool-schema.js";
@@ -62,7 +63,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, loginTokenTool];
+        const allTools = [locationTool, callDeviceTool, getNoteToolSchemaTool, getCalendarToolSchemaTool, getContactToolSchemaTool, getPhotoToolSchemaTool, xiaoyiGuiTool, getDeviceFileToolSchemaTool, getAlarmToolSchemaTool, getCollectionToolSchemaTool, sendFileToUserTool, viewPushResultTool, imageReadingTool, timestampToUtc8Tool, saveSelfEvolutionSkillTool, 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/monitor.js

@@ -71,7 +71,6 @@ 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

package/dist/src/provider.js

@@ -9,6 +9,7 @@
 //   models.providers.xiaoyiprovider.models = [...]
 import { createHash } from "crypto";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
+import { selfEvolutionManager } from "./utils/self-evolution-manager.js";
 // ── Retry config ──────────────────────────────────────────────
 const RETRY_DELAYS_MS = [10_000, 20_000, 40_000, 60_000];
 const MAX_RETRY_ATTEMPTS = 8;
@@ -21,6 +22,8 @@ function isRetryableProviderError(message) {
         return true;
     if (lower.includes("rate limit reached for requests"))
         return true;
+    if (lower.includes("现在访问有点拥挤，稍等一下再试会更顺畅哦～"))
+        return true;
     return false;
 }
 /** Check if the request is triggered by a cron job by inspecting the first user message. */
@@ -41,6 +44,25 @@ function isCronTriggered(messages) {
     }
     return /^\[cron:/i.test(text.trim());
 }
+/** Extract cron title from first user message matching `[cron:<uuid> <title>]`. */
+function extractCronTitle(messages) {
+    if (!messages)
+        return undefined;
+    const firstUser = messages.find(m => m.role === "user");
+    if (!firstUser)
+        return undefined;
+    let text = "";
+    if (typeof firstUser.content === "string") {
+        text = firstUser.content;
+    }
+    else if (Array.isArray(firstUser.content)) {
+        const block = firstUser.content.find(b => b.type === "text" && typeof b.text === "string");
+        if (block)
+            text = block.text;
+    }
+    const match = text.trim().match(/^\[cron:[^\s]+\s+(.+)\]$/);
+    return match ? match[1] : undefined;
+}
 /** Compute retry delay in ms for the given 1-based attempt, with up to 10s jitter. */
 function getRetryDelayMs(attempt, isCron = false) {
     if (isCron) {
@@ -217,6 +239,39 @@ 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";
+const SELF_EVOLUTION_PROMPT_BEGIN = "<self_evolution_prompt>";
+const SELF_EVOLUTION_PROMPT_END = "</self_evolution_prompt>";
+const SELF_EVOLUTION_ENABLED_PROMPT_SECTION = `
+${SELF_EVOLUTION_PROMPT_BEGIN}
+## Self Evolution(CRITICAL)
+用户已启用自进化(不管之前是什么状态，不管之前的对话记录，当前视作已开启即可)。
+自进化含义：当你识别出某个稳定、可复用的经验、调试模式或工作流程，并且它很可能对未来完成此用户的同类任务有帮助时，你可以考虑将其保存为可复用的经验。
+
+[触发条件]
+当满足以下任意一项时，必须触发自进化流程：
+- 显式指令与关键词匹配（最高优先级）：当用户消息中包含“进化”、“下次应该”、“以后必须”、“永远”等表达长期意图的词汇，或伴随明显的行为纠正、流程规范化或交付标准设定的指导动作等。
+- 主动固化要求：用户主动要求将过去的交互经验（如交付件规格、skill选择、任务工作流等）进行沉淀/自进化。
+- 隐式经验与避坑沉淀：当前任务执行过程中，你识别出了可以持久化为长期经验的标准工作流，或者在执行中遇到了工具调用错误、命令参数错误等明确的“踩坑点”，以后需要规避。
+
+[触发后处理]
+- 遵循 "self-evolution" 技能指导逐步进行技能评估。
+- 只能在任务完成后，正式回复用户前读取该技能。
+- 禁止直接修改文件。需要先创建提案，向用户发送进化请求，用户同意后才能进行更改。
+${SELF_EVOLUTION_PROMPT_END}
+`.trim();
+const SELF_EVOLUTION_DISABLED_PROMPT_SECTION = `
+${SELF_EVOLUTION_PROMPT_BEGIN}
+## Self Evolution
+用户当前已禁用自我进化。
+你不得执行自进化相关行为，并且应将此功能视为不可用(不管之前是什么状态，不管之前的对话记录，当前视作已关闭即可)。
+${SELF_EVOLUTION_PROMPT_END}
+`.trim();
+function stripSelfEvolutionPrompt(prompt) {
+    return prompt
+        .replace(/\n*<self_evolution_prompt>[\s\S]*?<\/self_evolution_prompt>\n*/gu, "\n\n")
+        .replace(/\n{3,}/gu, "\n\n")
+        .trim();
+}
 /**
  * Encode uid via SHA-256 and take first 32 hex chars.
  */
@@ -293,15 +348,26 @@ export const xiaoyiProvider = {
                     dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${fallbackValue}` : fallbackValue;
                     dynamicHeaders[HEADER_SESSION_ID] = fallbackValue;
                     dynamicHeaders[HEADER_INTERACTION_ID] = fallbackValue;
+                    if (isCron) {
+                        const cronTitle = extractCronTitle(context.messages);
+                        if (cronTitle)
+                            dynamicHeaders["x-cron-title"] = cronTitle;
+                    }
                 }
                 else {
-                    // Session mode: use pre-resolved session headers
+                    // 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}` : traceId;
+                        dynamicHeaders[HEADER_TRACE_ID] = isCron ? `cron_${traceId}${ts}` : `${traceId}${ts}`;
+                        if (isCron) {
+                            const cronTitle = extractCronTitle(context.messages);
+                            if (cronTitle)
+                                dynamicHeaders["x-cron-title"] = cronTitle;
+                        }
                     }
                     if (typeof sessionId === "string")
                         dynamicHeaders[HEADER_SESSION_ID] = sessionId;
@@ -314,6 +380,7 @@ export const xiaoyiProvider = {
             if (context.systemPrompt) {
                 console.log(`[xiaoyiprovider] system prompt length: ${context.systemPrompt.length}`);
             }
+            const sessionCtx = getCurrentSessionContext();
             // 在发送给模型前，优化 systemPrompt 结构
             if (context.systemPrompt) {
                 let sp = context.systemPrompt;
@@ -343,8 +410,17 @@ export const xiaoyiProvider = {
                 console.log(`[xiaoyiprovider] system prompt optimized: ${beforeLen} -> ${sp.length}`);
                 context.systemPrompt = sp;
             }
+            const selfEvolutionEnabled = await selfEvolutionManager.isEnabled();
+            const prompt = stripSelfEvolutionPrompt(context.systemPrompt ?? "");
+            context.systemPrompt = [
+                prompt,
+                selfEvolutionEnabled
+                    ? SELF_EVOLUTION_ENABLED_PROMPT_SECTION
+                    : SELF_EVOLUTION_DISABLED_PROMPT_SECTION,
+            ]
+                .filter(Boolean)
+                .join("\n\n");
             // Append device context to systemPrompt
-            const sessionCtx = getCurrentSessionContext();
             if (sessionCtx?.deviceType) {
                 const rawDevice = sessionCtx.deviceType;
                 const displayDevice = (rawDevice === "2in1") ? "鸿蒙PC" : rawDevice;

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

@@ -1,3 +1,22 @@
-import type { PluginHookBeforePromptBuildEvent, PluginHookBeforePromptBuildResult, PluginHookAgentContext } from "openclaw/plugins/hooks.js";
+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

@@ -3,18 +3,22 @@ const TOOL_RETRIEVER_HEADER = `## 用户查询相关skill列表如下：
 
 `;
 const TOOL_RETRIEVER_FOOTER = `
-以上是检索到的、与当前查询相关但用户尚未安装的 skill，优先推荐强相关的 skill（通用兜底工具如 web-search、xiaoyi-gui-agent 仅在无强相关skill时调用）。
-对于强相关skill，你需要主动提醒用户可以考虑安装，但禁止直接给用户安装。用户明确希望安装后，使用find-skill执行安装。
-若用户已有的skill已能很好地完成当前任务，则无需提醒安装功能相似的skill。
+以上是检索到的、与当前查询相关但用户尚未安装的skill，请按照以下规则判断是否需要推荐：
+1.判断用户当前请求的意图类型：
+-若用户请求为查询已有信息、查看状态、执行已有功能或进行常规操作（例如查看定时任务列表），且这些操作无需额外skill即可完成，则不推荐任何skill。
+2.仅在以下条件全部满足时，才考虑推荐skill：
+-用户请求明确表示需要完成某个具体任务；
+-现有能力（包括已安装的skill或系统自带功能）不足以满足该任务。此时，优先推荐与任务强相关的skill。
+3.对于强相关且用户尚未安装的skill：
+-可主动提醒用户考虑安装，但禁止直接安装；
+-用户明确同意后，使用find-skills执行安装。
+4.若用户已安装的skill已能很好地完成当前任务，即使存在功能相似的未安装skill，也无需提醒。
 ---以下是用户原始请求---
 `;
 const PLUGIN_LOG_PREFIX = "[skill-retriever]";
-const SKIP_KEYWORDS = ["安装", "装一下", "下载", "查询", "查找", "install", "卸载", "删除", "重载"];
+const SKIP_KEYWORDS = ["安装", "装一下", "下载", "查询", "查找", "install", "卸载", "删除", "重载", "定时任务", "重装"];
 const SKIP_PATTERNS = [
-    "/new",
-    "/reset",
-    "session was started",
-    "a new session was started",
+    "/new", "/reset", "/compact", "/stop", "/think", "/model", "/fast", "/verbose", "/config", "/debug", "/status", "/tasks", "/whoami", "/context", "/skill", "/commands", "/tools"
 ];
 function shouldSkipSearch(prompt) {
     const trimmedPrompt = prompt.trim();
@@ -38,30 +42,22 @@ 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,
@@ -74,16 +70,14 @@ export function createBeforePromptBuildHandler(config) {
                 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}"`);
+                console.log(`${PLUGIN_LOG_PREFIX} [ERROR] Failed to format skills context`);
                 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,
             };

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

@@ -81,7 +81,6 @@ 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;
@@ -89,7 +88,6 @@ export async function searchTools(options) {
         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 = {
@@ -101,7 +99,6 @@ export async function searchTools(options) {
         "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",
@@ -119,13 +116,9 @@ export async function searchTools(options) {
             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`);

package/dist/src/tools/save-self-evolution-skill-tool.d.ts

@@ -0,0 +1 @@
+export declare const saveSelfEvolutionSkillTool: any;

package/dist/src/tools/save-self-evolution-skill-tool.js

@@ -0,0 +1,189 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { selfEvolutionManager } from "../utils/self-evolution-manager.js";
+const SELF_EVOLVED_SKILL_ROOT = "/home/sandbox/.openclaw/workspace/skills";
+function slugifyTitle(title) {
+    return title
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+}
+function normalizeStringArray(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => (typeof item === "string" ? item.trim() : ""))
+            .filter(Boolean);
+    }
+    if (typeof value === "string" && value.trim()) {
+        return [value.trim()];
+    }
+    return [];
+}
+function containsSensitiveContent(text) {
+    const lower = text.toLowerCase();
+    const sensitivePatterns = [
+        /api[_ -]?key/u,
+        /access[_ -]?token/u,
+        /bearer\s+[a-z0-9._-]+/iu,
+        /password/u,
+        /secret/u,
+        /\/home\/sandbox\//u,
+        /\/tmp\//u,
+        /[a-z]:\\/iu,
+    ];
+    return sensitivePatterns.some((pattern) => pattern.test(lower));
+}
+function buildSkillMarkdown(params) {
+    const description = `${params.summary}\n\nWhen to use: ${params.whenToUse}`
+        .replace(/"/g, '\\"')
+        .replace(/\r?\n/g, "\\n");
+    const lines = [
+        "---",
+        `name: "${params.title.replace(/"/g, '\\"')}"`,
+        `description: "${description}"`,
+        "---",
+        "",
+        `# ${params.title}`,
+        "",
+        "## Rules",
+    ];
+    for (const rule of params.rules) {
+        lines.push(`- ${rule}`);
+    }
+    if (params.examples.length > 0) {
+        lines.push("", "## Examples");
+        for (const example of params.examples) {
+            lines.push(`- ${example}`);
+        }
+    }
+    if (params.tags.length > 0) {
+        lines.push("", "## Tags", params.tags.map((tag) => `- ${tag}`).join("\n"));
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+export const saveSelfEvolutionSkillTool = {
+    name: "save_self_evolution_skill",
+    label: "Save Self Evolution Skill",
+    description: "将可复用的经验/脚本/教训等保存为skill技能，供下次执行类似任务时参考。仅用于通用、可复用的场景。",
+    parameters: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "所学技能的简短、可复用标题。",
+            },
+            summary: {
+                type: "string",
+                description: "技能的概括性总结，不要太长。",
+            },
+            when_to_use: {
+                type: "string",
+                description: "描述在未来任务中什么情况/哪些条件下使用此技能。",
+            },
+            rules: {
+                type: "array",
+                items: { type: "string" },
+                description: "具体、可复用的规则或checklist。",
+            },
+            examples: {
+                type: "array",
+                items: { type: "string" },
+                description: "陷阱示例以及正确模式示例，可选",
+            },
+            tags: {
+                type: "array",
+                items: { type: "string" },
+                description: "用于未来发现的标签，可选。",
+            },
+        },
+        required: ["title", "summary", "when_to_use", "rules"],
+    },
+    async execute(_toolCallId, params) {
+        if (!(await selfEvolutionManager.isEnabled())) {
+            throw new Error("Self-evolution is currently disabled by the user.");
+        }
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. This tool can only run during an active conversation.");
+        }
+        const title = typeof params.title === "string" ? params.title.trim() : "";
+        const summary = typeof params.summary === "string" ? params.summary.trim() : "";
+        const whenToUse = typeof params.when_to_use === "string" ? params.when_to_use.trim() : "";
+        const rules = normalizeStringArray(params.rules);
+        const examples = normalizeStringArray(params.examples);
+        const tags = normalizeStringArray(params.tags);
+        if (!title || !summary || !whenToUse || rules.length === 0) {
+            throw new Error("Missing required fields. title, summary, when_to_use, and at least one rule are required.");
+        }
+        if (title.length < 6 || summary.length < 10 || whenToUse.length < 10) {
+            throw new Error("Skill content is too short. Provide a reusable title, summary, and usage guidance.");
+        }
+        const combinedText = [title, summary, whenToUse, ...rules, ...examples, ...tags].join("\n");
+        if (containsSensitiveContent(combinedText)) {
+            throw new Error("Skill content appears to contain sensitive or environment-specific data and was rejected.");
+        }
+        const slug = slugifyTitle(title);
+        if (!slug) {
+            throw new Error("Title could not be normalized into a valid skill name.");
+        }
+        const skillDir = path.join(SELF_EVOLVED_SKILL_ROOT, `evolving-${slug}`);
+        const skillFilePath = path.join(skillDir, "SKILL.md");
+        const nextContent = buildSkillMarkdown({
+            title,
+            summary,
+            whenToUse,
+            rules,
+            examples,
+            tags,
+        });
+        const nextHash = createHash("sha256").update(nextContent).digest("hex");
+        await fs.mkdir(skillDir, { recursive: true });
+        try {
+            const existingContent = await fs.readFile(skillFilePath, "utf-8");
+            const existingHash = createHash("sha256").update(existingContent).digest("hex");
+            if (existingHash === nextHash) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                deduped: true,
+                                skillName: slug,
+                                path: skillFilePath,
+                                message: "An identical self-evolved skill already exists.",
+                            }),
+                        },
+                    ],
+                };
+            }
+            throw new Error(`A different skill with the same title already exists: ${skillFilePath}`);
+        }
+        catch (error) {
+            if (error?.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        await fs.writeFile(skillFilePath, nextContent, "utf-8");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        deduped: false,
+                        skillName: slug,
+                        path: skillFilePath,
+                        sessionId: sessionContext.sessionId,
+                        message: "Self-evolved skill saved successfully.",
+                    }),
+                },
+            ],
+        };
+    },
+};

package/dist/src/tools/session-manager.js

@@ -2,6 +2,7 @@
 // Stores active session contexts that tools can access
 import { AsyncLocalStorage } from "async_hooks";
 import { configManager } from "../utils/config-manager.js";
+import { toolCallNudgeManager } from "../utils/tool-call-nudge-manager.js";
 import { getCurrentTaskId, getCurrentMessageId } from "../task-manager.js";
 // Map of sessionKey -> SessionContextWithRef
 const activeSessions = new Map();
@@ -40,6 +41,7 @@ export function unregisterSession(sessionKey) {
     if (existing.refCount <= 0) {
         activeSessions.delete(sessionKey);
         configManager.clearSession(existing.sessionId);
+        toolCallNudgeManager.clearSession(sessionKey);
     }
 }
 /**

package/dist/src/utils/self-evolution-manager.d.ts

@@ -0,0 +1,5 @@
+declare class SelfEvolutionManager {
+    isEnabled(): Promise<boolean>;
+}
+export declare const selfEvolutionManager: SelfEvolutionManager;
+export {};

package/dist/src/utils/self-evolution-manager.js

@@ -0,0 +1,47 @@
+import fs from "node:fs/promises";
+const SELF_EVOLUTION_ENV_FILE = "/home/sandbox/.openclaw/.xiaoyienv";
+const SELF_EVOLUTION_ENV_KEY = "selfEvolutionState";
+function parseBooleanLike(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true") {
+        return true;
+    }
+    if (normalized === "false") {
+        return false;
+    }
+    return null;
+}
+class SelfEvolutionManager {
+    async isEnabled() {
+        try {
+            const envData = await fs.readFile(SELF_EVOLUTION_ENV_FILE, "utf-8");
+            for (const line of envData.split(/\r?\n/u)) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith("#")) {
+                    continue;
+                }
+                const eqIndex = trimmed.indexOf("=");
+                if (eqIndex === -1) {
+                    continue;
+                }
+                const key = trimmed.slice(0, eqIndex).trim();
+                if (key !== SELF_EVOLUTION_ENV_KEY) {
+                    continue;
+                }
+                const value = trimmed.slice(eqIndex + 1).trim();
+                const parsed = parseBooleanLike(value);
+                if (parsed !== null) {
+                    return parsed;
+                }
+            }
+            return false;
+        }
+        catch (error) {
+            if (error?.code !== "ENOENT") {
+                console.error(`[SELF_EVOLUTION] Failed to read ${SELF_EVOLUTION_ENV_FILE}:`, error);
+            }
+            return false;
+        }
+    }
+}
+export const selfEvolutionManager = new SelfEvolutionManager();

package/dist/src/utils/tool-call-nudge-manager.d.ts

@@ -0,0 +1,14 @@
+type RecordToolCallResult = {
+    count: number;
+    shouldNudge: boolean;
+};
+declare class ToolCallNudgeManager {
+    private readonly threshold;
+    private readonly sessions;
+    constructor(threshold?: number);
+    recordToolCall(sessionKey: string): RecordToolCallResult;
+    clearSession(sessionKey: string): void;
+}
+export declare const TOOL_CALL_NUDGE_THRESHOLD = 5;
+export declare const toolCallNudgeManager: ToolCallNudgeManager;
+export {};

package/dist/src/utils/tool-call-nudge-manager.js

@@ -0,0 +1,35 @@
+const DEFAULT_TOOL_CALL_NUDGE_THRESHOLD = 5;
+class ToolCallNudgeManager {
+    threshold;
+    sessions = new Map();
+    constructor(threshold = DEFAULT_TOOL_CALL_NUDGE_THRESHOLD) {
+        this.threshold = threshold;
+    }
+    recordToolCall(sessionKey) {
+        let state = this.sessions.get(sessionKey);
+        if (!state) {
+            state = {
+                count: 0,
+                nudged: false,
+            };
+            this.sessions.set(sessionKey, state);
+        }
+        state.count += 1;
+        if (!state.nudged && state.count >= this.threshold) {
+            state.nudged = true;
+            return {
+                count: state.count,
+                shouldNudge: true,
+            };
+        }
+        return {
+            count: state.count,
+            shouldNudge: false,
+        };
+    }
+    clearSession(sessionKey) {
+        this.sessions.delete(sessionKey);
+    }
+}
+export const TOOL_CALL_NUDGE_THRESHOLD = DEFAULT_TOOL_CALL_NUDGE_THRESHOLD;
+export const toolCallNudgeManager = new ToolCallNudgeManager();

package/dist/src/websocket.js

@@ -354,12 +354,11 @@ export class XYWebSocketManager extends EventEmitter {
             if (parsed.jsonrpc === "2.0") {
                 const a2aRequest = parsed;
                 // Extract sessionId from params
-                // const sessionId = a2aRequest.params?.sessionId;
-                // if (!sessionId) {
-                //   console.error("[XY] Message missing sessionId");
-                //   return;
-                // }
-                const sessionId = "111111";
+                const sessionId = a2aRequest.params?.sessionId;
+                if (!sessionId) {
+                    console.error("[XY] Message missing sessionId");
+                    return;
+                }
                 // Check if message contains only data parts (tool results)
                 const dataParts = a2aRequest.params?.message?.parts?.filter((p) => p.kind === "data");
                 const hasOnlyDataParts = dataParts && dataParts.length > 0 &&

package/package.json

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