alemonjs-aichat 1.0.35 → 1.0.38

package/lib/api/aitools.js

@@ -313,6 +313,36 @@ const tools = [
             },
         },
     },
+    {
+        type: "function",
+        function: {
+            name: "RunServerCommand",
+            description: "直接在服务器上执行运维指令，可用于查看状态、管理服务、Docker、PM2、日志和部署流程。执行前必须通过本地基础拦截和 AI 自动审核；审核不可用或未通过时不会执行。不要用它操作 public/{guid} 项目文件，AI agent 项目文件操作仍使用 Agent* 工具。",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: {
+                        type: "string",
+                        description: "要执行的服务器指令，例如 systemctl status nginx、docker ps、pm2 list、tail -n 100 app.log",
+                    },
+                    workingDirectory: {
+                        type: "string",
+                        description: "可选。服务器上的执行目录，可以是绝对路径或相对当前进程目录，默认为服务进程当前目录",
+                    },
+                    reviewGuid: {
+                        type: "string",
+                        description: "必填。传入当前群号，也就是系统提示词里的“当前群号(reviewGuid)”；私聊时也传当前会话的群号/guid。用于读取当前群 AI 配置并执行 AI 自动审核，不是 public/{guid} 项目工作目录ID。",
+                    },
+                    timeoutSeconds: {
+                        type: "number",
+                        description: "可选。命令超时时间，默认 120 秒，最大 600 秒",
+                        default: 120,
+                    },
+                },
+                required: ["command", "reviewGuid"],
+            },
+        },
+    },
     {
         type: "function",
         function: {
@@ -333,7 +363,12 @@ const tools = [
                     action: {
                         type: "string",
                         description: "Git 操作类型：currentBranch 当前分支；listBranches 分支列表；listRemotes 远端列表；switchBranch 切换到已有分支",
-                        enum: ["currentBranch", "listBranches", "listRemotes", "switchBranch"],
+                        enum: [
+                            "currentBranch",
+                            "listBranches",
+                            "listRemotes",
+                            "switchBranch",
+                        ],
                     },
                     branch: {
                         type: "string",
@@ -708,14 +743,14 @@ const tools = [
         type: "function",
         function: {
             name: "ping",
-            description: `
-检测目标主机是否可达。
-
-【限制】
-- 仅允许公网域名
-- 禁止 IP 地址（防止内网扫描）
-- 自动限制次数（例如 3 次）
-
+            description: `
+检测目标主机是否可达。
+
+【限制】
+- 仅允许公网域名
+- 禁止 IP 地址（防止内网扫描）
+- 自动限制次数（例如 3 次）
+
 `,
             parameters: {
                 type: "object",
@@ -730,22 +765,22 @@ const tools = [
         type: "function",
         function: {
             name: "http_request",
-            description: `
-发送 HTTP 请求以获取网页或 API 数据。
-
-【能力范围】
-- 支持 GET / POST 请求
-- 返回文本或 JSON 内容
-- 自动处理常见编码
-
-【限制】
-- 禁止访问云元数据地址（如 169.254.169.254）
-- 请求超时限制为 5 秒
-- 响应大小限制（例如 1MB）
-
-【使用建议】
-- 优先使用此工具获取网页内容，而不是使用 shell
-- 适合抓取网页、调用 API、获取数据
+            description: `
+发送 HTTP 请求以获取网页或 API 数据。
+
+【能力范围】
+- 支持 GET / POST 请求
+- 返回文本或 JSON 内容
+- 自动处理常见编码
+
+【限制】
+- 禁止访问云元数据地址（如 169.254.169.254）
+- 请求超时限制为 5 秒
+- 响应大小限制（例如 1MB）
+
+【使用建议】
+- 优先使用此工具获取网页内容，而不是使用 shell
+- 适合抓取网页、调用 API、获取数据
 `,
             parameters: {
                 type: "object",
@@ -830,11 +865,44 @@ const ALLOWED_DOTNET_PROJECT_SUBCOMMANDS = new Set([
     "sln",
 ]);
 const BLOCKED_PROJECT_COMMAND_PATTERNS = [
-    { pattern: /&&|\|\||[;|<>`]|[$][(]/, reason: "不允许使用 shell 控制符、重定向、命令替换或反引号" },
-    { pattern: /(^|[\s])(rm|del|erase|rmdir|rd)([\s]|$)/i, reason: "不允许使用删除命令" },
-    { pattern: /(^|[\s])(powershell|pwsh|cmd|bash|sh|docker|ssh|scp|sftp|curl|wget)([\s]|$)/i, reason: "不允许执行受限外部命令" },
+    {
+        pattern: /&&|\|\||[;|<>`]|[$][(]/,
+        reason: "不允许使用 shell 控制符、重定向、命令替换或反引号",
+    },
+    {
+        pattern: /(^|[\s])(rm|del|erase|rmdir|rd)([\s]|$)/i,
+        reason: "不允许使用删除命令",
+    },
+    {
+        pattern: /(^|[\s])(powershell|pwsh|cmd|bash|sh|docker|ssh|scp|sftp|curl|wget)([\s]|$)/i,
+        reason: "不允许执行受限外部命令",
+    },
     { pattern: /\.\.[\\/]/, reason: "不允许通过 .. 离开 public 工作目录" },
 ];
+const SERVER_COMMAND_DEFAULT_TIMEOUT_SECONDS = 120;
+const SERVER_COMMAND_MAX_TIMEOUT_SECONDS = 600;
+const BLOCKED_SERVER_COMMAND_PATTERNS = [
+    {
+        pattern: /\0/,
+        reason: "命令包含非法空字符",
+    },
+    {
+        pattern: /:\s*\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;/,
+        reason: "不允许执行 fork bomb",
+    },
+    {
+        pattern: /(^|[\s;&|])rm\s+(-[^\s]*r[^\s]*f|-f[^\s]*r|-[^\s]*rf[^\s]*)\s+(\/|\/\*|~|~\/|\$HOME)(\s|$)/i,
+        reason: "不允许递归强制删除系统根目录或用户主目录",
+    },
+    {
+        pattern: /(^|[\s;&|])(mkfs|mkswap|fdisk|parted|wipefs)([\s]|$)/i,
+        reason: "不允许执行磁盘格式化或分区破坏类命令",
+    },
+    {
+        pattern: /(^|[\s;&|])dd\s+[\s\S]*\bof=\/dev\//i,
+        reason: "不允许使用 dd 写入块设备",
+    },
+];
 const toToolError = (error) => ({
     success: false,
     error: error instanceof Error ? error.message : String(error),
@@ -1408,7 +1476,15 @@ const buildProjectCommandReview = (command) => {
                 tokens,
             };
         }
-        risk = ["new", "restore", "build", "run", "test", "publish", "clean"].includes(subcommand)
+        risk = [
+            "new",
+            "restore",
+            "build",
+            "run",
+            "test",
+            "publish",
+            "clean",
+        ].includes(subcommand)
             ? "medium"
             : "low";
         reasons.push(risk === "medium"
@@ -1490,7 +1566,8 @@ const buildProjectCommandReview = (command) => {
             tokens,
         };
     }
-    if (["create", "init", "dlx", "exec"].includes(subcommand) || ["npx", "npx.cmd", "bunx"].includes(baseCommand)) {
+    if (["create", "init", "dlx", "exec"].includes(subcommand) ||
+        ["npx", "npx.cmd", "bunx"].includes(baseCommand)) {
         risk = "medium";
         reasons.push("脚手架或外部执行命令会下载并运行第三方包");
     }
@@ -1498,7 +1575,8 @@ const buildProjectCommandReview = (command) => {
         risk = "medium";
         reasons.push("依赖安装命令会写入项目依赖和锁文件");
     }
-    else if (["run", "test", "build"].includes(subcommand) || subcommand === "") {
+    else if (["run", "test", "build"].includes(subcommand) ||
+        subcommand === "") {
         risk = "low";
         reasons.push("项目内脚本或常规包管理命令");
     }
@@ -1514,6 +1592,56 @@ const buildProjectCommandReview = (command) => {
         tokens,
     };
 };
+const buildServerCommandLocalReview = (command) => {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return {
+            allowed: false,
+            risk: "blocked",
+            reasons: ["命令不能为空"],
+        };
+    }
+    for (const item of BLOCKED_SERVER_COMMAND_PATTERNS) {
+        if (item.pattern.test(trimmed)) {
+            return {
+                allowed: false,
+                risk: "blocked",
+                reasons: [item.reason],
+            };
+        }
+    }
+    const highRiskPatterns = [
+        /(^|[\s;&|])(sudo|su)([\s]|$)/i,
+        /(^|[\s;&|])(systemctl|service|supervisorctl|pm2)([\s]|$)/i,
+        /(^|[\s;&|])(docker|docker-compose|kubectl)([\s]|$)/i,
+        /(^|[\s;&|])(apt|apt-get|yum|dnf|pacman|apk)([\s]|$)/i,
+        /(^|[\s;&|])(iptables|ufw|firewall-cmd)([\s]|$)/i,
+        /(^|[\s;&|])(rm|mv|cp|chmod|chown|kill|pkill)([\s]|$)/i,
+    ];
+    const mediumRiskPatterns = [
+        /(^|[\s;&|])(curl|wget|git|tar|unzip|npm|pnpm|yarn|node)([\s]|$)/i,
+        /[;&|<>`]|[$][(]/,
+    ];
+    if (highRiskPatterns.some((pattern) => pattern.test(trimmed))) {
+        return {
+            allowed: true,
+            risk: "high",
+            reasons: ["服务器管理或文件/进程/网络配置相关命令，必须经过 AI 审核"],
+        };
+    }
+    if (mediumRiskPatterns.some((pattern) => pattern.test(trimmed))) {
+        return {
+            allowed: true,
+            risk: "medium",
+            reasons: ["可能修改服务状态、下载内容或使用 shell 控制符，必须经过 AI 审核"],
+        };
+    }
+    return {
+        allowed: true,
+        risk: "low",
+        reasons: ["常规服务器查询或低风险命令，仍需 AI 审核确认"],
+    };
+};
 const getReviewAIConfig = async (reviewGuid) => {
     const guid = reviewGuid?.trim();
     const config = await redisClient.getAIConfig(guid || undefined);
@@ -1548,8 +1676,8 @@ const reviewProjectCommandWithAI = async ({ command, localReview, reviewGuid, })
             messages: [
                 {
                     role: "system",
-                    content: "你是一个命令安全审查器。请只输出 JSON，格式为 {\"allowed\":boolean,\"risk\":\"low|medium|high|blocked\",\"reason\":\"简短中文原因\"}。审核标准：命令必须只适用于 public 工作目录内的安全项目操作，不得包含权限提升、删除系统文件、远程控制、数据外传、全局环境修改或危险 shell 行为。"
-                        + `\n性格约束:${aiConfig.config.systemPrompt || ""}`,
+                    content: '你是一个命令安全审查器。请只输出 JSON，格式为 {"allowed":boolean,"risk":"low|medium|high|blocked","reason":"简短中文原因"}。审核标准：命令必须只适用于 public 工作目录内的安全项目操作，不得包含权限提升、删除系统文件、远程控制、数据外传、全局环境修改或危险 shell 行为。' +
+                        `\n性格约束:${aiConfig.config.systemPrompt || ""}`,
                 },
                 {
                     role: "user",
@@ -1598,6 +1726,143 @@ const reviewProjectCommandWithAI = async ({ command, localReview, reviewGuid, })
         };
     }
 };
+const reviewServerCommandWithAI = async ({ command, localReview, reviewGuid, workingDirectory, }) => {
+    const aiConfig = await getReviewAIConfig(reviewGuid);
+    if (!aiConfig) {
+        return {
+            status: "skipped",
+            reason: "未找到可用的当前 AI 配置，服务器指令必须完成 AI 审核后才能执行",
+        };
+    }
+    try {
+        const openai = new OpenAi({
+            baseURL: aiConfig.config.host,
+            apiKey: aiConfig.config.key,
+            timeout: 30000,
+        });
+        const response = await openai.chat.completions.create({
+            model: aiConfig.config.model,
+            temperature: 0,
+            max_tokens: 220,
+            messages: [
+                {
+                    role: "system",
+                    content: '你是服务器运维指令安全审核器。请只输出 JSON，格式为 {"allowed":boolean,"risk":"low|medium|high|blocked","reason":"简短中文原因"}。可以允许合理的服务器管理、状态查看、日志查看、服务重启、Docker/PM2/systemctl 操作、部署和包管理命令；必须阻止清空数据、破坏系统、植入后门、泄露密钥、反弹 shell、未知脚本下载后直接执行、越权访问或明显不可恢复的危险操作。' +
+                        `\n性格约束:${aiConfig.config.systemPrompt || ""}`,
+                },
+                {
+                    role: "user",
+                    content: JSON.stringify({
+                        command,
+                        workingDirectory,
+                        localReview: {
+                            allowed: localReview.allowed,
+                            risk: localReview.risk,
+                            reasons: localReview.reasons,
+                        },
+                    }),
+                },
+            ],
+        });
+        const text = response.choices[0]?.message?.content || "";
+        const match = text.match(/\{[\s\S]*\}/);
+        if (!match) {
+            return {
+                status: "failed",
+                reason: "AI 审核未返回可解析的 JSON",
+                raw: text,
+            };
+        }
+        const parsed = JSON.parse(match[0]);
+        return {
+            status: "completed",
+            currentAI: aiConfig.currentAI || null,
+            model: aiConfig.config.model,
+            guid: aiConfig.guid,
+            allowed: Boolean(parsed.allowed),
+            risk: parsed.risk === "low" ||
+                parsed.risk === "medium" ||
+                parsed.risk === "high" ||
+                parsed.risk === "blocked"
+                ? parsed.risk
+                : "high",
+            reason: typeof parsed.reason === "string" && parsed.reason.trim()
+                ? parsed.reason.trim()
+                : "AI 未提供明确原因",
+        };
+    }
+    catch (error) {
+        return {
+            status: "failed",
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+};
+const resolveServerWorkingDirectory = (workingDirectory) => {
+    if (workingDirectory?.includes("\0")) {
+        throw new Error("workingDirectory 包含非法空字符");
+    }
+    const cwd = path.resolve(workingDirectory?.trim() || process.cwd());
+    if (!fs.existsSync(cwd)) {
+        throw new Error("workingDirectory 不存在");
+    }
+    if (!fs.statSync(cwd).isDirectory()) {
+        throw new Error("workingDirectory 不是目录");
+    }
+    return cwd;
+};
+const normalizeServerCommandTimeoutMs = (timeoutSeconds) => {
+    const safeSeconds = Math.min(normalizePositiveInteger(timeoutSeconds, SERVER_COMMAND_DEFAULT_TIMEOUT_SECONDS, "timeoutSeconds"), SERVER_COMMAND_MAX_TIMEOUT_SECONDS);
+    return safeSeconds * 1000;
+};
+const runServerShellCommand = ({ command, cwd, timeoutMs, }) => {
+    return new Promise((resolve, reject) => {
+        const powershellCommand = [
+            "chcp 65001 | Out-Null",
+            "[Console]::InputEncoding = [System.Text.UTF8Encoding]::new()",
+            "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new()",
+            "$OutputEncoding = [System.Text.UTF8Encoding]::new()",
+            command,
+        ].join("; ");
+        const shell = process.platform === "win32"
+            ? {
+                file: "powershell.exe",
+                args: [
+                    "-NoProfile",
+                    "-ExecutionPolicy",
+                    "Bypass",
+                    "-Command",
+                    powershellCommand,
+                ],
+            }
+            : { file: "sh", args: ["-lc", command] };
+        const child = spawn(shell.file, shell.args, { cwd });
+        let output = "";
+        const appendOutput = (data) => {
+            output += data.toString();
+            if (output.length > PROJECT_COMMAND_MAX_OUTPUT) {
+                output = output.slice(-PROJECT_COMMAND_MAX_OUTPUT);
+            }
+        };
+        const timeout = setTimeout(() => {
+            child.kill();
+            reject(new Error("服务器指令执行超时"));
+        }, timeoutMs);
+        child.stdout.on("data", appendOutput);
+        child.stderr.on("data", appendOutput);
+        child.on("error", (error) => {
+            clearTimeout(timeout);
+            reject(new Error(`服务器指令启动失败: ${error.message}`));
+        });
+        child.on("close", (exitCode) => {
+            clearTimeout(timeout);
+            resolve({
+                output: trimProjectCommandOutput(output.trim()),
+                exitCode: exitCode ?? -1,
+            });
+        });
+    });
+};
 const runSpawnCommand = ({ file, args, cwd, }) => {
     return new Promise((resolve, reject) => {
         const child = spawn(file, args, { cwd });
@@ -1662,14 +1927,22 @@ const findExecutablePaths = async (name, cwd) => {
 };
 const inspectProjectEnvironment = async (cwd) => {
     const versionCommands = [
-        { name: "dotnet", file: process.platform === "win32" ? "dotnet.exe" : "dotnet", args: ["--version"] },
+        {
+            name: "dotnet",
+            file: process.platform === "win32" ? "dotnet.exe" : "dotnet",
+            args: ["--version"],
+        },
         process.platform === "win32"
             ? { name: "npm", file: "npm.cmd", args: ["-v"] }
             : { name: "npm", file: "npm", args: ["-v"] },
         process.platform === "win32"
             ? { name: "npx", file: "npx.cmd", args: ["-v"] }
             : { name: "npx", file: "npx", args: ["-v"] },
-        { name: "node", file: process.platform === "win32" ? "node.exe" : "node", args: ["-v"] },
+        {
+            name: "node",
+            file: process.platform === "win32" ? "node.exe" : "node",
+            args: ["-v"],
+        },
         { name: "git", file: "git", args: ["--version"] },
     ];
     const versions = {};
@@ -1682,11 +1955,15 @@ const inspectProjectEnvironment = async (cwd) => {
                 cwd,
             });
             versions[command.name] =
-                result.exitCode === 0 ? result.output || "ok" : `exit ${result.exitCode}`;
+                result.exitCode === 0
+                    ? result.output || "ok"
+                    : `exit ${result.exitCode}`;
         }
         catch (error) {
             versions[command.name] =
-                error instanceof Error ? `unavailable: ${error.message}` : String(error);
+                error instanceof Error
+                    ? `unavailable: ${error.message}`
+                    : String(error);
         }
         paths[command.name] = await findExecutablePaths(command.name, cwd);
     }
@@ -1694,7 +1971,10 @@ const inspectProjectEnvironment = async (cwd) => {
         cwd,
         versions,
         paths,
-        entries: fs.readdirSync(cwd, { withFileTypes: true }).slice(0, 50).map((item) => ({
+        entries: fs
+            .readdirSync(cwd, { withFileTypes: true })
+            .slice(0, 50)
+            .map((item) => ({
             name: item.name,
             type: item.isDirectory() ? "directory" : "file",
         })),
@@ -1722,7 +2002,9 @@ const extractArchiveWithinWorkspace = async ({ archive, destination, }) => {
             cwd: destination,
         });
     }
-    if (lower.endsWith(".tar") || lower.endsWith(".tar.gz") || lower.endsWith(".tgz")) {
+    if (lower.endsWith(".tar") ||
+        lower.endsWith(".tar.gz") ||
+        lower.endsWith(".tgz")) {
         return runSpawnCommand({
             file: "tar",
             args: ["-xf", archive, "-C", destination],
@@ -1750,15 +2032,50 @@ const performProjectCommandReview = async ({ command, reviewGuid, }) => {
         aiReview,
     };
 };
+const performServerCommandReview = async ({ command, reviewGuid, workingDirectory, }) => {
+    const localReview = buildServerCommandLocalReview(command);
+    if (!localReview.allowed) {
+        return {
+            allowed: false,
+            risk: localReview.risk,
+            localReview,
+            aiReview: {
+                status: "skipped",
+                reason: "本地基础拦截未通过，未继续调用 AI 审核",
+            },
+        };
+    }
+    const aiReview = await reviewServerCommandWithAI({
+        command,
+        localReview,
+        reviewGuid,
+        workingDirectory,
+    });
+    const allowed = aiReview.status === "completed" && aiReview.allowed === true;
+    const risk = aiReview.status === "completed" && aiReview.risk
+        ? aiReview.risk
+        : localReview.risk;
+    return {
+        allowed,
+        risk,
+        localReview,
+        aiReview,
+    };
+};
 /**
  * 确保 Docker 容器已创建并运行
  */
 async function ensureContainerRunning(config) {
-    const { containerName, image, memory, cpus, pidsLimit, networkMode, workspacePath } = config;
+    const { containerName, image, memory, cpus, pidsLimit, networkMode, workspacePath, } = config;
     if (!containerName)
         return;
     return new Promise((resolve, reject) => {
-        const check = spawn("docker", ["inspect", "-f", "{{.State.Running}}", containerName]);
+        const check = spawn("docker", [
+            "inspect",
+            "-f",
+            "{{.State.Running}}",
+            containerName,
+        ]);
         let stdout = "";
         check.stdout.on("data", (d) => (stdout += d.toString()));
         check.on("error", (error) => {
@@ -1787,12 +2104,18 @@ async function ensureContainerRunning(config) {
                 return;
             }
             const args = [
-                "run", "-d",
-                "--name", containerName,
-                "--memory", memory || "256m",
-                "--cpus", cpus || "0.5",
-                "--pids-limit", String(pidsLimit || 64),
-                "--network", networkMode || "none",
+                "run",
+                "-d",
+                "--name",
+                containerName,
+                "--memory",
+                memory || "256m",
+                "--cpus",
+                cpus || "0.5",
+                "--pids-limit",
+                String(pidsLimit || 64),
+                "--network",
+                networkMode || "none",
             ];
             if (workspacePath && fs.existsSync(workspacePath)) {
                 args.push("-v", `${workspacePath}:/workspace`, "-w", "/workspace");
@@ -2224,7 +2547,7 @@ const availableTools = {
      * @param command 命令字符串
      * @returns 命令执行结果
      */
-    exec: async ({ userId, groupId, command }) => {
+    exec: async ({ userId, groupId, command, }) => {
         const workspace = getWorkspace(userId);
         if (commandTargetsAgentWorkspace(command || "")) {
             return [
@@ -2385,6 +2708,46 @@ const availableTools = {
             return toToolError(error);
         }
     },
+    RunServerCommand: async ({ command, workingDirectory, reviewGuid, timeoutSeconds = SERVER_COMMAND_DEFAULT_TIMEOUT_SECONDS, }) => {
+        try {
+            if (!reviewGuid?.trim()) {
+                throw new Error("reviewGuid 必填，请传入当前群号");
+            }
+            const cwd = resolveServerWorkingDirectory(workingDirectory);
+            const timeoutMs = normalizeServerCommandTimeoutMs(timeoutSeconds);
+            const review = await performServerCommandReview({
+                command,
+                reviewGuid,
+                workingDirectory: cwd,
+            });
+            if (!review.allowed) {
+                return {
+                    success: false,
+                    command,
+                    workingDirectory: cwd,
+                    error: "服务器指令未通过 AI 自动审核",
+                    review,
+                };
+            }
+            const result = await runServerShellCommand({
+                command,
+                cwd,
+                timeoutMs,
+            });
+            return {
+                success: result.exitCode === 0,
+                command,
+                workingDirectory: cwd,
+                review,
+                output: result.output,
+                exitCode: result.exitCode,
+                error: result.exitCode === 0 ? undefined : "服务器指令执行失败",
+            };
+        }
+        catch (error) {
+            return toToolError(error);
+        }
+    },
     AgentGitOperation: async ({ guid, action, workingDirectory = ".", branch, includeRemote = true, }) => {
         try {
             const { target: cwd, relativePath } = resolveAgentPath(guid, workingDirectory);
@@ -2494,7 +2857,8 @@ const availableTools = {
                     throw new Error("action=extract 时必须提供 archivePath");
                 }
                 const archive = resolveAgentPath(guid, archivePath);
-                if (!fs.existsSync(archive.target) || !fs.statSync(archive.target).isFile()) {
+                if (!fs.existsSync(archive.target) ||
+                    !fs.statSync(archive.target).isFile()) {
                     throw new Error("压缩包不存在或不是文件");
                 }
                 const destination = resolveAgentPath(guid, destinationPath || workingDirectory || ".");
@@ -2757,9 +3121,7 @@ const availableTools = {
                 fileName: fileName || null,
                 uploadType,
                 url,
-                sendText: uploadType === "image"
-                    ? `<img=${url}>`
-                    : `文件链接: ${url}`,
+                sendText: uploadType === "image" ? `<img=${url}>` : `文件链接: ${url}`,
             };
         }
         catch (error) {

package/lib/config.js

@@ -3,6 +3,8 @@ import fs from 'fs';
 import path from 'path';
 import { redis } from './redis.js';
 
+const TOOL_LOOP_TTL_SECONDS = 600;
+const TOOL_LOOP_STALE_MS = TOOL_LOOP_TTL_SECONDS * 1000;
 class db {
     redis;
     systemPrompt = "";
@@ -237,6 +239,14 @@ class db {
     async setToolPromptArgsSwitch(guid, enable) {
         await this.redis.set(`ai:tool_prompt_args:switch:${guid}`, enable ? "1" : "0");
     }
+    /** 工具调用前是否发送模型返回的 content */
+    async getToolCallContentSwitch(guid) {
+        return (await this.redis.get(`ai:tool_call_content:switch:${guid}`)) || "0";
+    }
+    /** 设置工具调用前 content 发送开关状态 */
+    async setToolCallContentSwitch(guid, enable) {
+        await this.redis.set(`ai:tool_call_content:switch:${guid}`, enable ? "1" : "0");
+    }
     /** --------------------------------------------------------- */
     /** 获取复杂输出开关状态 */
     async getComplexOutput(guid) {
@@ -427,9 +437,50 @@ class db {
             for (const key of keys) {
                 await this.redis.del(key);
             }
+            const contextStatsKeys = await this.redis.keys(`ai:context_stats:*`);
+            if (contextStatsKeys.length > 0) {
+                await this.redis.del(...contextStatsKeys);
+            }
+            await this.clearAITransientState();
             return;
         }
-        await this.redis.del(`ai:history:${guid}`);
+        await this.clearAITransientState(guid);
+        await this.redis.del(`ai:history:${guid}`, `ai:context_stats:${guid}`);
+    }
+    /** 记录当前会话上下文和 token 使用情况 */
+    async recordAIContextStats(guid, input) {
+        const current = await this.getAIContextStats(guid);
+        const promptTokens = input.promptTokens ?? 0;
+        const completionTokens = input.completionTokens ?? 0;
+        const totalTokens = input.totalTokens ?? promptTokens + completionTokens;
+        const cachedTokens = input.cachedTokens ?? 0;
+        const cacheMissTokens = input.cacheMissTokens ?? Math.max(promptTokens - cachedTokens, 0);
+        const nextStats = {
+            ...input,
+            promptTokens: input.promptTokens ?? null,
+            completionTokens: input.completionTokens ?? null,
+            totalTokens: input.totalTokens ?? null,
+            cachedTokens: input.cachedTokens ?? null,
+            cacheMissTokens: input.cacheMissTokens ?? null,
+            guid,
+            requestCount: (current?.requestCount ?? 0) + 1,
+            updatedAt: Date.now(),
+            totalPromptTokens: (current?.totalPromptTokens ?? 0) + promptTokens,
+            totalCompletionTokens: (current?.totalCompletionTokens ?? 0) + completionTokens,
+            totalTokensUsed: (current?.totalTokensUsed ?? 0) + totalTokens,
+            totalCachedTokens: (current?.totalCachedTokens ?? 0) + cachedTokens,
+            totalCacheMissTokens: (current?.totalCacheMissTokens ?? 0) + cacheMissTokens,
+        };
+        await this.redis.set(`ai:context_stats:${guid}`, JSON.stringify(nextStats));
+        return nextStats;
+    }
+    /** 获取当前会话上下文和 token 使用情况 */
+    async getAIContextStats(guid) {
+        const statsStr = await this.redis.get(`ai:context_stats:${guid}`);
+        if (!statsStr) {
+            return null;
+        }
+        return JSON.parse(statsStr);
     }
     /** 清理最后的N条聊天记录 */
     async clearLastNChatHistory(guid, n) {
@@ -464,17 +515,72 @@ class db {
         await this.redis.set(this.getArchiveRecordKey(guid, id), JSON.stringify(record));
         return record;
     }
+    /** 清理工具循环等临时会话状态 */
+    async clearAITransientState(guid) {
+        if (!guid) {
+            const transientPrefixes = [
+                "ai:tool_loop_processing:",
+                "ai:guidance:",
+                "ai:session:",
+            ];
+            for (const prefix of transientPrefixes) {
+                const keys = await this.redis.keys(`${prefix}*`);
+                if (keys.length > 0) {
+                    await this.redis.del(...keys);
+                }
+            }
+            return;
+        }
+        await this.redis.del(`ai:tool_loop_processing:${guid}`, `ai:guidance:${guid}`, `ai:session:${guid}`);
+    }
     /** 设置工具调用中的处理状态 */
     async setAIToolLoopProcessing(guid, processing) {
         if (processing) {
-            await this.redis.set(`ai:tool_loop_processing:${guid}`, "1");
+            const now = Date.now();
+            const state = {
+                processing: true,
+                startedAt: now,
+                updatedAt: now,
+            };
+            await this.redis.set(`ai:tool_loop_processing:${guid}`, JSON.stringify(state), "EX", TOOL_LOOP_TTL_SECONDS);
             return;
         }
         await this.redis.del(`ai:tool_loop_processing:${guid}`);
     }
     /** 获取工具调用中的处理状态 */
     async getAIToolLoopProcessing(guid) {
-        return (await this.redis.get(`ai:tool_loop_processing:${guid}`)) || "0";
+        const key = `ai:tool_loop_processing:${guid}`;
+        const processing = await this.redis.get(key);
+        if (!processing) {
+            return "0";
+        }
+        let state = null;
+        if (processing !== "1") {
+            try {
+                const parsed = JSON.parse(processing);
+                if (parsed?.processing === true) {
+                    state = parsed;
+                }
+            }
+            catch {
+                await this.clearAITransientState(guid);
+                return "0";
+            }
+            const updatedAt = Number(state?.updatedAt || state?.startedAt || 0);
+            if (!updatedAt || Date.now() - updatedAt > TOOL_LOOP_STALE_MS) {
+                await this.clearAITransientState(guid);
+                return "0";
+            }
+        }
+        const ttl = await this.redis.ttl(key);
+        if (ttl === -1) {
+            if (processing === "1") {
+                await this.clearAITransientState(guid);
+                return "0";
+            }
+            await this.redis.expire(key, TOOL_LOOP_TTL_SECONDS);
+        }
+        return "1";
     }
     /** 获取工具调用期间追加的引导消息 */
     async getAIGuidanceMessages(guid) {
@@ -482,13 +588,20 @@ class db {
         if (!queueStr) {
             return [];
         }
-        return JSON.parse(queueStr);
+        try {
+            const queue = JSON.parse(queueStr);
+            return Array.isArray(queue) ? queue : [];
+        }
+        catch {
+            await this.clearAIGuidanceMessages(guid);
+            return [];
+        }
     }
     /** 追加工具调用期间的引导消息 */
     async addAIGuidanceMessage(guid, data) {
         const queue = await this.getAIGuidanceMessages(guid);
         queue.push(data);
-        await this.redis.set(`ai:guidance:${guid}`, JSON.stringify(queue));
+        await this.redis.set(`ai:guidance:${guid}`, JSON.stringify(queue), "EX", TOOL_LOOP_TTL_SECONDS);
         return queue;
     }
     /** 提取并清空工具调用期间的引导消息 */

package/lib/data/help.json.js

@@ -136,6 +136,10 @@ var list = [
 				{
 					cmd: "/清空对话",
 					desc: "清空当前页面的对话记录。"
+				},
+				{
+					cmd: "/撤回",
+					desc: "引用一条消息发送撤回指令，自动撤回被引用的消息。"
 				}
 			]
 		}
@@ -200,6 +204,10 @@ var list = [
 				{
 					cmd: "/[开启|关闭]工具提示详情",
 					desc: "开启或关闭工具调用提示详情功能。开启后工具调用的提示消息会包含更多的详情信息。"
+				},
+				{
+					cmd: "/[开启|关闭]工具调用内容",
+					desc: "开启或关闭工具调用前模型返回内容的发送。开启后会发送工具调用响应中 content 的内容。"
 				}
 			]
 		}

package/lib/image/conponent/AiConfig.js

@@ -9,6 +9,7 @@ const cmds = [
     { cmd: "/切换模型 <模型名称>", desc: "切换当前使用的AI模型" },
     { cmd: "/<开启|关闭>仅艾特触发", desc: "开启或关闭仅艾特触发功能" },
     { cmd: "/<开启|关闭>工具", desc: "开启或关闭AI工具" },
+    { cmd: "/<开启|关闭>工具调用内容", desc: "开启或关闭工具调用前内容发送" },
     { cmd: "/<开启|关闭>复杂输出", desc: "开启或关闭复杂输出" },
     { cmd: "/<开启|关闭>好感度", desc: "开启或关闭好感度系统" },
     { cmd: "/清空对话", desc: "清空当前对话历史" },
@@ -76,7 +77,8 @@ function App(data) {
                         React.createElement(StatusItem, { label: "\u5DE5\u5177\u603B\u5F00\u5173", value: data.tools }),
                         React.createElement(StatusItem, { label: "\u5DE5\u5177\u63D0\u793A", value: data.toolPromptSwitch }),
                         React.createElement(StatusItem, { label: "\u5DE5\u5177\u63D0\u793A\u64A4\u56DE", value: data.toolPromptRevokeSwitch }),
-                        React.createElement(StatusItem, { label: "\u5DE5\u5177\u63D0\u793A\u4F20\u53C2", value: data.toolPromptArgsSwitch })),
+                        React.createElement(StatusItem, { label: "\u5DE5\u5177\u63D0\u793A\u4F20\u53C2", value: data.toolPromptArgsSwitch }),
+                        React.createElement(StatusItem, { label: "\u5DE5\u5177\u8C03\u7528\u5185\u5BB9", value: data.toolCallContentSwitch })),
                     React.createElement("div", { className: "pt-2 border-t border-white/10" },
                         React.createElement("div", { className: "flex items-center justify-between py-2" },
                             React.createElement("span", { className: " text-white/60" }, "\u5F53\u524D\u4F7F\u7528\u6A21\u578B"),

package/lib/middleware/mw.js

@@ -177,6 +177,7 @@ var mw = onMiddleware(selects, async (event, next) => {
         // 处理回复消息
         const replyData = event.value.message.find((item) => item.type === "reply");
         if (replyData) {
+            event["replyMessageId"] = String(replyData.data.id);
             const msg = await onebotClient.getMsg({
                 message_id: Number(replyData.data.id),
             });
@@ -233,6 +234,7 @@ var mw = onMiddleware(selects, async (event, next) => {
         })
             .join("");
         if (event.replyId && event.replyId !== "-1") {
+            event["replyMessageId"] = String(event.replyId);
             const replyMsg = await client.getMessage(event.replyId);
             console.log("获取回复", replyMsg);
             if (replyMsg) {
@@ -276,6 +278,7 @@ var mw = onMiddleware(selects, async (event, next) => {
                 ? [CDN_URL + event.value.fileMeta.url]
                 : [];
         if (event.value.replyToId) {
+            event["replyMessageId"] = String(event.value.replyToId);
             const channelMessages = await client.request({
                 method: "GET",
                 url: `/channels/${event.ChannelId}/messages/${event.value.replyToId}`,

package/lib/response/config/res.js

@@ -1,7 +1,7 @@
 import redisClient from '../../config.js';
 import { loadSkills } from '../../api/loadSkill.js';
 import App from '../../image/conponent/AiConfig.js';
-import { useMessage, Image, Text } from 'alemonjs';
+import { useMessage, Text, Image } from 'alemonjs';
 import { renderComponentIsHtmlToBuffer } from 'jsxp';
 import OpenAi from 'openai';
 
@@ -54,10 +54,64 @@ const archiveCurrentConversation = async (guid, reason, aiConfig) => {
         reason,
     });
 };
+const statusNumberFormatter = new Intl.NumberFormat("zh-CN");
+const formatNumberValue = (value) => {
+    return typeof value === "number" && Number.isFinite(value)
+        ? statusNumberFormatter.format(value)
+        : "未知";
+};
+const formatTokenValue = (value) => {
+    return formatNumberValue(value);
+};
+const formatAIContextStatus = (stats) => {
+    if (!stats) {
+        return "当前会话还没有 CAPI 上下文统计。";
+    }
+    const updatedAt = new Date(stats.updatedAt).toLocaleString("zh-CN", {
+        hour12: false,
+    });
+    const usageNote = stats.usageAvailable
+        ? ""
+        : "提示: 最近一次请求未返回 usage, 实际 token 统计可能不完整。";
+    const divider = "················";
+    return [
+        "当前AI状态：",
+        divider,
+        `模式: ${stats.mode.toUpperCase()}`,
+        `模型: ${stats.model || "未知"}`,
+        `更新时间: ${updatedAt}`,
+        `请求次数: ${formatNumberValue(stats.requestCount)}`,
+        divider,
+        "最近一次上下文：",
+        `消息数: ${formatNumberValue(stats.contextMessageCount)}`,
+        `上下文字符数: ${formatNumberValue(stats.contextCharLength)}`,
+        `上下文估算token: ${formatTokenValue(stats.estimatedContextTokens)}`,
+        `输入token: ${formatTokenValue(stats.promptTokens)}`,
+        `输出token: ${formatTokenValue(stats.completionTokens)}`,
+        `总token: ${formatTokenValue(stats.totalTokens)}`,
+        `缓存命中token: ${formatTokenValue(stats.cachedTokens)}`,
+        `缓存未命中token: ${formatTokenValue(stats.cacheMissTokens)}`,
+        divider,
+        "当前会话累计：",
+        `输入token: ${formatTokenValue(stats.totalPromptTokens)}`,
+        `输出token: ${formatTokenValue(stats.totalCompletionTokens)}`,
+        `总token: ${formatTokenValue(stats.totalTokensUsed)}`,
+        `缓存命中token: ${formatTokenValue(stats.totalCachedTokens)}`,
+        `缓存未命中token: ${formatTokenValue(stats.totalCacheMissTokens)}`,
+        usageNote,
+    ]
+        .filter((line) => line !== "")
+        .join("\n");
+};
 var res = onResponse(selects, async (e, next) => {
     // 创建
     const [message] = useMessage(e);
     const config = await redisClient.getAIConfig(e.guid);
+    // 查看AI状态
+    if (/^(\/|#)ai状态$/i.test(e.msg)) {
+        const stats = await redisClient.getAIContextStats(e.guid);
+        message.send(format(Text(formatAIContextStatus(stats))));
+    }
     // 查看AI配置
     if (/^(\/|#)(ai配置|当前提示词|查看提示词)$/i.test(e.msg)) {
         const complexResponse = (await redisClient.getComplexOutput(e.guid)) || "1"; // 复杂输出
@@ -73,6 +127,7 @@ var res = onResponse(selects, async (e, next) => {
         const toolPromptSwitch = await redisClient.getToolPromptSwitch(e.guid); // 工具提示开关
         const toolPromptRevokeSwitch = await redisClient.getToolPromptRevokeSwitch(e.guid); // 工具提示撤回开关
         const toolPromptArgsSwitch = await redisClient.getToolPromptArgsSwitch(e.guid); // 工具提示传参开关
+        const toolCallContentSwitch = await redisClient.getToolCallContentSwitch(e.guid); // 工具调用内容发送开关
         // 发送消息
         try {
             const scale = await redisClient.getRenderPrecision(e.guid);
@@ -93,6 +148,7 @@ var res = onResponse(selects, async (e, next) => {
                 toolPromptSwitch: toolPromptSwitch == "1",
                 toolPromptRevokeSwitch: toolPromptRevokeSwitch == "1",
                 toolPromptArgsSwitch: toolPromptArgsSwitch == "1",
+                toolCallContentSwitch: toolCallContentSwitch == "1",
             }, {
                 playwright: {
                     context: { deviceScaleFactor: scale },
@@ -102,11 +158,11 @@ var res = onResponse(selects, async (e, next) => {
                 message.send(format(Image(img)));
             }
             else {
-                message.send(format(Text(`当前AI配置：\n`), Text(`总开关: ${config.model != "" ? "开启" : "关闭"}\n`), Text(`工具: ${toolsIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`复杂输出: ${complexResponse == "1" ? "开启" : "关闭"}\n`), Text(`好感度开关: ${affectionIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`TTS回复开关: ${isOpenTTSReply == "1" ? "开启" : "关闭"}\n`), Text(`深度思考: ${deepThinkingIsOpen == "1" ? "默认" : "关闭"}\n`), Text(`仅艾特触发: ${atTriggerSwitch == "1" ? "开启" : "关闭"}\n`), Text(`模型: ${config.model || "未设置"}\n`), Text(`提示词: ${config.systemPrompt || "未设置"}\n`), Text(`当前AI: ${currentAI || "未设置"}\n`), Text(`AI数量: ${aiList.length ? aiList.length : "暂无AI配置"}`)));
+                message.send(format(Text(`当前AI配置：\n`), Text(`总开关: ${config.model != "" ? "开启" : "关闭"}\n`), Text(`工具: ${toolsIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`工具调用内容: ${toolCallContentSwitch == "1" ? "开启" : "关闭"}\n`), Text(`复杂输出: ${complexResponse == "1" ? "开启" : "关闭"}\n`), Text(`好感度开关: ${affectionIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`TTS回复开关: ${isOpenTTSReply == "1" ? "开启" : "关闭"}\n`), Text(`深度思考: ${deepThinkingIsOpen == "1" ? "默认" : "关闭"}\n`), Text(`仅艾特触发: ${atTriggerSwitch == "1" ? "开启" : "关闭"}\n`), Text(`模型: ${config.model || "未设置"}\n`), Text(`提示词: ${config.systemPrompt || "未设置"}\n`), Text(`当前AI: ${currentAI || "未设置"}\n`), Text(`AI数量: ${aiList.length ? aiList.length : "暂无AI配置"}`)));
             }
         }
         catch (error) {
-            message.send(format(Text(`当前AI配置：\n`), Text(`总开关: ${config.model != "" ? "开启" : "关闭"}\n`), Text(`工具: ${toolsIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`复杂输出: ${complexResponse == "1" ? "开启" : "关闭"}\n`), Text(`好感度开关: ${affectionIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`TTS回复开关: ${isOpenTTSReply == "1" ? "开启" : "关闭"}\n`), Text(`深度思考: ${deepThinkingIsOpen == "1" ? "默认" : "关闭"}\n`), Text(`仅艾特触发: ${atTriggerSwitch == "1" ? "开启" : "关闭"}\n`), Text(`模型: ${config.model || "未设置"}\n`), Text(`提示词: ${config.systemPrompt || "未设置"}\n`), Text(`当前AI: ${currentAI || "未设置"}\n`), Text(`AI数量: ${aiList.length ? aiList.length : "暂无AI配置"}`)));
+            message.send(format(Text(`当前AI配置：\n`), Text(`总开关: ${config.model != "" ? "开启" : "关闭"}\n`), Text(`工具: ${toolsIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`工具调用内容: ${toolCallContentSwitch == "1" ? "开启" : "关闭"}\n`), Text(`复杂输出: ${complexResponse == "1" ? "开启" : "关闭"}\n`), Text(`好感度开关: ${affectionIsOpen == "1" ? "开启" : "关闭"}\n`), Text(`TTS回复开关: ${isOpenTTSReply == "1" ? "开启" : "关闭"}\n`), Text(`深度思考: ${deepThinkingIsOpen == "1" ? "默认" : "关闭"}\n`), Text(`仅艾特触发: ${atTriggerSwitch == "1" ? "开启" : "关闭"}\n`), Text(`模型: ${config.model || "未设置"}\n`), Text(`提示词: ${config.systemPrompt || "未设置"}\n`), Text(`当前AI: ${currentAI || "未设置"}\n`), Text(`AI数量: ${aiList.length ? aiList.length : "暂无AI配置"}`)));
         }
     }
     // 查看AI列表

package/lib/response/revoke/res.js

@@ -0,0 +1,34 @@
+import { useMessage, Text } from 'alemonjs';
+
+const selects = onSelects(["message.create", "private.message.create"]);
+const normalizeMessageId = (value) => {
+    if (value === undefined || value === null)
+        return undefined;
+    const text = String(value).trim();
+    return text === "" || text === "-1" ? undefined : text;
+};
+const getReplyMessageId = (e) => {
+    const replySegment = Array.isArray(e.value?.message)
+        ? e.value.message.find((item) => item?.type === "reply")
+        : undefined;
+    return (normalizeMessageId(e.replyMessageId) ||
+        normalizeMessageId(replySegment?.data?.id) ||
+        normalizeMessageId(e.replyId) ||
+        normalizeMessageId(e.value?.replyToId) ||
+        normalizeMessageId(e.reply?.message_id) ||
+        normalizeMessageId(e.reply?.id));
+};
+var res = onResponse(selects, async (e) => {
+    const [message] = useMessage(e);
+    const targetMessageId = getReplyMessageId(e);
+    if (!targetMessageId) {
+        await message.send(format(Text("请引用一条消息后再发送 /撤回")));
+        return;
+    }
+    const result = await message.delete({ messageId: targetMessageId });
+    if (result.code !== 2000) {
+        await message.send(format(Text("撤回失败，可能是平台不支持或机器人没有权限")));
+    }
+});
+
+export { res as default, selects };

package/lib/response/setting/res.js

@@ -493,6 +493,22 @@ var res = onResponse(selects, async (e, next) => {
         message.send(format(Text(`已${enable ? "开启" : "关闭"}工具提示详情功能 !`)));
         return;
     }
+    // 控制工具调用前 content 发送开关
+    if (/(\/|#)(开启|关闭)工具调用内容$/i.test(e.msg)) {
+        if (!e.IsMaster) {
+            return;
+        }
+        const match = e.msg.match(/(\/|#)(开启|关闭)工具调用内容$/i);
+        if (!match) {
+            message.send(format(Text("格式错误，请按照 格式：/开启工具调用内容 或 /关闭工具调用内容 进行设置")));
+            return;
+        }
+        const [, , action] = match;
+        const enable = action === "开启";
+        await redisClient.setToolCallContentSwitch(e.guid, enable);
+        message.send(format(Text(`已${enable ? "开启" : "关闭"}工具调用内容发送功能 !`)));
+        return;
+    }
     // 控制工具开关
     if (/(\/|#)(开启|关闭)工具(.*)$/i.test(e.msg)) {
         if (!e.IsMaster) {

package/lib/response/zreply/capi.js

@@ -43,6 +43,56 @@ const appendPendingGuidanceMessages = async (guid, messages) => {
     await redisClient.addAIChatHistoryBatch(guid, guidanceMessages);
     return guidanceMessages;
 };
+const getTextLength = (value) => {
+    if (typeof value === "string") {
+        return value.length;
+    }
+    if (Array.isArray(value)) {
+        return value.reduce((sum, item) => sum + getTextLength(item), 0);
+    }
+    if (value && typeof value === "object") {
+        return Object.values(value).reduce((sum, item) => sum + getTextLength(item), 0);
+    }
+    return 0;
+};
+const getNumber = (value) => {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+};
+const extractCachedTokens = (usage) => {
+    return getNumber(usage?.prompt_tokens_details?.cached_tokens ??
+        usage?.input_tokens_details?.cached_tokens ??
+        usage?.prompt_cache_hit_tokens);
+};
+const extractCacheMissTokens = (usage, promptTokens) => {
+    const explicitMissTokens = getNumber(usage?.prompt_cache_miss_tokens);
+    if (explicitMissTokens !== null) {
+        return explicitMissTokens;
+    }
+    const cachedTokens = extractCachedTokens(usage);
+    if (promptTokens !== null && cachedTokens !== null) {
+        return Math.max(promptTokens - cachedTokens, 0);
+    }
+    return null;
+};
+const recordCapiContextStats = async (guid, model, messages, completion) => {
+    const usage = completion?.usage;
+    const promptTokens = getNumber(usage?.prompt_tokens ?? usage?.input_tokens);
+    const completionTokens = getNumber(usage?.completion_tokens ?? usage?.output_tokens);
+    const contextCharLength = getTextLength(messages);
+    await redisClient.recordAIContextStats(guid, {
+        mode: "capi",
+        model,
+        contextMessageCount: messages.length,
+        contextCharLength,
+        estimatedContextTokens: Math.ceil(contextCharLength / 4),
+        promptTokens,
+        completionTokens,
+        totalTokens: getNumber(usage?.total_tokens),
+        cachedTokens: extractCachedTokens(usage),
+        cacheMissTokens: extractCacheMissTokens(usage, promptTokens),
+        usageAvailable: Boolean(usage),
+    });
+};
 const CApiReply = async (e) => {
     console.log("e.UserId", e.UserId, e.bot);
     const cfg = await getChatConfig(e);
@@ -81,6 +131,7 @@ const CApiReply = async (e) => {
         createParams["stream"] = false;
         // log("请求AI，参数：", createParams);
         const stream = (await openai.chat.completions.create(createParams));
+        await recordCapiContextStats(e.guid, cfg.config.model, messages, stream);
         log("AI回复原始数据:\n", JSON.stringify(stream, null, 2));
         let fullContent = "";
         let toolCalls = [];
@@ -114,7 +165,9 @@ const CApiReply = async (e) => {
             return;
         }
         await redisClient.addAIChatHistory(e.guid, usermessage);
-        if (res.choices[0].message?.tool_calls && fullContent.trim() !== "") {
+        if (cfg.toolConfig.toolCallContentSwitch === "1" &&
+            res.choices[0].message?.tool_calls &&
+            fullContent.trim() !== "") {
             await sendAIReply(fullContent, cfg, e, message);
         }
         // 检查是否有工具调用需要处理
@@ -140,6 +193,7 @@ const CApiReply = async (e) => {
                     }
                     Object.assign(params, getDeepThoughtReasoning(cfg));
                     res = await openai.chat.completions.create(params);
+                    await recordCapiContextStats(e.guid, cfg.config.model, messages, res);
                     if (!res.choices || res.choices.length === 0) {
                         log("AI未返回内容");
                         return;
@@ -243,6 +297,7 @@ const CApiReply = async (e) => {
                 // log("重新请求AI，参数：", params);
                 // 重新请求
                 res = await openai.chat.completions.create(params);
+                await recordCapiContextStats(e.guid, cfg.config.model, messages, res);
                 // 检查是否还有工具调用需要处理
                 if (!res.choices || res.choices.length === 0) {
                     log("AI未返回内容");
@@ -273,6 +328,7 @@ const CApiReply = async (e) => {
         };
     }
     catch (error) {
+        await redisClient.setAIToolLoopProcessing(e.guid, false);
         console.error("AI回复出错", error);
         message.send(format(Text("AI回复出错了\n" + error)));
         return {

package/lib/response/zreply/getChatConfig.js

@@ -75,6 +75,8 @@ const getChatConfig = async (e) => {
         toolPromptRevokeSwitch: await redisClient.getToolPromptRevokeSwitch(e.guid),
         /** 工具提示传参开关 */
         toolPromptArgsSwitch: await redisClient.getToolPromptArgsSwitch(e.guid),
+        /** 工具调用前 content 发送开关 */
+        toolCallContentSwitch: await redisClient.getToolCallContentSwitch(e.guid),
     };
     /** 技能列表 */
     const skills = loadSkills();
@@ -83,33 +85,34 @@ const getChatConfig = async (e) => {
     /** 机器人昵称 */
     const botName = e.bot.nickname || "小咸鱼";
     const memoryPrompt = relevantMemoryContext
-        ? `
-  ## 系统预检索记忆
-  以下内容是系统根据当前话题自动检索到的相关长期记忆和历史归档, 回答时优先参考与当前话题直接相关的部分; 如果与用户本轮最新表述冲突, 以用户本轮消息为准
-  ${relevantMemoryContext}
+        ? `
+  ## 系统预检索记忆
+  以下内容是系统根据当前话题自动检索到的相关长期记忆和历史归档, 回答时优先参考与当前话题直接相关的部分; 如果与用户本轮最新表述冲突, 以用户本轮消息为准
+  ${relevantMemoryContext}
   `
         : "";
     /** 系统提示词 */
-    const systemPrompt = `
-  # AI助手回复规范
-  请严格按照以下规范进行回复, 不要添加任何不必要的内容, 也不要删除或修改规范中的任何内容, 以确保回复能够被正确解析和处理
-  
-  ## 技能
-  在遇到用户需要执行特定操作时,先获取对应的技能,如果有可用技能,获取该技能,并严格按照技能文档要求的格式调用, 不要添加任何多余的内容, 也不要删除或修改规范中的任何内容, 以确保技能能够被正确解析和处理
-  当没有技能可以应对需求时, 就自行挑选合适的工具函数来完成用户的需求
-  如果用户提到本地仓库、知识库、参考项目、之前克隆过的项目，或者你准备说"本地没有"、"仓库里没有"、"没找到"之类的话，必须先检查 public/{guid} 内现有内容，优先搜索 knowledge/ 目录；至少先调用一次 AgentSearchFiles、AgentListFiles 或读取相关技能后再下结论
-  如果你不知道之前项目所在的 guid，先调用 AgentListWorkspaces 找到 public/ 下已有工作目录，再继续用 AgentListFiles、AgentSearchFiles 或 AgentReadFileLines；不要用 exec 查 public/{guid}，因为 exec 的默认工作目录不是那里
-  如果用户要查看分支、确认当前分支、查看远端或切换分支，优先使用 AgentGitOperation，不要自己拼 git commit、push、pull、merge、rebase、reset 等命令
-  如果用户在继续之前的话题、问你记不记得、提到上次/刚才/之前聊过的内容，先参考“系统预检索记忆”；如果系统预检索内容还不够，再调用 MemoryOperation，优先使用 chatHistory 的 search:关键词 或 guid:id 去补充历史上下文，然后再回答
-  
-  调用执行脚本类型的工具时, 务必确保脚本安全, 不得执行对服务器有伤害的脚本
-  ---
-  技能列表:
-  ${skills.map((skill) => `- ${skill.name}: ${skill.description}`).join("\n")}
-  ---
-  ${memoryPrompt}
-  
-  ## 关于回复格式:
+    const systemPrompt = `
+  # AI助手回复规范
+  请严格按照以下规范进行回复, 不要添加任何不必要的内容, 也不要删除或修改规范中的任何内容, 以确保回复能够被正确解析和处理
+  
+  ## 技能
+  在遇到用户需要执行特定操作时,先获取对应的技能,如果有可用技能,获取该技能,并严格按照技能文档要求的格式调用, 不要添加任何多余的内容, 也不要删除或修改规范中的任何内容, 以确保技能能够被正确解析和处理
+  当没有技能可以应对需求时, 就自行挑选合适的工具函数来完成用户的需求
+  如果用户提到本地仓库、知识库、参考项目、之前克隆过的项目，或者你准备说"本地没有"、"仓库里没有"、"没找到"之类的话，必须先检查 public/{guid} 内现有内容，优先搜索 knowledge/ 目录；至少先调用一次 AgentSearchFiles、AgentListFiles 或读取相关技能后再下结论
+  如果你不知道之前项目所在的 guid，先调用 AgentListWorkspaces 找到 public/ 下已有工作目录，再继续用 AgentListFiles、AgentSearchFiles 或 AgentReadFileLines；不要用 exec 查 public/{guid}，因为 exec 的默认工作目录不是那里
+  如果用户需要直接执行服务器运维指令、查看服务状态、管理 Docker/PM2/systemctl、查看日志或部署服务，使用 RunServerCommand；它会自动审核指令安全，不要改用 exec。调用 RunServerCommand 时 reviewGuid 必填，必须传下方环境信息里的“当前群号(reviewGuid)”，不要传 public/{guid} 工作目录ID
+  如果用户要查看分支、确认当前分支、查看远端或切换分支，优先使用 AgentGitOperation，不要自己拼 git commit、push、pull、merge、rebase、reset 等命令
+  如果用户在继续之前的话题、问你记不记得、提到上次/刚才/之前聊过的内容，先参考“系统预检索记忆”；如果系统预检索内容还不够，再调用 MemoryOperation，优先使用 chatHistory 的 search:关键词 或 guid:id 去补充历史上下文，然后再回答
+  
+  调用执行脚本类型的工具时, 务必确保脚本安全, 不得执行对服务器有伤害的脚本
+  ---
+  技能列表:
+  ${skills.map((skill) => `- ${skill.name}: ${skill.description}`).join("\n")}
+  ---
+  ${memoryPrompt}
+  
+  ## 关于回复格式:
   ### 用户发言
   - 格式: [私聊]用户昵称(用户id)(发送时间):消息内容
   当场景为私聊时, 用户昵称前方会出现[私聊]标识
@@ -158,15 +161,15 @@ const getChatConfig = async (e) => {
   #### 基础状态信息:
   这里的信息会实时变化,根据需要进行获取使用
   当前群时间:${getGroupTimeString()}
-  当前群号:${e.guid}
+  当前群号(reviewGuid):${e.guid}
   当前群名称:${e.GroupName || "无"}
   当前聊天平台:${e.Platform}
   当前框架:alemonjs-aichat
   ${e.ClientError ? `当前错误信息:${e.ClientError}` : ""}
   `;
-    const RapiSystemPrompt = `
-请严格按照以下规范进行回复, 以确保回复能够被正确解析和处理
-1. 文本消息：
+    const RapiSystemPrompt = `
+请严格按照以下规范进行回复, 以确保回复能够被正确解析和处理
+1. 文本消息：
 ${botName}::text<<<EOF
 文本内容
 EOF
@@ -185,14 +188,14 @@ ${botName}::audio voice=音色 内容
 =====================
 
 - 不允许使用任何其他格式
-- 不允许输出解释说明
-- 不允许夹杂 markdown
-- tool调用前可以先输出一行说明
-- 每一条输出必须独立一行
-- 允许多段输出叠加, 例如:
-${botName}::text 这是第一条消息
-${botName}::text 这是第二条消息
-${memoryPrompt ? `\n【系统预检索记忆】\n${relevantMemoryContext}\n` : ""}
+- 不允许输出解释说明
+- 不允许夹杂 markdown
+- tool调用前可以先输出一行说明
+- 每一条输出必须独立一行
+- 允许多段输出叠加, 例如:
+${botName}::text 这是第一条消息
+${botName}::text 这是第二条消息
+${memoryPrompt ? `\n【系统预检索记忆】\n${relevantMemoryContext}\n` : ""}
   `;
     return {
         /** AI配置 */

package/lib/response/zreply/tools.js

@@ -1,4 +1,4 @@
-import { format, Audio, Mention, Text, ImageURL, ImageFile } from 'alemonjs';
+import { format, Audio, ImageURL, ImageFile, Text, Mention } from 'alemonjs';
 import redisClient from '../../config.js';
 import { TTSClient } from '../../api/tts.js';
 import { createTTSMessage } from './tts.js';

package/lib/routes/commands.js

@@ -7,6 +7,11 @@ const children = [
         regular: /(\/|#)(ai)?(指令|帮助|菜单|功能)$/i,
         handler: lazy(() => import('../response/help/res.js')),
     },
+    // revoke
+    {
+        regular: /^(\/|#)撤回$/i,
+        handler: lazy(() => import('../response/revoke/res.js')),
+    },
     // tools (多条正则合并)
     {
         regular: Regular.or(/(\/|#)(ai)?(pt|p图|ps|修图)(.*)$/i, /(\/|#)(ai)?(画图)(.*)$/i, /(\/|#)(ai)?(生成视频)(.*)$/i, /(\/|#)(ai)?(查询)(.*)$/i, /(\/|#)(ai)?(开启|关闭)?画图提示词优化$/i, /^(\/|#)(.+)说([\s\S]*)$/i, /^(\/|#)安装语音(模型)?(.+)$/i, /^(\/|#)看魔法$/i),
@@ -14,12 +19,12 @@ const children = [
     },
     // config
     {
-        regular: Regular.or(/^(\/|#)(ai配置|当前提示词|查看提示词)$/i, /^(\/|#)ai列表$/i, /^(\/|#)提示词列表$/i, /^(\/|#)清空对话$/i, /^(\/|#)清空(所有|全部)对话$/i, /^(\/|#)get (.+)$/i, /(\/|#)(开启)?(new|新对话|新会话)$/i),
+        regular: Regular.or(/^(\/|#)(ai配置|当前提示词|查看提示词)$/i, /^(\/|#)ai列表$/i, /^(\/|#)提示词列表$/i, /^(\/|#)清空对话$/i, /^(\/|#)清空(所有|全部)对话$/i, /^(\/|#)get (.+)$/i, /(\/|#)(开启)?(new|新对话|新会话)$/i, /^(\/|#)ai状态$/),
         handler: lazy(() => import('../response/config/res.js')),
     },
     // setting (包含大量子命令)
     {
-        regular: Regular.or(/(\/|#)添加ai$/i, /(\/|#)添加ai\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/i, /(\/|#)(切换)(ai|配置) ?(.*)/i, /(\/|#)添加提示词$/i, /(\/|#)添加提示词 (\S+) ([\s\S]+)/i, /(\/|#)(删除)(提示词|提示词列表) ?(.*)/i, /(\/|#)(切换|设置)提示词 ?(.*)$/i, /(\/|#)清空提示词$/i, /(\/|#)删除ai\s(\S+)$/i, /(\/|#)(开启|启用|关闭|禁用)好感度$/i, /(\/|#)(开启|关闭)(全部)?聊天$/i, /(\/|#)(开启|关闭)语音回复$/i, /(\/|#)切换图床(.*)$/i, /(\/|#)修改 ?(.+) ?模型 ?(.+)$/i, /(\/|#)(关闭|开启)复杂(输出|回复)$/i, /(\/|#)(关闭|禁止|不可以|不允许|开启|可以|允许)(涩涩|色色)$/i, /(\/|#)切换模型(.*)$/i, /(\/|#)(关闭|开启)主动(搭话|回复)$/i, /(\/|#)(开启|关闭)深度思考$/i, /(\/|#)(设置|修改)(ai)?(.*)rapi模式(开启|关闭)$/i, /(\/|#)(开启|关闭)仅艾特触发$/i, /(\/|#)添加正则规则 (.+)$/i, /(\/|#)(删除|移除)正则规则 (.+)$/i, /(\/|#)正则规则列表$/i, /(\/|#)清空正则规则$/i, /(\/|#)切换群容器$/i, /(\/|#)切换用户容器$/i, /(\/|#)切换系统环境$/i, /(\/|#)工具列表$/i, /(\/|#)(开启|关闭)(MCP)?工具$/i, /(\/|#)(开启|关闭)工具(.*)$/i, /(\/|#)(开启|关闭)工具提示$/i, /(\/|#)(开启|关闭)工具(调用)?提示撤回$/i, /(\/|#)(开启|关闭)工具(调用)?提示详情$/i, /(\/|#)测试$/i, /(\/|#)设置渲染精度\s*(中|高|超高)$/i),
+        regular: Regular.or(/(\/|#)添加ai$/i, /(\/|#)添加ai\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/i, /(\/|#)(切换)(ai|配置) ?(.*)/i, /(\/|#)添加提示词$/i, /(\/|#)添加提示词 (\S+) ([\s\S]+)/i, /(\/|#)(删除)(提示词|提示词列表) ?(.*)/i, /(\/|#)(切换|设置)提示词 ?(.*)$/i, /(\/|#)清空提示词$/i, /(\/|#)删除ai\s(\S+)$/i, /(\/|#)(开启|启用|关闭|禁用)好感度$/i, /(\/|#)(开启|关闭)(全部)?聊天$/i, /(\/|#)(开启|关闭)语音回复$/i, /(\/|#)切换图床(.*)$/i, /(\/|#)修改 ?(.+) ?模型 ?(.+)$/i, /(\/|#)(关闭|开启)复杂(输出|回复)$/i, /(\/|#)(关闭|禁止|不可以|不允许|开启|可以|允许)(涩涩|色色)$/i, /(\/|#)切换模型(.*)$/i, /(\/|#)(关闭|开启)主动(搭话|回复)$/i, /(\/|#)(开启|关闭)深度思考$/i, /(\/|#)(设置|修改)(ai)?(.*)rapi模式(开启|关闭)$/i, /(\/|#)(开启|关闭)仅艾特触发$/i, /(\/|#)添加正则规则 (.+)$/i, /(\/|#)(删除|移除)正则规则 (.+)$/i, /(\/|#)正则规则列表$/i, /(\/|#)清空正则规则$/i, /(\/|#)切换群容器$/i, /(\/|#)切换用户容器$/i, /(\/|#)切换系统环境$/i, /(\/|#)工具列表$/i, /(\/|#)(开启|关闭)(MCP)?工具$/i, /(\/|#)(开启|关闭)工具(.*)$/i, /(\/|#)(开启|关闭)工具提示$/i, /(\/|#)(开启|关闭)工具(调用)?提示撤回$/i, /(\/|#)(开启|关闭)工具(调用)?提示详情$/i, /(\/|#)(开启|关闭)工具调用内容$/i, /(\/|#)测试$/i, /(\/|#)设置渲染精度\s*(中|高|超高)$/i),
         handler: lazy(() => import('../response/setting/res.js')),
     },
     // affection

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs-aichat",
-  "version": "1.0.35",
+  "version": "1.0.38",
   "description": "alemonjs-aichat",
   "author": "suancaixianyu",
   "license": "MIT",
@@ -45,6 +45,7 @@
   },
   "dependencies": {
     "@ai-sdk/xai": "^3.0.60",
+    "@alemonjs/scbbs": "file:../scbbs",
     "@aws-sdk/client-s3": "^3.975.0",
     "@aws-sdk/s3-request-presigner": "^3.975.0",
     "ai": "^6.0.105",