@ynhcj/xiaoyi-channel 0.0.104-beta → 0.0.106-beta

package/dist/index.js

@@ -8,35 +8,50 @@ import { extractResultText, processText, parseSecurityResult, validateAndTruncat
 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";
-const SELF_EVOLUTION_NUDGE_MESSAGE = "[系统消息，非用户发言，不需要告知用户] 当前任务已经调用了较多工具。如果你识别到其中存在稳定、可复用的踩坑经验或排错模式，可以在完成当前主要任务后，正式回复用户前，阅读xiaoyi-self-evolution技能了解自进化规则。注意，不要打断当前主任务，已完成任务为最高优先级。";
-const SELF_EVOLUTION_KEYWORD_NUDGE_MESSAGE = "[系统消息，非用户发言，不需要告知用户] 当前用户请求中可能包含希望沉淀经验、避免重复踩坑的意图。如果你已经从当前问题中识别出稳定、可复用的处理规则或排错经验，可以在完成当前主要任务后，正式回复用户前，阅读xiaoyi-self-evolution技能了解自进化规则。注意，不要打断当前主任务，已完成任务为最高优先级。";
+const SELF_EVOLUTION_NUDGE_MESSAGE = "[系统消息，非用户发言，无需主动告知用户] 当前任务已经调用了较多次数的工具。如果你识别到其中存在可复用的解决方法或踩坑经验等，可以在完成当前主要任务后，正式回复用户前，阅读xiaoyi-self-evolution技能了解自进化规则。注意，不要打断当前主任务，以完成任务为最高优先级。";
+const SELF_EVOLUTION_KEYWORD_NUDGE_MESSAGE = "[系统消息，非用户发言，无需主动告知用户] 当前用户请求中可能包含用户长期偏好、行为纠正意图、经验沉淀需求。如果你已经从当前问题中识别出稳定、可复用的处理规则或排错经验，或者用户表达了明显的具备长期约束力的纠错与反馈，可以在完成当前主要任务后，正式回复用户前，阅读xiaoyi-self-evolution技能了解自进化规则。注意，不要打断当前主任务，以完成任务为最高优先级。";
 const SELF_EVOLUTION_KEYWORD_PATTERNS = [
     /进化/u,
+    /沉淀/u,
     /记住/u,
-    /永远/u,
-    /下次必须/u,
-    /沉淀为/u,
-    /总结为/u,
-    /归纳为/u,
-    /以后(?:不要再犯|别再犯|必须|注意|记住)/u,
-    /记住这个坑/u,
-    /避免下次/u,
-    /别再踩坑/u,
-    /不要再踩坑/u,
-    /下次(?:别再|不要再)/u,
-    /以后(?:别再|不要再)(?:出错|犯错|漏掉|踩坑)/u,
-    /这个坑要记住/u,
-    /记住这次(?:教训|经验|问题)/u,
-    /吸取这次(?:教训|经验)/u,
-    /总结(?:一下)?这个坑/u,
-    /把这个(?:经验|教训|规则)记住/u,
-    /以后按这个规则/u,
+    /记下来/u,
+    /记一下/u,
+    /长期记住/u,
+    /永久记住/u,
+    /永远记住/u,
+    /形成规范/u,
+    /固化下来/u,
+    /固定下来/u,
+    /记成规则/u,
+    /纳入经验/u,
+    /写入经验/u,
+    /沉淀成(?:经验|规则|规范|流程)/u,
+    /总结成(?:经验|规则|规范|流程|步骤)/u,
+    /归纳成(?:经验|规则|规范|流程)/u,
+    /提炼成(?:经验|规则|规范|流程)/u,
     /以后都按这个来/u,
-    /以后遇到这种情况/u,
-    /类似情况(?:下)?不要再/u,
-    /这种问题下次不能再出现/u,
-    /永远不要再(?:犯|踩|漏)/u,
-    /永远记住这次(?:教训|经验)/u,
+    /下次都这样处理/u,
+    /以后统一这样/u,
+    /后面都这样/u,
+    /后续按这个(?:规范|流程|模板|方案)/u,
+    /以后(?:遇到|碰到)这种情况/u,
+    /类似(?:问题|情况|场景)都这样处理/u,
+    /避免(?:再次|以后|下次)/u,
+    /避免再(?:犯|错|踩坑|出错)/u,
+    /防止以后再犯/u,
+    /别再(?:出错|犯错|踩坑|漏掉|忘记)/u,
+    /不要再(?:出错|犯错|踩坑|漏掉|忘记)/u,
+    /下次别再/u,
+    /以后不要再/u,
+    /以后别再/u,
+    /这个坑(?:要)?记住/u,
+    /吸取这次(?:教训|经验)/u,
+    /(?:以后|下次|后续|之后)(?:都|统一|默认|应该|要|就)?(?:按这个|这样|这么)(?:来|做|处理|执行)/u,
+    /(?:以后|下次|后续|之后)(?:遇到|碰到)(?:类似)?(?:问题|情况|场景)(?:时)?(?:都|就)?(?:按这个|这样|这么)(?:来|做|处理|执行)/u,
+    /(?:别再|不要再|避免)(?:犯错|出错|踩坑|漏掉|遗漏|忘记)/u,
+    /(?:总结|归纳|提炼|沉淀|复盘)(?:一下)?(?:这次|这个)?(?:经验|教训|问题|规则|规范|流程)?/u,
+    /(?:把)?这次(?:经验|教训|规则|做法)(?:记住|记下来|沉淀下来|固化下来)/u,
+    /(?:形成|整理成|沉淀成|提炼成)(?:一套)?(?:规则|规范|流程|步骤|最佳实践)/u,
 ];
 function shouldCountToolCall(toolName) {
     if (toolName === "save_self_evolution_skill") {

package/dist/src/provider.js

@@ -11,8 +11,8 @@ 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 = 4;
+const RETRY_DELAYS_MS = [10_000, 20_000, 40_000, 60_000, 60_000];
+const MAX_RETRY_ATTEMPTS = 5;
 /** Check if an errorMessage indicates a retryable provider error by type. */
 function isRetryableProviderError(message) {
     if (!message)

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

@@ -4,6 +4,7 @@ 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";
+const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/u;
 function slugifyTitle(title) {
     return title
         .trim()
@@ -23,19 +24,141 @@ function normalizeStringArray(value) {
     }
     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,
+function normalizeWhitespace(text) {
+    return text.replace(/\s+/gu, " ").trim();
+}
+function normalizeForFingerprint(text) {
+    return normalizeWhitespace(text)
+        .toLowerCase()
+        .replace(/[`"'()[\]{}:;,.!?]/gu, "")
+        .replace(/\s+/gu, " ")
+        .trim();
+}
+function normalizeForComparison(items) {
+    return items
+        .map((item) => normalizeForFingerprint(item))
+        .filter(Boolean)
+        .sort();
+}
+function sanitizeLine(text) {
+    let value = text;
+    let changed = false;
+    const replacements = [
+        [/(bearer\s+)[a-z0-9._=-]{12,}/giu, "$1[REDACTED_TOKEN]"],
+        [/((?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|password|secret)\s*[:=]\s*)([^\s,;]+)/giu, "$1[REDACTED_SECRET]"],
+        [/(-----BEGIN [A-Z ]*PRIVATE KEY-----)[\s\S]*?(-----END [A-Z ]*PRIVATE KEY-----)/gu, "$1\n[REDACTED_PRIVATE_KEY]\n$2"],
+        [/\b(?:[a-zA-Z]:\\(?:[^\\\r\n]+\\)*[^\\\r\n\s]+|\/(?:home|Users|tmp|var|private|etc)\/[^\s"'`<>]+)/gu, "[REDACTED_PATH]"],
+        [/\b(sk-[a-zA-Z0-9]{16,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z\-_]{20,})\b/gu, "[REDACTED_SECRET]"],
+    ];
+    for (const [pattern, replacement] of replacements) {
+        const next = value.replace(pattern, replacement);
+        if (next !== value) {
+            value = next;
+            changed = true;
+        }
+    }
+    return { value, changed };
+}
+function sanitizeStringArray(values) {
+    let changed = false;
+    const sanitized = values.map((value) => {
+        const result = sanitizeLine(value);
+        changed = changed || result.changed;
+        return result.value;
+    });
+    return { values: sanitized, changed };
+}
+function sanitizeSkillContent(params) {
+    const titleResult = sanitizeLine(params.title);
+    const summaryResult = sanitizeLine(params.summary);
+    const whenToUseResult = sanitizeLine(params.whenToUse);
+    const supplementResult = sanitizeLine(params.supplement);
+    const rulesResult = sanitizeStringArray(params.rules);
+    const examplesResult = sanitizeStringArray(params.examples);
+    const tagsResult = sanitizeStringArray(params.tags);
+    return {
+        title: titleResult.value,
+        summary: summaryResult.value,
+        whenToUse: whenToUseResult.value,
+        supplement: supplementResult.value,
+        rules: rulesResult.values,
+        examples: examplesResult.values,
+        tags: tagsResult.values,
+        changed: titleResult.changed ||
+            summaryResult.changed ||
+            whenToUseResult.changed ||
+            supplementResult.changed ||
+            rulesResult.changed ||
+            examplesResult.changed ||
+            tagsResult.changed,
+    };
+}
+function containsHighlySensitiveContent(text) {
+    const highRiskPatterns = [
+        /-----BEGIN [A-Z ]*PRIVATE KEY-----/u,
+        /bearer\s+[a-z0-9._=-]{12,}/iu,
+        /\b(?:sk-[a-zA-Z0-9]{16,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z\-_]{20,})\b/u,
+        /(?:api[_ -]?key|access[_ -]?token|refresh[_ -]?token|password|secret)\s*[:=]\s*[^\s,;]{8,}/iu,
     ];
-    return sensitivePatterns.some((pattern) => pattern.test(lower));
+    return highRiskPatterns.some((pattern) => pattern.test(text));
+}
+function buildSkillFingerprint(params) {
+    const normalized = {
+        title: normalizeForFingerprint(params.title),
+        summary: normalizeForFingerprint(params.summary),
+        whenToUse: normalizeForFingerprint(params.whenToUse),
+        supplement: normalizeForFingerprint(params.supplement),
+        rules: normalizeForComparison(params.rules),
+        examples: normalizeForComparison(params.examples),
+        tags: normalizeForComparison(params.tags),
+    };
+    return createHash("sha256").update(JSON.stringify(normalized)).digest("hex");
+}
+function parseFrontmatterValue(content, key) {
+    const match = content.match(new RegExp(`^${key}:\\s*"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"`, "m"));
+    if (match) {
+        return match[1].replace(/\\"/g, '"').replace(/\\n/g, "\n");
+    }
+    return null;
+}
+function parseTimestampFromExistingSkill(content, key) {
+    const value = parseFrontmatterValue(content, key);
+    if (!value) {
+        return null;
+    }
+    return ISO_DATE_PATTERN.test(value) ? value : null;
+}
+async function findDuplicateSkillByFingerprint(targetFingerprint) {
+    try {
+        const entries = await fs.readdir(SELF_EVOLVED_SKILL_ROOT, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || !entry.name.startsWith("evolving-")) {
+                continue;
+            }
+            const skillFilePath = path.join(SELF_EVOLVED_SKILL_ROOT, entry.name, "SKILL.md");
+            try {
+                const existingContent = await fs.readFile(skillFilePath, "utf-8");
+                const fingerprint = parseFrontmatterValue(existingContent, "fingerprint");
+                if (fingerprint && fingerprint === targetFingerprint) {
+                    return {
+                        path: skillFilePath,
+                        slug: entry.name.replace(/^evolving-/u, ""),
+                    };
+                }
+            }
+            catch (error) {
+                if (error?.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (error?.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    return null;
 }
 function buildSkillMarkdown(params) {
     const description = `${params.summary}\n\nWhen to use: ${params.whenToUse}`
@@ -45,12 +168,17 @@ function buildSkillMarkdown(params) {
         "---",
         `name: "${params.title.replace(/"/g, '\\"')}"`,
         `description: "${description}"`,
-        "---",
-        "",
-        `# ${params.title}`,
-        "",
-        "## Rules",
+        `fingerprint: "${params.fingerprint}"`,
+        `created_at: "${params.createdAt}"`,
     ];
+    if (params.updatedAt) {
+        lines.push(`updated_at: "${params.updatedAt}"`);
+    }
+    lines.push("---", "", `# ${params.title}`, "", "## Metadata", `- Created At: ${params.createdAt}`);
+    if (params.updatedAt) {
+        lines.push(`- Updated At: ${params.updatedAt}`);
+    }
+    lines.push("", "## Rules");
     for (const rule of params.rules) {
         lines.push(`- ${rule}`);
     }
@@ -60,6 +188,9 @@ function buildSkillMarkdown(params) {
             lines.push(`- ${example}`);
         }
     }
+    if (params.supplement) {
+        lines.push("", "## Supplement", params.supplement);
+    }
     if (params.tags.length > 0) {
         lines.push("", "## Tags", params.tags.map((tag) => `- ${tag}`).join("\n"));
     }
@@ -75,7 +206,7 @@ export const saveSelfEvolutionSkillTool = {
         properties: {
             title: {
                 type: "string",
-                description: "所学技能的简短、可复用标题。",
+                description: "所学技能的简短标题。**必须为英文，可用下划线或中划线分割。**",
             },
             summary: {
                 type: "string",
@@ -83,7 +214,7 @@ export const saveSelfEvolutionSkillTool = {
             },
             when_to_use: {
                 type: "string",
-                description: "描述在未来任务中什么情况/哪些条件下使用此技能。",
+                description: "描述在未来任务中什么情况/哪些条件下使用此技能，描述尽量精准。",
             },
             rules: {
                 type: "array",
@@ -93,13 +224,17 @@ export const saveSelfEvolutionSkillTool = {
             examples: {
                 type: "array",
                 items: { type: "string" },
-                description: "陷阱示例以及正确模式示例，可选",
+                description: "陷阱示例或正确模式示例，可选",
             },
             tags: {
                 type: "array",
                 items: { type: "string" },
                 description: "用于未来发现的标签，可选。",
             },
+            supplement: {
+                type: "string",
+                description: "补充说明。将其他想补充但不属于固定字段的内容放在这里。可选。",
+            },
         },
         required: ["title", "summary", "when_to_use", "rules"],
     },
@@ -114,32 +249,114 @@ export const saveSelfEvolutionSkillTool = {
         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) {
+        const supplement = typeof params.supplement === "string" ? params.supplement.trim() : "";
+        const rawRules = normalizeStringArray(params.rules);
+        const rawExamples = normalizeStringArray(params.examples);
+        const rawTags = normalizeStringArray(params.tags);
+        if (!title || !summary || !whenToUse || rawRules.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)) {
+        const sanitized = sanitizeSkillContent({
+            title,
+            summary,
+            whenToUse,
+            supplement,
+            rules: rawRules,
+            examples: rawExamples,
+            tags: rawTags,
+        });
+        const combinedText = [
+            sanitized.title,
+            sanitized.summary,
+            sanitized.whenToUse,
+            sanitized.supplement,
+            ...sanitized.rules,
+            ...sanitized.examples,
+            ...sanitized.tags,
+        ].join("\n");
+        if (containsHighlySensitiveContent(combinedText)) {
             throw new Error("Skill content appears to contain sensitive or environment-specific data and was rejected.");
         }
-        const slug = slugifyTitle(title);
+        const slug = slugifyTitle(sanitized.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 fingerprint = buildSkillFingerprint({
+            title: sanitized.title,
+            summary: sanitized.summary,
+            whenToUse: sanitized.whenToUse,
+            supplement: sanitized.supplement,
+            rules: sanitized.rules,
+            examples: sanitized.examples,
+            tags: sanitized.tags,
+        });
+        const duplicateSkill = await findDuplicateSkillByFingerprint(fingerprint);
+        if (duplicateSkill && duplicateSkill.path !== skillFilePath) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            deduped: true,
+                            sanitized: sanitized.changed,
+                            skillName: duplicateSkill.slug,
+                            path: duplicateSkill.path,
+                            message: "A semantically identical self-evolved skill already exists.",
+                        }),
+                    },
+                ],
+            };
+        }
+        const nowIso = new Date().toISOString();
+        let createdAt = nowIso;
+        let updatedAt;
+        try {
+            const existingContent = await fs.readFile(skillFilePath, "utf-8");
+            const existingFingerprint = parseFrontmatterValue(existingContent, "fingerprint");
+            const existingCreatedAt = parseTimestampFromExistingSkill(existingContent, "created_at");
+            createdAt = existingCreatedAt ?? nowIso;
+            if (existingFingerprint === fingerprint) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                deduped: true,
+                                sanitized: sanitized.changed,
+                                skillName: slug,
+                                path: skillFilePath,
+                                createdAt,
+                                message: "An identical self-evolved skill already exists.",
+                            }),
+                        },
+                    ],
+                };
+            }
+            updatedAt = nowIso;
+        }
+        catch (error) {
+            if (error?.code !== "ENOENT") {
+                throw error;
+            }
+        }
         const nextContent = buildSkillMarkdown({
-            title,
-            summary,
-            whenToUse,
-            rules,
-            examples,
-            tags,
+            title: sanitized.title,
+            summary: sanitized.summary,
+            whenToUse: sanitized.whenToUse,
+            supplement: sanitized.supplement,
+            rules: sanitized.rules,
+            examples: sanitized.examples,
+            tags: sanitized.tags,
+            fingerprint,
+            createdAt,
+            updatedAt,
         });
         const nextHash = createHash("sha256").update(nextContent).digest("hex");
         await fs.mkdir(skillDir, { recursive: true });
@@ -154,15 +371,16 @@ export const saveSelfEvolutionSkillTool = {
                             text: JSON.stringify({
                                 success: true,
                                 deduped: true,
+                                sanitized: sanitized.changed,
                                 skillName: slug,
                                 path: skillFilePath,
+                                createdAt,
                                 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") {
@@ -177,10 +395,15 @@ export const saveSelfEvolutionSkillTool = {
                     text: JSON.stringify({
                         success: true,
                         deduped: false,
+                        sanitized: sanitized.changed,
                         skillName: slug,
                         path: skillFilePath,
                         sessionId: sessionContext.sessionId,
-                        message: "Self-evolved skill saved successfully.",
+                        createdAt,
+                        updatedAt,
+                        message: updatedAt
+                            ? "Self-evolved skill updated successfully."
+                            : "Self-evolved skill saved successfully.",
                     }),
                 },
             ],

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

@@ -11,6 +11,6 @@ declare class ToolCallNudgeManager {
     tryMarkKeywordNudge(sessionKey: string): boolean;
     clearSession(sessionKey: string): void;
 }
-export declare const TOOL_CALL_NUDGE_THRESHOLD = 5;
+export declare const TOOL_CALL_NUDGE_THRESHOLD = 6;
 export declare const toolCallNudgeManager: ToolCallNudgeManager;
 export {};

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

@@ -1,4 +1,4 @@
-const DEFAULT_TOOL_CALL_NUDGE_THRESHOLD = 5;
+const DEFAULT_TOOL_CALL_NUDGE_THRESHOLD = 6;
 class ToolCallNudgeManager {
     threshold;
     sessions = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.104-beta",
+  "version": "0.0.106-beta",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,7 +16,7 @@
     "openclaw.plugin.json"
   ],
   "scripts": {
-    "build": "tsc"
+    "build": "node ./node_modules/typescript/bin/tsc"
   },
   "keywords": [
     "openclaw",