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

package/dist/src/tools/save-file-to-phone-tool.js

@@ -0,0 +1,166 @@
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentSessionContext } from "./session-manager.js";
+import { XYFileUploadService } from "../file-upload.js";
+/**
+ * Duck-typed ToolInputError: openclaw 按 .name 字段匹配，不用 instanceof。
+ * 抛出此错误会让 openclaw 返回 HTTP 400 而非 500，
+ * LLM 会将其识别为参数错误而非瞬时故障，不会触发重试。
+ */
+class ToolInputError extends Error {
+    status = 400;
+    constructor(message) {
+        super(message);
+        this.name = "ToolInputError";
+    }
+}
+/**
+ * XY save file to phone tool - saves files to user's device file manager.
+ * Supports local file paths (auto-uploaded to get public URL) and public URLs.
+ */
+export const saveFileToPhoneTool = {
+    name: "save_file_to_file_manager",
+    label: "Save File to Phone",
+    description: `将文件保存到手机文件管理器。
+
+  注意:
+  a. 操作超时时间为60秒,请勿重复调用此工具
+  b. 如果遇到各类调用失败场景,不可以重试，直接返回错误。
+  c. 调用工具前需认真检查调用参数是否满足工具要求
+
+  回复约束：如果工具返回没有授权或者其他报错，只需要完整描述没有授权或者其他报错内容即可，不需要主动给用户提供解决方案，例如告诉用户如何授权，如何解决报错等都是不需要的，请严格遵守。
+  `,
+    parameters: {
+        type: "object",
+        properties: {
+            fileName: {
+                type: "string",
+                description: "必填，文件名称。",
+            },
+            url: {
+                type: "string",
+                description: "必填，支持本地路径或者公网url路径。如果是本地路径会先上传获取公网url。",
+            },
+            suffix: {
+                type: "string",
+                description: "必填，文件后缀，例如 ppt、doc、pdf 等。",
+            },
+        },
+        required: ["fileName", "url", "suffix"],
+    },
+    async execute(toolCallId, params) {
+        // Validate parameters
+        const { fileName, url, suffix } = params;
+        if (!url || typeof url !== "string") {
+            throw new ToolInputError("缺少必填参数: url");
+        }
+        if (!fileName || typeof fileName !== "string") {
+            throw new ToolInputError("缺少必填参数: fileName");
+        }
+        if (!suffix || typeof suffix !== "string") {
+            throw new ToolInputError("缺少必填参数: suffix");
+        }
+        // Get session context
+        const sessionContext = getCurrentSessionContext();
+        if (!sessionContext) {
+            throw new Error("No active XY session found. SaveFileToFileManager tool can only be used during an active conversation.");
+        }
+        const { config, sessionId, taskId, messageId } = sessionContext;
+        // Get WebSocket manager
+        const wsManager = getXYWebSocketManager(config);
+        // Determine the URL: if it's a local path, upload first to get public URL
+        let publicUrl = url;
+        if (!url.startsWith("http://") && !url.startsWith("https://")) {
+            // Local file path - upload to get public URL
+            const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+            publicUrl = await uploadService.uploadFileAndGetUrl(url);
+            if (!publicUrl) {
+                throw new Error("本地文件上传失败，无法获取公网URL");
+            }
+        }
+        // Build intentParam
+        const intentParam = {
+            fileName: fileName,
+            url: publicUrl,
+            suffix: suffix,
+        };
+        // Build SaveFileToFileManager command
+        const command = {
+            header: {
+                namespace: "Common",
+                name: "Action",
+            },
+            payload: {
+                cardParam: {},
+                executeParam: {
+                    executeMode: "background",
+                    intentName: "SaveFileToFileManager",
+                    bundleName: "com.huawei.hmos.vassistant",
+                    dimension: "",
+                    needUnlock: true,
+                    actionResponse: true,
+                    appType: "OHOS_APP",
+                    timeOut: 5,
+                    timeout: 55000,
+                    intentParam,
+                    permissionId: ["ohos.permission.WRITE_IMAGEVIDEO"],
+                    achieveType: "INTENT",
+                },
+                responses: [
+                    {
+                        resultCode: "",
+                        displayText: "",
+                        ttsText: "",
+                    },
+                ],
+                needUploadResult: true,
+                noHalfPage: false,
+                pageControlRelated: false,
+            },
+        };
+        // Send command and wait for response (60 second timeout)
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                wsManager.off("data-event", handler);
+                reject(new Error("保存文件到手机超时（60秒）"));
+            }, 60000);
+            // Listen for data events from WebSocket
+            const handler = (event) => {
+                if (event.intentName === "SaveFileToFileManager") {
+                    clearTimeout(timeout);
+                    wsManager.off("data-event", handler);
+                    if (event.status === "success" && event.outputs) {
+                        resolve({
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify(event.outputs),
+                                }
+                            ]
+                        });
+                    }
+                    else {
+                        reject(new Error(`保存文件到手机失败: ${event.status}`));
+                    }
+                }
+            };
+            // Register event handler
+            wsManager.on("data-event", handler);
+            // Send the command
+            sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+            })
+                .then(() => {
+            })
+                .catch((error) => {
+                clearTimeout(timeout);
+                wsManager.off("data-event", handler);
+                reject(error);
+            });
+        });
+    },
+};

