@ynhcj/xiaoyi-channel 0.0.99-beta → 0.0.101-beta

package/dist/index.js

@@ -5,9 +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.
@@ -25,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;
             }

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/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;
@@ -236,6 +237,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.
  */
@@ -344,6 +378,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;
@@ -373,8 +408,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/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/package.json

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