@ynhcj/xiaoyi-channel 1.1.26 → 1.1.28

package/dist/src/sensitive-redactor.js

@@ -0,0 +1,364 @@
+import fs from "fs";
+import path from "path";
+// 一键开关 Xiaoyi channel 的敏感信息脱敏与检测能力。
+// false 时：
+// 1. 不再读取 openclaw.json / .xiaoyienv 提取敏感值；
+// 2. 不再对消息内容做脱敏替换；
+// 3. 不再做 Base64 绕过检测；
+// 4. containsSensitiveInfo 一律返回 false。
+const ENABLE_SENSITIVE_REDACTION = true;
+let sensitiveValues = null;
+let lastLoadTime = 0;
+const CACHE_TTL_MS = 60 * 1000;
+const REDACTED_MARKER = "[execution-validator已脱敏]";
+const BASE64_CANDIDATE_RE = /(?<![A-Za-z0-9+/_-])([A-Za-z0-9+/]{12,}={0,2}|[A-Za-z0-9_-]{12,})(?![A-Za-z0-9+/_-])/g;
+const SECRET_KEYWORDS = [
+    "apikey",
+    "token",
+    "secret",
+    "password",
+    "passwd",
+    "pwd",
+    "authorization",
+    "cookie",
+    "session",
+    "signature",
+    "sign",
+];
+const ID_KEYWORDS = [
+    "agentid",
+    "apiid",
+    "uid",
+    "pushid",
+    "userid",
+    "accountid",
+    "clientid",
+    "appid",
+];
+const URL_KEYWORDS = [
+    "url",
+    "endpoint",
+];
+const PLACEHOLDER_VALUES = new Set([
+    "apikey",
+    "api-key",
+    "api_key",
+    "token",
+    "secret",
+    "password",
+    "passwd",
+    "pwd",
+    "authorization",
+    "bearer",
+    "openclaw",
+    "text/event-stream",
+]);
+function getConfigRoot() {
+    return process.env.HOME || "/home/sandbox";
+}
+function normalizeKeyName(key) {
+    return String(key ?? "").toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function normalizeValue(value) {
+    return String(value ?? "").trim();
+}
+function matchesKeyword(normalizedKey, keywords) {
+    return keywords.some(keyword => normalizedKey.includes(keyword));
+}
+function isPlaceholderValue(value) {
+    const normalized = normalizeValue(value).toLowerCase();
+    if (!normalized) {
+        return true;
+    }
+    if (PLACEHOLDER_VALUES.has(normalized)) {
+        return true;
+    }
+    if (/^(my|your|demo|test)?(apikey|token|secret|password)$/.test(normalized)) {
+        return true;
+    }
+    return false;
+}
+function looksLikeToken(value) {
+    const trimmed = normalizeValue(value);
+    if (trimmed.length < 8 || isPlaceholderValue(trimmed)) {
+        return false;
+    }
+    if (/^(sk-|sk_)[a-z0-9]/i.test(trimmed)) {
+        return true;
+    }
+    if (/^[a-f0-9]{24,}$/i.test(trimmed)) {
+        return true;
+    }
+    if (/^[A-Za-z0-9._/+\\=-]{16,}$/.test(trimmed) && /[A-Za-z]/.test(trimmed) && /\d/.test(trimmed)) {
+        return true;
+    }
+    return false;
+}
+function looksLikeIdentifier(value) {
+    const trimmed = normalizeValue(value);
+    if (trimmed.length < 6 || isPlaceholderValue(trimmed)) {
+        return false;
+    }
+    if (/^agent[a-z0-9]{8,}$/i.test(trimmed)) {
+        return true;
+    }
+    if (/^webhook[a-z0-9]{6,}$/i.test(trimmed)) {
+        return true;
+    }
+    if (/^\d{6,}$/.test(trimmed)) {
+        return true;
+    }
+    if (/^[A-Za-z][A-Za-z0-9_-]{10,}$/.test(trimmed) && /\d/.test(trimmed)) {
+        return true;
+    }
+    return false;
+}
+function looksLikeSensitiveUrl(value) {
+    const trimmed = normalizeValue(value);
+    try {
+        const parsed = new URL(trimmed);
+        if (parsed.username || parsed.password) {
+            return true;
+        }
+        for (const [name, paramValue] of parsed.searchParams.entries()) {
+            const normalizedName = normalizeKeyName(name);
+            if ((matchesKeyword(normalizedName, SECRET_KEYWORDS) || matchesKeyword(normalizedName, ID_KEYWORDS))
+                && normalizeValue(paramValue).length > 5) {
+                return true;
+            }
+        }
+        const segments = parsed.pathname.split("/").filter(Boolean);
+        return segments.some(segment => looksLikeToken(segment));
+    }
+    catch {
+        return false;
+    }
+}
+function shouldKeepSensitiveValue(key, value) {
+    const trimmed = normalizeValue(value);
+    if (trimmed.length <= 5 || isPlaceholderValue(trimmed)) {
+        return false;
+    }
+    const normalizedKey = normalizeKeyName(key);
+    if (matchesKeyword(normalizedKey, SECRET_KEYWORDS)) {
+        return looksLikeToken(trimmed) || looksLikeSensitiveUrl(trimmed);
+    }
+    if (matchesKeyword(normalizedKey, ID_KEYWORDS)) {
+        return looksLikeIdentifier(trimmed) || looksLikeToken(trimmed);
+    }
+    if (matchesKeyword(normalizedKey, URL_KEYWORDS)) {
+        return looksLikeSensitiveUrl(trimmed);
+    }
+    return looksLikeToken(trimmed);
+}
+function addSensitiveValue(values, key, value) {
+    if (shouldKeepSensitiveValue(key, value)) {
+        values.push(String(value));
+    }
+}
+function extractSensitiveValues() {
+    const values = [];
+    try {
+        const openclawJsonPath = path.join(getConfigRoot(), ".openclaw", "openclaw.json");
+        if (fs.existsSync(openclawJsonPath)) {
+            const content = fs.readFileSync(openclawJsonPath, "utf-8");
+            const config = JSON.parse(content);
+            if (config.channels) {
+                for (const channelName of Object.keys(config.channels)) {
+                    const channel = config.channels[channelName];
+                    addSensitiveValue(values, "apiKey", channel.apiKey);
+                    addSensitiveValue(values, "agentId", channel.agentId);
+                    addSensitiveValue(values, "apiId", channel.apiId);
+                    addSensitiveValue(values, "uid", channel.uid);
+                    addSensitiveValue(values, "pushId", channel.pushId);
+                    addSensitiveValue(values, "wsUrl1", channel.wsUrl1);
+                    addSensitiveValue(values, "wsUrl2", channel.wsUrl2);
+                }
+            }
+            if (config.models?.providers) {
+                for (const providerName of Object.keys(config.models.providers)) {
+                    const provider = config.models.providers[providerName];
+                    addSensitiveValue(values, "apiKey", provider.apiKey);
+                    addSensitiveValue(values, "baseUrl", provider.baseUrl);
+                    if (provider.headers) {
+                        for (const headerKey of Object.keys(provider.headers)) {
+                            addSensitiveValue(values, headerKey, provider.headers[headerKey]);
+                        }
+                    }
+                }
+            }
+            addSensitiveValue(values, "token", config.gateway?.auth?.token);
+            console.log(`[SENSITIVE_REDACTOR] Extracted ${values.length} sensitive values from openclaw.json`);
+        }
+    }
+    catch (err) {
+        console.error("[SENSITIVE_REDACTOR] Failed to read openclaw.json:", err);
+    }
+    try {
+        const xiaoyienvPath = path.join(getConfigRoot(), ".openclaw", ".xiaoyienv");
+        if (fs.existsSync(xiaoyienvPath)) {
+            const content = fs.readFileSync(xiaoyienvPath, "utf-8");
+            try {
+                const envConfig = JSON.parse(content);
+                for (const key of Object.keys(envConfig)) {
+                    addSensitiveValue(values, key, envConfig[key]);
+                }
+            }
+            catch {
+                const lines = content.split("\n");
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (trimmed && !trimmed.startsWith("#")) {
+                        const eqIndex = trimmed.indexOf("=");
+                        if (eqIndex > 0) {
+                            const key = trimmed.slice(0, eqIndex).trim();
+                            const value = trimmed.slice(eqIndex + 1).trim();
+                            addSensitiveValue(values, key, value);
+                        }
+                    }
+                }
+            }
+            console.log(`[SENSITIVE_REDACTOR] Total sensitive values after .xiaoyienv: ${values.length}`);
+        }
+    }
+    catch (err) {
+        console.error("[SENSITIVE_REDACTOR] Failed to read .xiaoyienv:", err);
+    }
+    const uniqueValues = [...new Set(values)].filter(value => typeof value === "string" && value.length > 5);
+    uniqueValues.sort((a, b) => b.length - a.length);
+    return uniqueValues;
+}
+function getSensitiveValues() {
+    if (!ENABLE_SENSITIVE_REDACTION) {
+        return [];
+    }
+    const now = Date.now();
+    if (sensitiveValues === null || now - lastLoadTime > CACHE_TTL_MS) {
+        sensitiveValues = extractSensitiveValues();
+        lastLoadTime = now;
+    }
+    return sensitiveValues;
+}
+export function refreshSensitivePatterns() {
+    sensitiveValues = null;
+    lastLoadTime = 0;
+    if (ENABLE_SENSITIVE_REDACTION) {
+        getSensitiveValues();
+    }
+}
+function maskSensitiveValue(value) {
+    return REDACTED_MARKER;
+}
+function escapeRegExp(value) {
+    return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function containsSensitiveValue(text, values) {
+    const normalizedText = String(text).toLowerCase();
+    for (const sensitiveValue of values) {
+        if (sensitiveValue && normalizedText.includes(String(sensitiveValue).toLowerCase())) {
+            return true;
+        }
+    }
+    return false;
+}
+function replaceSensitiveValues(text, values) {
+    let result = text;
+    for (const sensitiveValue of values) {
+        if (sensitiveValue && containsSensitiveValue(result, [sensitiveValue])) {
+            const masked = maskSensitiveValue(sensitiveValue);
+            result = result.replace(new RegExp(escapeRegExp(sensitiveValue), "gi"), masked);
+        }
+    }
+    return result;
+}
+// 从文本里提取“看起来像 Base64”的连续片段。
+// 这里只做候选收集，是否真的需要脱敏由解码后的匹配结果决定。
+function extractBase64Candidates(text) {
+    return [...text.matchAll(BASE64_CANDIDATE_RE)].map(match => match[1]);
+}
+// 尝试把候选片段按 Base64 / Base64URL 解码。
+// 解码失败时返回 null，交给上层继续处理其他候选。
+function tryDecodeBase64(input) {
+    try {
+        let normalized = input.replace(/-/g, "+").replace(/_/g, "/");
+        const mod = normalized.length % 4;
+        if (mod) {
+            normalized += "=".repeat(4 - mod);
+        }
+        const decoded = Buffer.from(normalized, "base64").toString("utf8");
+        if (!decoded) {
+            return null;
+        }
+        return decoded;
+    }
+    catch {
+        return null;
+    }
+}
+export function redactSensitiveText(text) {
+    if (!ENABLE_SENSITIVE_REDACTION) {
+        return text;
+    }
+    if (!text || typeof text !== "string") {
+        return text;
+    }
+    const values = getSensitiveValues();
+    let result = replaceSensitiveValues(text, values);
+    // 先按原文直接匹配；只有没命中时才继续尝试 Base64 绕过检测。
+    if (result !== text) {
+        return result;
+    }
+    const candidates = extractBase64Candidates(text);
+    for (const candidate of candidates) {
+        const decoded = tryDecodeBase64(candidate);
+        if (!decoded) {
+            continue;
+        }
+        if (containsSensitiveValue(decoded, values)) {
+            result = result.split(candidate).join(REDACTED_MARKER);
+        }
+    }
+    return result;
+}
+export function redactSensitiveObject(obj) {
+    if (!ENABLE_SENSITIVE_REDACTION) {
+        return obj;
+    }
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (typeof obj === "string") {
+        return redactSensitiveText(obj);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(item => redactSensitiveObject(item));
+    }
+    if (typeof obj === "object") {
+        const result = {};
+        for (const key of Object.keys(obj)) {
+            result[key] = redactSensitiveObject(obj[key]);
+        }
+        return result;
+    }
+    return obj;
+}
+export function containsSensitiveInfo(text) {
+    if (!ENABLE_SENSITIVE_REDACTION) {
+        return false;
+    }
+    if (!text || typeof text !== "string") {
+        return false;
+    }
+    const values = getSensitiveValues();
+    if (containsSensitiveValue(text, values)) {
+        return true;
+    }
+    const candidates = extractBase64Candidates(text);
+    for (const candidate of candidates) {
+        const decoded = tryDecodeBase64(candidate);
+        if (decoded && containsSensitiveValue(decoded, values)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/src/task-manager.js

@@ -17,26 +17,22 @@ const activeTaskIds = _g.__xyActiveTaskIds;
  * Returns true if this was an update (session already had an active task).
  */
 export function registerTaskId(sessionId, taskId, messageId) {
-    logger.log(`[TASK_MANAGER] 📝 Registering/Updating taskId for session: ${sessionId}`);
-    logger.log(`[TASK_MANAGER]   - taskId: ${taskId}`);
     const existing = activeTaskIds.get(sessionId);
     if (existing) {
-        logger.log(`[TASK_MANAGER]   - Previous taskId: ${existing.currentTaskId}`);
-        logger.log(`[TASK_MANAGER]   - 🔄 Updating taskId`);
+        logger.log(`[TASK_MANAGER] Updating taskId: ${existing.currentTaskId} → ${taskId}`);
         existing.currentTaskId = taskId;
         existing.currentMessageId = messageId;
         existing.updatedAt = Date.now();
         return true; // isUpdate
     }
     else {
-        const binding = {
+        activeTaskIds.set(sessionId, {
             sessionId,
             currentTaskId: taskId,
             currentMessageId: messageId,
             updatedAt: Date.now(),
-        };
-        activeTaskIds.set(sessionId, binding);
-        logger.log(`[TASK_MANAGER]   - ✅ TaskId registered (new)`);
+        });
+        logger.log(`[TASK_MANAGER] Registered new taskId: ${taskId}`);
         return false;
     }
 }
@@ -44,7 +40,7 @@ export function registerTaskId(sessionId, taskId, messageId) {
  * 移除session的活跃taskId（消息处理完成时调用）。
  */
 export function decrementTaskIdRef(sessionId) {
-    logger.log(`[TASK_MANAGER] 🗑️  Removing taskId for ${sessionId}`);
+    logger.log(`[TASK_MANAGER] Removing taskId`);
     activeTaskIds.delete(sessionId);
 }
 /**
@@ -77,6 +73,6 @@ export function getAllActiveTaskBindings() {
  * 强制清理（错误恢复用）
  */
 export function forceCleanTaskId(sessionId) {
-    logger.log(`[TASK_MANAGER] ⚠️  Force clearing taskId for ${sessionId}`);
+    logger.log(`[TASK_MANAGER] Force clearing taskId`);
     activeTaskIds.delete(sessionId);
 }

package/dist/src/tools/agent-as-skill-tool.d.ts

@@ -0,0 +1,7 @@
+import type { SessionContext } from "./session-manager.js";
+/**
+ * Agent-as-skill tool - invokes a registered agent by agentId as a skill.
+ * The tool receives the agentId, query, and optional file attachments,
+ * forwards the request to the target agent via WebSocket, and returns the result.
+ */
+export declare function createAgentAsSkillTool(ctx: SessionContext): any;

package/dist/src/tools/agent-as-skill-tool.js

@@ -0,0 +1,190 @@
+// Agent-as-skill tool implementation - invokes another agent as a skill
+import { getXYWebSocketManager } from "../client.js";
+import { sendCommand } from "../formatter.js";
+import { getCurrentTaskId } from "../task-manager.js";
+import { logger } from "../utils/logger.js";
+import { XYFileUploadService } from "../file-upload.js";
+/**
+ * Agent-as-skill tool - invokes a registered agent by agentId as a skill.
+ * The tool receives the agentId, query, and optional file attachments,
+ * forwards the request to the target agent via WebSocket, and returns the result.
+ */
+export function createAgentAsSkillTool(ctx) {
+    const { config, sessionId, taskId, messageId } = ctx;
+    return {
+        name: "agent_as_a_tool",
+        label: "Agent as Skill Tool",
+        description: `智能体作为skill的执行元工具。当需要调用其他已注册的Agent来执行特定任务时使用此工具。
+该工具会将用户请求和可选的附件文件转发给目标Agent执行，并返回执行结果。
+
+使用场景：
+- 需要调用其他Agent完成特定领域的任务
+- 需要将文件/图片交给专门的Agent处理
+- 需要组合多个Agent的能力来完成复杂任务
+
+注意事项：
+- 操作超时时间为5分钟
+- 该工具执行期间必须严格等待结果返回，不要执行其他操作
+- 如果超时或失败，最多重试一次`,
+        parameters: {
+            type: "object",
+            properties: {
+                agentId: {
+                    type: "string",
+                    description: "待执行的AgentId，精准匹配系统注册的AgentId",
+                },
+                query: {
+                    type: "string",
+                    description: "用户原始请求文本，原样转发给目标Agent执行",
+                },
+                filesInfo: {
+                    description: "附件文件/图片信息列表，无文件时可传null或空数组，支持传入数组或JSON字符串",
+                    items: {
+                        type: "object",
+                        properties: {
+                            fileType: {
+                                type: "string",
+                                description: "文件类型：file 或 image",
+                                enum: ["file", "image"],
+                            },
+                            fileId: {
+                                type: "string",
+                                description: "文件全局唯一标识",
+                            },
+                            fileUrl: {
+                                type: "string",
+                                description: "文件可访问下载链接（完整HTTP/HTTPS地址）",
+                            },
+                            fileUrlLocal: {
+                                type: "string",
+                                description: "文件本地路径，如果提供此字段，工具会自动上传文件并将公网URL填入fileUrl",
+                            },
+                        },
+                    },
+                },
+            },
+            required: ["agentId", "query"],
+        },
+        async execute(toolCallId, params) {
+            // Dynamic lookup: use latest taskId from task-manager (handles steer/interrupt)
+            const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+            // Validate parameters
+            if (!params.agentId || typeof params.agentId !== "string") {
+                throw new Error("Missing or invalid required parameter: agentId must be a non-empty string");
+            }
+            if (!params.query || typeof params.query !== "string") {
+                throw new Error("Missing or invalid required parameter: query must be a non-empty string");
+            }
+            // Robust parsing: normalize filesInfo from array or JSON string
+            let filesInfo = null;
+            if (params.filesInfo) {
+                if (Array.isArray(params.filesInfo)) {
+                    filesInfo = params.filesInfo;
+                }
+                else if (typeof params.filesInfo === 'string') {
+                    try {
+                        const parsed = JSON.parse(params.filesInfo);
+                        if (Array.isArray(parsed)) {
+                            filesInfo = parsed;
+                        }
+                        else {
+                            throw new Error("filesInfo must be an array or a JSON string representing an array");
+                        }
+                    }
+                    catch (parseError) {
+                        throw new Error(`filesInfo JSON解析失败: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                    }
+                }
+                else {
+                    filesInfo = null;
+                }
+            }
+            // Upload local files and fill fileUrl
+            if (filesInfo && filesInfo.length > 0) {
+                const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+                for (const fileInfo of filesInfo) {
+                    if (fileInfo.fileUrlLocal && !fileInfo.fileUrl) {
+                        try {
+                            const publicUrl = await uploadService.uploadFileAndGetUrl(fileInfo.fileUrlLocal, "TEMPORARY_MATERIAL_DOC");
+                            if (publicUrl) {
+                                fileInfo.fileUrl = publicUrl;
+                            }
+                            else {
+                                logger.warn("[AGENT-AS-SKILL] 上传文件未返回公网URL", { fileUrlLocal: fileInfo.fileUrlLocal });
+                            }
+                        }
+                        catch (uploadError) {
+                            logger.error("[AGENT-AS-SKILL] 上传本地文件失败", { fileUrlLocal: fileInfo.fileUrlLocal, error: uploadError });
+                            throw new Error(`上传本地文件失败 (${fileInfo.fileUrlLocal}): ${uploadError instanceof Error ? uploadError.message : String(uploadError)}`);
+                        }
+                    }
+                    // Remove fileUrlLocal from the final payload
+                    delete fileInfo.fileUrlLocal;
+                }
+            }
+            // Get WebSocket manager
+            const wsManager = getXYWebSocketManager(config);
+            // Build ExecuteAgentAsSkill command
+            const command = {
+                header: {
+                    namespace: "System",
+                    name: "ExecuteAgentAsSkill",
+                },
+                payload: {
+                    agentId: params.agentId,
+                    query: params.query,
+                    filesInfo: filesInfo || null,
+                },
+            };
+            // Send command and wait for response (5 minute timeout)
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    wsManager.off("agent-as-skill-response", handler);
+                    logger.error("超时: Agent-as-Skill 操作超时（5分钟）", { agentId: params.agentId, toolCallId });
+                    reject(new Error("Agent-as-Skill 操作超时（5分钟）"));
+                }, 300000); // 5 minutes timeout
+                // Listen for Agent-as-Skill response events
+                const handler = (event) => {
+                    // Check if this is the ExecuteAgentAsSkillResponse we're waiting for
+                    if (event.header?.namespace === "System" &&
+                        event.header?.name === "ExecuteAgentAsSkillResponse") {
+                        clearTimeout(timeout);
+                        wsManager.off("agent-as-skill-response", handler);
+                        // Return the payload directly as the tool result
+                        const payload = event.payload;
+                        if (payload) {
+                            resolve({
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: typeof payload === "string" ? payload : JSON.stringify(payload),
+                                    },
+                                ],
+                            });
+                        }
+                        else {
+                            reject(new Error("Agent-as-Skill 响应格式错误：缺少 payload"));
+                        }
+                    }
+                };
+                // Register event handler
+                wsManager.on("agent-as-skill-response", handler);
+                // Send the command
+                sendCommand({
+                    config,
+                    sessionId,
+                    taskId: currentTaskId,
+                    messageId,
+                    command,
+                    toolCallId,
+                }).then(() => {
+                    logger.log("[AGENT-AS-SKILL] Command sent successfully", { agentId: params.agentId });
+                }).catch((error) => {
+                    clearTimeout(timeout);
+                    wsManager.off("agent-as-skill-response", handler);
+                    reject(error);
+                });
+            });
+        },
+    };
+}

package/dist/src/tools/calendar-tool.js

@@ -87,7 +87,7 @@ export function createCalendarTool(ctx) {
             return new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => {
                     wsManager.off("data-event", handler);
-                    logger.error("超时: 创建日程超时（60秒）", { sessionId, toolCallId });
+                    logger.error("超时: 创建日程超时（60秒）", { toolCallId });
                     reject(new Error("创建日程超时（60秒）"));
                 }, 60000);
                 // Listen for data events from WebSocket
@@ -106,7 +106,7 @@ export function createCalendarTool(ctx) {
                             });
                         }
                         else {
-                            reject(new Error(`创建日程失败: ${event.status}`));
+                            reject(new Error(`创建日程失败: ${JSON.stringify(event.outputs)}`));
                         }
                     }
                 };
@@ -120,6 +120,7 @@ export function createCalendarTool(ctx) {
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => {
                 })

package/dist/src/tools/call-phone-tool.js

@@ -79,7 +79,7 @@ export function createCallPhoneTool(ctx) {
             return new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => {
                     wsManager.off("data-event", handler);
-                    logger.error("超时: 拨打电话超时（60秒）", { sessionId, toolCallId });
+                    logger.error("超时: 拨打电话超时（60秒）", { toolCallId });
                     reject(new Error("拨打电话超时（60秒）"));
                 }, 60000);
                 // Listen for data events from WebSocket
@@ -98,7 +98,7 @@ export function createCallPhoneTool(ctx) {
                             });
                         }
                         else {
-                            reject(new Error(`拨打电话失败: ${event.status}`));
+                            reject(new Error(`拨打电话失败: ${JSON.stringify(event.outputs)}`));
                         }
                     }
                 };
@@ -112,6 +112,7 @@ export function createCallPhoneTool(ctx) {
                     taskId: currentTaskId,
                     messageId,
                     command,
+                    toolCallId,
                 })
                     .then(() => {
                 })

package/dist/src/tools/check-plugin-privilege-tool.d.ts

@@ -0,0 +1,6 @@
+import type { SessionContext } from "./session-manager.js";
+/**
+ * XY check plugin privilege tool - checks user authorization for device-side tools
+ * used in scheduled tasks.
+ */
+export declare function createCheckPluginPrivilegeTool(ctx: SessionContext): any;