package/dist/src/tools/save-media-to-gallery-tool.js

@@ -19,13 +19,9 @@ class ToolInputError extends Error {
  * Supports local file paths (auto-uploaded to get public URL) and public URLs.
  */
 export const saveMediaToGalleryTool = {
-    name: "SaveMediaToGallery",
+    name: "save_media_to_gallery",
     label: "Save Media to Gallery",
-    description: `将图片文件或者视频文件保存到手机图库。
-  工具参数说明：
-  a. mediaType：非必填，string类型，不传端侧默认为pic。支持传 pic(图片) 或 video(视频)。
-  b. fileName：非必填，string类型，文件名称，不传手机侧默认生成随机uuid。
-  c. url：必填，string类型，支持本地路径或者公网url路径。如果是本地路径，会先上传获取公网url再保存到图库。
+    description: `将图片文件或者视频文件保存到设备图库。
 
   注意:
   a. 操作超时时间为60秒,请勿重复调用此工具
@@ -47,7 +43,7 @@ export const saveMediaToGalleryTool = {
             },
             url: {
                 type: "string",
-                description: "必填，支持本地路径或者公网url路径。如果是本地路径会先上传获取公网url。",
+                description: "必填，支持本地路径或者公网url路径。如果是本地路径，会先上传获取公网url再保存到图库",
             },
         },
         required: ["url"],

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,412 @@
+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/.agents/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()
+        .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 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 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}`
+        .replace(/"/g, '\\"')
+        .replace(/\r?\n/g, "\\n");
+    const lines = [
+        "---",
+        `name: "${params.title.replace(/"/g, '\\"')}"`,
+        `description: "${description}"`,
+        `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}`);
+    }
+    if (params.examples.length > 0) {
+        lines.push("", "## Examples");
+        for (const example of params.examples) {
+            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"));
+    }
+    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: "用于未来发现的标签，可选。",
+            },
+            supplement: {
+                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 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 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(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: 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 });
+        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,
+                                sanitized: sanitized.changed,
+                                skillName: slug,
+                                path: skillFilePath,
+                                createdAt,
+                                message: "An identical self-evolved skill already exists.",
+                            }),
+                        },
+                    ],
+                };
+            }
+        }
+        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,
+                        sanitized: sanitized.changed,
+                        skillName: slug,
+                        path: skillFilePath,
+                        sessionId: sessionContext.sessionId,
+                        createdAt,
+                        updatedAt,
+                        message: updatedAt
+                            ? "Self-evolved skill updated successfully."
+                            : "Self-evolved skill saved successfully.",
+                    }),
+                },
+            ],
+        };
+    },
+};

package/dist/src/tools/schema-tool-factory.d.ts

@@ -0,0 +1,27 @@
+/**
+ * schema-tool-factory: 创建 get_xxx_tool_schema 工具。
+ * 每个工具在被 LLM 调用时，返回其所包含的子工具的 name / description / parameters schema。
+ */
+interface SchemaToolOptions {
+    name: string;
+    label: string;
+    description: string;
+    tools: any[];
+}
+export declare function createSchemaTool(options: SchemaToolOptions): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: {};
+        required: string[];
+    };
+    execute(_toolCallId: string, _params: any): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
+};
+export {};

package/dist/src/tools/schema-tool-factory.js

@@ -0,0 +1,32 @@
+/**
+ * schema-tool-factory: 创建 get_xxx_tool_schema 工具。
+ * 每个工具在被 LLM 调用时，返回其所包含的子工具的 name / description / parameters schema。
+ */
+export function createSchemaTool(options) {
+    const { name, label, description, tools } = options;
+    return {
+        name,
+        label,
+        description,
+        parameters: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+        async execute(_toolCallId, _params) {
+            const schemas = tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            }));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(schemas, null, 2),
+                    },
+                ],
+            };
+        },
+    };
+}