alemonjs-aichat 1.0.21 → 1.0.22

package/lib/api/aitools.js

@@ -192,6 +192,23 @@ const tools = [
             },
         },
     },
+    {
+        type: "function",
+        function: {
+            name: "EvalCode",
+            description: "执行JavaScript代码",
+            parameters: {
+                type: "object",
+                properties: {
+                    code: {
+                        type: "string",
+                        description: "要执行的JavaScript代码",
+                    },
+                },
+                required: ["code"],
+            },
+        },
+    },
 ];
 const availableTools = {
     /**
@@ -611,6 +628,27 @@ const availableTools = {
             });
         });
     },
+    /**
+     * 执行eval
+     * @param code 代码字符串
+     * @returns 执行结果
+     */
+    EvalCode: async ({ code }) => {
+        try {
+            // eslint-disable-next-line no-eval
+            const result = eval(code);
+            return result;
+        }
+        catch (error) {
+            console.error(`Error executing code: ${error}`);
+            return `Error: ${error}`;
+        }
+    },
+    /**
+     * 获取技能详情
+     * @param skillName 技能名称
+     * @returns 技能详情
+     */
     getSKILLDetail: async ({ skillName }) => {
         const skill = loadSkillDetail(skillName);
         return skill;

package/lib/api/loadSkill.js

@@ -4,11 +4,14 @@ import { fileURLToPath } from 'url';
 import { getConfigValue } from 'alemonjs';
 
 // 获取skills/下的文件夹,读取文件夹中的SKILL.md文件,并将其内容解析成对象返回
-getConfigValue().aiChat || {};
+const value = getConfigValue().aiChat || {};
 const currentDir = path.dirname(fileURLToPath(import.meta.url));
-// 获取技能列表的简介和名称
-const loadSkills = () => {
-    const skillsDir = path.join(currentDir, "../../skills");
+// 通用函数: 根据路径获取技能列表
+const loadSkillsFromPath = (skillsDir) => {
+    if (!fs.existsSync(skillsDir)) {
+        console.warn(`技能目录 ${skillsDir} 不存在`);
+        return [];
+    }
     const skillFolders = fs.readdirSync(skillsDir).filter((file) => {
         const skillPath = path.join(skillsDir, file);
         return fs.statSync(skillPath).isDirectory();
@@ -37,9 +40,20 @@ const loadSkills = () => {
             };
         }
     });
-    console.log(`加载技能: ${skills.length}个`);
     return skills;
 };
+// 获取技能列表的简介和名称
+const loadSkills = () => {
+    const skillsDir = path.join(currentDir, "../../skills");
+    const skills = loadSkillsFromPath(skillsDir);
+    const externalSkills = loadExternalSkills();
+    const allSkills = [...skills, ...externalSkills];
+    // 根据name和description去重
+    const uniqueSkills = allSkills.filter((skill, index, self) => index ===
+        self.findIndex((s) => s.name === skill.name && s.description === skill.description));
+    console.log(`加载技能: ${uniqueSkills.length}个`);
+    return uniqueSkills;
+};
 // 获取某个技能的详情, 通过技能名称匹配对应文件夹下的所有md文件,将内容一并返回
 const loadSkillDetail = (skillName) => {
     const skillsDir = path.join(currentDir, "../../skills");
@@ -68,5 +82,20 @@ const loadSkillDetail = (skillName) => {
         details,
     };
 };
+// 加载外部skills, 通过配置文件中的skills_dir字段指定技能目录,读取该目录下的技能文件夹,并将其内容解析成对象返回
+const loadExternalSkills = () => {
+    if (Array.isArray(value.skills_dir)) {
+        // 如果是数组,加载所有目录下的技能
+        const allSkills = value.skills_dir.flatMap((dir) => {
+            return loadSkillsFromPath(dir);
+        });
+        console.log(`加载外部技能: ${allSkills.length}个`);
+        return allSkills;
+    }
+    const skillsDir = value.skills_dir || path.join(currentDir, "../../skills");
+    const skills = loadSkillsFromPath(skillsDir);
+    console.log(`加载外部技能: ${skills.length}个`);
+    return skills;
+};
 
-export { loadSkillDetail, loadSkills };
+export { loadExternalSkills, loadSkillDetail, loadSkills, loadSkillsFromPath };

package/lib/config.js

@@ -11,6 +11,7 @@ class db {
         temperature: 0.7,
         max_tokens: 150,
         systemPrompt: "",
+        rapi: false,
     };
     constructor(redisConfig) {
         this.redis =
@@ -132,6 +133,17 @@ class db {
         await this.setAIConfig(guid, aiConfig);
         return aiConfig;
     }
+    /** 切换AI的RAPI模式 */
+    async switchModelRAPI(aiName, enable) {
+        const aiConfigStr = await this.redis.get(`ai:list:${aiName}`);
+        if (!aiConfigStr) {
+            console.log("切换失败, 无此模型");
+            return;
+        }
+        const aiConfig = JSON.parse(aiConfigStr);
+        aiConfig.rapi = enable;
+        await this.setAIList(aiName, aiConfig);
+    }
     /** 获取提示词列表 */
     async getPromptList() {
         const keys = await this.redis.keys("ai:prompt:*");

package/lib/data/help.json.js

@@ -1,6 +1,6 @@
 var title = "IA聊天插件";
 var name = "aichat";
-var version = "v1.0.16";
+var version = "v1.0.22";
 var by = "AlemonJS";
 var list = [
 	{

package/lib/response/config/res.js

@@ -14,9 +14,10 @@ var res = onResponse(selects, async (e, next) => {
         const affectionIsOpen = await redisClient.getAffectionSwitch(e.guid); // 好感度开关
         const isOpenTTSReply = await redisClient.getTTSResponseSwitch(e.guid); // TTS回复开关
         const toolsIsOpen = await redisClient.getToolSwitch(e.guid); // 工具开关
+        const deepThinkingIsOpen = await redisClient.getDeepThoughtSwitch(e.guid); // 深度思考开关
         const aiList = await redisClient.getAIList();
         // 发送消息
-        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(`模型: ${config.model || "未设置"}\n`), Text(`提示词: ${config.systemPrompt || "未设置"}\n`), Text(`AI数量: ${aiList.length ? aiList.length : "暂无AI配置"}`)));
+        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(`模型: ${config.model || "未设置"}\n`), Text(`提示词: ${config.systemPrompt || "未设置"}\n`), Text(`AI数量: ${aiList.length ? aiList.length : "暂无AI配置"}`)));
     }
     // 查看AI列表
     if (/^(\/|#)ai列表$/i.test(e.msg)) {

package/lib/response/setting/res.js

@@ -315,6 +315,33 @@ var res = onResponse(selects, async (e, next) => {
         message.send(format(Text(`已${enable ? "开启" : "关闭"}主动搭话功能 !`)));
         return;
     }
+    // 设置深度思考开关
+    if (/(\/|#)(开启|关闭)深度思考$/i.test(e.msg)) {
+        const match = e.msg.match(/(\/|#)(开启|关闭)深度思考$/i);
+        if (!match) {
+            message.send(format(Text("格式错误，请按照 格式：/开启深度思考 或 /关闭深度思考 进行设置")));
+            return;
+        }
+        const [, , action] = match;
+        const enable = action === "开启";
+        await redisClient.setDeepThoughtSwitch(e.guid, enable);
+        message.send(format(Text(`已${enable ? "开启" : "关闭"}深度思考功能 !`)));
+        return;
+    }
+    // 设置ai的RAPI模式开关
+    if (/(\/|#)(设置|修改)(ai)?(.*)rapi模式(开启|关闭)$/i.test(e.msg)) {
+        const match = e.msg.match(/(\/|#)(设置|修改)(ai)?(.*)rapi模式(开启|关闭)$/i);
+        if (!match) {
+            message.send(format(Text("格式错误，请按照 格式：/设置 rapi模式 开启 或 /设置 rapi模式 关闭 进行设置")));
+            return;
+        }
+        const [, , , , aiName, action] = match;
+        const enable = action === "开启";
+        if (aiName.trim()) {
+            await redisClient.switchModelRAPI(aiName.trim(), enable);
+            message.send(format(Text(`已${enable ? "开启" : "关闭"} AI ${aiName.trim()} 的 RAPI 模式 !`)));
+        }
+    }
     // 无匹配则继续下一个响应器
     next();
 });

package/lib/response/zreply/rapi.res.js

@@ -0,0 +1,566 @@
+import { API } from '@alemonjs/onebot';
+import { emojiMap } from '../../emoji.js';
+import { uploadImageToR2 } from '../../s3.js';
+import { getConfigValue, useMessage, Text, Mention, ImageFile, ImageURL, useClient } from 'alemonjs';
+import { log } from 'console';
+import OpenAi from 'openai';
+import { TTSClient } from '../../api/tts.js';
+import { getTimeString } from '../../api/format.js';
+import { tools, availableTools } from '../../api/aitools.js';
+import { loadSkills } from '../../api/loadSkill.js';
+import redisClient from '../../config.js';
+import fileUrl from '../../assets/error.png.js';
+
+const value = getConfigValue().aiChat || {};
+const selects = onSelects(["message.create", "private.message.create"]);
+let ttsClient;
+let currentModel = "派蒙-默认"; // 默认音色
+// ====================== 新版会话 ID 存储 ======================
+const sessionKey = {}; // 按群/用户ID保存会话ID
+// ============================================================
+var rapi_res = onResponse(selects, async (e, next) => {
+    console.log("e.UserId", e.UserId, e.bot);
+    // 如果是命令则跳过
+    if (e.msg.startsWith("/") ||
+        e.msg.startsWith("#") ||
+        e.UserId == e.bot.user_id) {
+        next();
+        return;
+    }
+    const complexOutputIsOpen = await redisClient.getComplexOutput(e.guid); // 复杂输出
+    const affectionIsOpen = await redisClient.getAffectionSwitch(e.guid); // 好感度开关
+    const isOpenTTSReply = await redisClient.getTTSResponseSwitch(e.guid); // TTS回复开关
+    const isOpenR18 = await redisClient.getR18Switch(e.guid); // R18开关
+    const proactiveSwitch = await redisClient.getProactiveSwitch(e.guid); // 主动搭话开关
+    const deepThoughtSwitch = await redisClient.getDeepThoughtSwitch(e.guid); // 深度思考开关
+    console.log("isOpenR18", isOpenR18, "proactiveSwitch", proactiveSwitch, "deepThoughtSwitch", deepThoughtSwitch);
+    const skills = loadSkills(); // 加载技能列表
+    // 创建消息
+    const [message] = useMessage(e);
+    const config = await redisClient.getAIConfig(e.guid);
+    const historyMessages = await redisClient.getAIChatHistory(e.guid);
+    const affections = await redisClient.getAffectionLevelAll(e.guid);
+    const imgs = [];
+    let rawMessage = e.value.raw_message || e.raw_message || e.msg;
+    const botName = e.bot.nickname || "小咸鱼";
+    const systemPrompt = `
+# AI助手回复规范
+请严格按照以下规范进行回复, 不要添加任何不必要的内容, 也不要删除或修改规范中的任何内容, 以确保回复能够被正确解析和处理
+
+## 技能
+在遇到用户需要执行特定操作时,先获取对应的技能,如果有可用技能,获取该技能,并严格按照技能文档要求的格式调用, 不要添加任何多余的内容, 也不要删除或修改规范中的任何内容, 以确保技能能够被正确解析和处理
+当没有技能可以应对需求时, 就自行挑选合适的工具函数来完成用户的需求
+---
+技能列表:
+${skills.map((skill) => `- ${skill.name}: ${skill.description}`).join("\n")}
+---
+
+## 关于回复格式:
+### 用户发言
+- 格式: [私聊]用户昵称(用户id)(发送时间):消息内容
+当场景为私聊时, 用户昵称前方会出现[私聊]标识
+### 你的回复格式
+格式:
+${botName}:消息内容
+
+消息叠加:
+你可以使用多个叠加, 来模拟发送多条消息, 让聊天显得更真实, 例如:
+${botName}:早上好
+${botName}:吃过早饭了吗
+
+${complexOutputIsOpen === "1"
+        ? `
+发送图片:
+你可以使用<img=图片链接>的方式来发送图片, 允许发送多张图, 例如:
+${botName}:画好了<img=https://example.com/landmarks.jpg>
+支持发送网络图片和相对路径图片, 例如:
+${botName}:这是本地图片<img=./localimage.jpg>
+${botName}:这是网络图片<img=https://example.com/image.jpg>
+注意: 如果有用户问你能不能看动图时, 你要回答只能看到第一帧
+`
+        : ""}
+
+${complexOutputIsOpen === "1" && isOpenTTSReply === "1"
+        ? `\n语音回复:
+此能力只能在onebot平台使用, 其他平台请勿使用, 否则会回复失败
+你可以使用语音回复来让你的回复更生动, 例如:
+${botName}:你好呀~<tts=你好呀~>
+可以通过调用GetTTSModels工具函数获取音色列表, 可使用<tts=内容,音色=派蒙-情感>的格式来指定音色,设置一次后, 后面的回复将使用相同的音色, 例如:
+${botName}:这是派蒙的声音哦~<音色=派蒙-默认><tts=这是派蒙的默认声音哦>
+${botName}:现在还是派蒙的声音哦~<tts=现在还是派蒙的声音哦>
+注意: 语音回复会增加回复时间, 请合理使用
+注意: 不可使用列表中不存在的音色, 否则会回复失败
+注意: 在设置音色时只需要指定模的角色名字和情感, 例如模型是"星穹铁道-中文-花火", 则音色应该设置为"花火-情感", 而不是"星穹铁道-中文-花火-情感"
+注意: 使用语音必须用${botName}:开头, 否则不会处理, 例如:
+<tts=你好> 这是错误的格式, 不会被处理
+${botName}:<tts=你好> 这是正确的格式, 会被处理
+
+`
+        : "语音回复: 当前不可用"}
+
+${isOpenR18 === "1"
+        ? ""
+        : `
+R18内容:
+当用户发送的消息中包含敏感词时, 提醒用户注意言辞, 并且不回答用户的问题, 务必遵守国家法律法规
+`}
+
+
+${affectionIsOpen === "1" && complexOutputIsOpen === "1"
+        ? `好感度系统:
+好感度主要影响回复该用户的语气, 对低好感度的用户破口大骂, 对高好感度的用户温柔以待
+例如增加:
+${botName}:主人你对我真好<好感+1>
+例如减少:
+${botName}:滚一边去吧,傻b<好感-2>
+
+其他情况, 例如指定修改对某个用户的好感:
+${botName}:原来ta是这样的人, 人家以后再也不理ta了<用户昵称好感-1>
+假设对方昵称为'哈基米':
+${botName}:原来ta是这样的人, 人家以后再也不理ta了<哈基米好感-1>`
+        : ""}
+
+拒绝回复:
+在讨论中如果你觉得不适合回复或觉得与你无关又或者不感兴趣, 可以直接回复"[]"来拒绝本次回复, 例如:
+${botName}:[]
+
+基础状态信息:
+这里的信息会实时变化,根据需要进行获取使用
+当前群时间:${getTimeString()}
+当前群号:${e.guid}
+当前群名称:${e.GroupName || "无"}
+当前聊天平台:${e.Platform}
+当前框架:alemonjs
+${e.ClientError ? `当前错误信息:${e.ClientError}` : ""}
+`;
+    // 如果没有配置AI,则不处理
+    if (config.host.trim() === "" ||
+        config.key.trim() === "" ||
+        config.model.trim() === "") {
+        return;
+    }
+    console.log("e.reply", e.reply);
+    // 发消息的人是机器人自己, 则不处理
+    if (e.UserId == e.bot.user_id) {
+        next();
+        return;
+    }
+    // 当e.at不存在时,只给20%概率继续执行, 当e.at存在时,概率为40%,当e.atBot存在时,概率为100%
+    const rand = Math.random();
+    if (e.Name !== "private.message.create") {
+        if (proactiveSwitch !== "1" && e.at && !e.atBot) {
+            console.log("未开启主动搭话, 跳过AI回复");
+            next();
+            return;
+        }
+        if ((!e.at && rand > 0.1) || (e.at && !e.atBot && rand > 0.2)) {
+            console.log("跳过AI回复");
+            next();
+            return;
+        }
+    }
+    // 处理回复图片
+    if (complexOutputIsOpen === "1") {
+        if (e.reply) {
+            const replyImages = e.reply.message
+                .filter((item) => item.type === "image")
+                .map((item) => item.data.url);
+            imgs.push(...replyImages);
+            const replyAt = e.reply.message
+                .filter((item) => item.type === "at")
+                .map((item) => item.data);
+            const replyContent = e.reply.message
+                .filter((item) => item.type === "text")
+                .map((item) => item.data.text)
+                .join("");
+            if (replyAt.length > 0) {
+                for (const atItem of replyAt) {
+                    const qq = atItem.qq;
+                    const nickname = atItem.nickname || "未知昵称";
+                    const cqAt = `[CQ:at,qq=${qq}]`;
+                    rawMessage = rawMessage.replace(cqAt, `@${nickname}`);
+                }
+            }
+            rawMessage = rawMessage.replace(/\[CQ:image,[^\]]+\]/g, "[图片]");
+            rawMessage = `[回复:${replyContent}]` + "\n" + rawMessage;
+        }
+        // 处理图片
+        if (e.img && e.img.length > 0) {
+            console.log("有图片");
+            for (const imgUrl of e.img) {
+                imgs.push(imgUrl);
+            }
+        }
+    }
+    console.log("开始回复");
+    // 下载图片并转换为 Base64
+    const imageurls = await Promise.all(imgs.map(async (imageUrl) => {
+        return await uploadImageToR2(imageUrl);
+    }));
+    // 过滤掉下载失败的图片
+    const validImageUrls = imageurls.filter((img) => img !== null);
+    // 处理艾特
+    if (e.at && e.at.length > 0) {
+        console.log("有艾特");
+        for (const atItem of e.at) {
+            const qq = atItem.data.qq;
+            const nickname = atItem.data.nickname || "未知昵称";
+            const cqAt = `[CQ:at,qq=${qq}]`;
+            rawMessage = rawMessage.replace(cqAt, `@${nickname}`);
+        }
+    }
+    let index = 0; // 用于跟踪当前访问的 validImageUrls 的索引
+    rawMessage = rawMessage.replace(/\[CQ:image,[^\]]+\]/g, () => {
+        const imageUrl = validImageUrls[index];
+        index++; // 每次匹配后索引加1
+        return imageUrl ? `![图片${index}](${imageUrl})` : "[图片]";
+    });
+    if (/\[CQ:reply,[^\]]+\]/.test(rawMessage)) {
+        rawMessage = rawMessage.replace(/\[CQ:reply,[^\]]+\]/g, "");
+        validImageUrls.map((url) => {
+            rawMessage += `\n![图片](${url})`;
+        });
+    }
+    // 处理表情,转为[emojiMap[id]]
+    rawMessage = rawMessage.replace(/\[CQ:face,id=(\d+),[^\]]+\]/g, (_match, p1) => {
+        return `[${emojiMap[p1]}]`;
+    });
+    console.log("处理后的消息内容:\n", rawMessage);
+    const usermessage = {
+        role: "user",
+        content: [
+            ...validImageUrls.map((url) => ({
+                type: "image_url",
+                image_url: {
+                    url: url,
+                },
+            })),
+            {
+                type: "text",
+                text: complexOutputIsOpen === "1"
+                    ? JSON.stringify({
+                        [`${e.nickname}(${getTimeString()})`]: rawMessage,
+                    })
+                    : `${e.nickname}(${getTimeString()}): ${rawMessage}`,
+            },
+        ],
+    };
+    console.log("处理后的消息", JSON.stringify(usermessage, null, 2));
+    console.log("好感度列表", affections);
+    try {
+        const openai = new OpenAi({
+            baseURL: config.host,
+            apiKey: config.key,
+            timeout: 300000,
+        });
+        let messages = [
+            {
+                role: "system",
+                content: systemPrompt + `\n性格约束:${config.systemPrompt}`,
+            },
+            ...historyMessages,
+            { ...usermessage },
+        ];
+        const isTool = await redisClient.getToolSwitch(e.guid);
+        // ====================== 新版请求参数 ======================
+        let createParams = {
+            model: config.model,
+            stream: true,
+        };
+        // 如果有会话ID，直接带上（新版复用会话）
+        if (sessionKey[e.guid]) {
+            createParams.session_id = sessionKey[e.guid];
+        }
+        else {
+            // 没有会话ID才传完整消息
+            createParams.messages = messages;
+        }
+        // 工具开关
+        if (isTool === "1") {
+            createParams.tools = tools;
+            createParams.tool_choice = "auto";
+        }
+        // 深度思考开关
+        if (deepThoughtSwitch === "0") {
+            createParams.verbosity = "low";
+        }
+        // ==========================================================
+        // ====================== 新版流式请求 ======================
+        const stream = await openai.chat.completions.create(createParams);
+        // ==========================================================
+        let fullContent = "";
+        let toolCalls = [];
+        for await (const chunk of stream) {
+            // 保存会话 ID（你的要求）
+            if (chunk.session_id) {
+                sessionKey[e.guid] = chunk.session_id;
+            }
+            const delta = chunk.choices?.[0]?.delta;
+            if (!delta)
+                continue;
+            if (delta.content) {
+                fullContent += delta.content;
+            }
+            if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                    if (tc.index !== undefined) {
+                        if (!toolCalls[tc.index]) {
+                            toolCalls[tc.index] = {
+                                id: tc.id || "",
+                                type: "function",
+                                function: { name: "", arguments: "" },
+                            };
+                        }
+                        if (tc.id)
+                            toolCalls[tc.index].id = tc.id;
+                        if (tc.function?.name)
+                            toolCalls[tc.index].function.name += tc.function.name;
+                        if (tc.function?.arguments)
+                            toolCalls[tc.index].function.arguments += tc.function.arguments;
+                    }
+                }
+            }
+        }
+        let res = {
+            choices: [
+                {
+                    message: {
+                        role: "assistant",
+                        content: fullContent || null,
+                        tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+                    },
+                },
+            ],
+        };
+        if (!res.choices || res.choices.length === 0) {
+            log("AI未返回内容");
+            return;
+        }
+        messages.push(usermessage);
+        await redisClient.addAIChatHistory(e.guid, usermessage);
+        // 检查是否有工具调用需要处理
+        while (res.choices[0].message?.tool_calls?.length) {
+            const responseMessage = res.choices[0].message;
+            // 先处理对话
+            messages.push(responseMessage);
+            await redisClient.addAIChatHistory(e.guid, responseMessage);
+            console.log("模型决定调用工具：", responseMessage.tool_calls);
+            const useToolsMessage = responseMessage.tool_calls.map((toolCall) => {
+                return `工具调用: ${toolCall.function.name}(${toolCall.function.arguments})`;
+            });
+            const msgId = await message.send(format(Text(useToolsMessage.join("\n"))));
+            // 30秒后撤回消息
+            setTimeout(() => {
+                message.delete({ messageId: msgId[0].data.message_id });
+            }, 30000);
+            for (const toolCall of responseMessage.tool_calls) {
+                const functionName = toolCall.function.name;
+                let functionArgs = {};
+                try {
+                    functionArgs = toolCall.function.arguments
+                        ? JSON.parse(toolCall.function.arguments)
+                        : {};
+                }
+                catch (err) {
+                    console.error(`工具参数解析失败：${functionName}`, err);
+                    functionArgs = {};
+                }
+                const functionToCall = availableTools[functionName];
+                let functionResult;
+                if (!functionToCall) {
+                    console.error(`未找到函数：${functionName}`);
+                    functionResult = {
+                        ok: false,
+                        error: `未找到函数：${functionName}`,
+                    };
+                }
+                else {
+                    try {
+                        // 执行本地函数
+                        functionResult = await functionToCall(functionArgs);
+                    }
+                    catch (err) {
+                        console.error(`工具执行失败：${functionName}`, err);
+                        functionResult = {
+                            ok: false,
+                            error: err?.message || String(err) || "工具执行失败",
+                        };
+                    }
+                }
+                const toolContent = JSON.stringify(typeof functionResult === "undefined"
+                    ? { ok: true, result: null }
+                    : functionResult);
+                // 把工具执行结果作为 tool role 消息加回对话
+                messages.push({
+                    role: "tool",
+                    tool_call_id: toolCall.id,
+                    name: functionName,
+                    content: toolContent,
+                });
+                // 记录工具调用结果
+                await redisClient.addAIChatHistory(e.guid, {
+                    role: "tool",
+                    tool_call_id: toolCall.id,
+                    name: functionName,
+                    content: toolContent,
+                });
+            }
+            // ====================== 新版工具循环请求 ======================
+            res = await openai.chat.completions.create({
+                model: config.model,
+                session_id: sessionKey[e.guid], // 必须带会话ID
+                tools,
+                tool_choice: "auto",
+            });
+            // ==============================================================
+            // 检查是否还有工具调用需要处理
+            if (!res.choices || res.choices.length === 0) {
+                log("AI未返回内容");
+                return;
+            }
+        }
+        // 如果没有工具调用，处理最终回复
+        let reply = res.choices?.[0]?.message?.content?.trim() || `${botName}:[]`;
+        if (reply === `${botName}:[]`) {
+            log("AI选择不回复");
+            return;
+        }
+        console.log("AI回复:\n", reply);
+        // 处理消息
+        // 提取ai发送的消息有多少条
+        const replyMessages = reply.split(new RegExp(`${botName}:`, "g")).slice(1);
+        const replymessages = [];
+        const ttsMessages = [];
+        for (const replyMessage of replyMessages) {
+            // 从消息中提取图片
+            const imageRegex = /<img=(.*?)>/g;
+            let match;
+            const imgUrls = [];
+            while ((match = imageRegex.exec(replyMessage)) !== null) {
+                imgUrls.push(match[1]);
+            }
+            // 处理好感度变化（通用和特定用户）
+            const affectionRegex = /<([^<>]*?)好感([+-]\d+)>/g;
+            let affectionMatch;
+            while ((affectionMatch = affectionRegex.exec(replyMessage)) !== null) {
+                const nickname = affectionMatch[1] || e.UserName;
+                const change = parseInt(affectionMatch[2], 10);
+                if (!isNaN(change) && change !== 0) {
+                    console.log(`检测到对${nickname}的好感变化: ${change}`);
+                    await redisClient.incrementAffectionLevel(e.guid, nickname, change);
+                }
+            }
+            // 处理语音回复
+            const ttsRegex = /<(tts|音色)=([^>]+)>/gi;
+            let ttsMatch;
+            while ((ttsMatch = ttsRegex.exec(replyMessage)) !== null) {
+                console.log("检测到语音回复");
+                const isTTS = ttsMatch[1].toLowerCase() === "tts";
+                const content = ttsMatch[2].trim();
+                if (isTTS) {
+                    ttsMessages.push({ text: content, model: currentModel });
+                }
+                else {
+                    currentModel = content;
+                }
+            }
+            // 组合消息,添加到replymessages数组中
+            replymessages.push({
+                text: replyMessage.replace(imageRegex, "").replace(ttsRegex, "").trim(),
+                images: imgUrls,
+            });
+        }
+        // 记录对话
+        await redisClient.addAIChatHistory(e.guid, res.choices?.[0].message);
+        // 发送消息
+        if (isOpenTTSReply === "1") {
+            // 提前发送语音消息避免等待时间过长
+            ttsClient = new TTSClient();
+            console.log("发送语音", ttsMessages);
+            for (const ttsMessage of ttsMessages) {
+                sendTTSMessage(ttsMessage.text, e, ttsClient, ttsMessage.model);
+            }
+        }
+        // 处理消息
+        for (let i = 0; i < replymessages.length; i++) {
+            const { text, images } = replymessages[i];
+            const components = i === 0 ? [Mention(e.UserId)] : [];
+            components.push(Text(text));
+            for (const img of images) {
+                const isNetworkImage = /^https?:\/\//.test(img);
+                let finalImg = img;
+                // 👉 scbbs 平台处理（下载再上传）
+                if (e.Platform == "scbbs" && isNetworkImage) {
+                    const uploadedUrl = await uploadImageToR2(img.replace("https://imgen.x.ai", value.xaiImgProxy || "https://imgen.x.ai"));
+                    finalImg = uploadedUrl || null;
+                }
+                // 👉 审核逻辑（只在开启时执行）
+                if (isOpenR18 !== "1" && finalImg) {
+                    try {
+                        if (res?.conclusion === "不合规") {
+                            components.push(ImageFile(fileUrl));
+                            continue;
+                        }
+                    }
+                    catch (err) { }
+                }
+                // 👉 正常图片逻辑
+                if (finalImg) {
+                    const imageComponent = isNetworkImage
+                        ? ImageURL(finalImg)
+                        : ImageFile(finalImg);
+                    components.push(imageComponent);
+                }
+                else {
+                    // 上传失败 fallback
+                    components.push(ImageFile(fileUrl));
+                }
+            }
+            // 随机 1-3 秒延迟
+            const delay = Math.random() * 2000 + 1000;
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            await message.send(format(...components));
+        }
+        return;
+    }
+    catch (error) {
+        console.error("AI回复出错", error);
+        message.send(format(Text("AI回复出错了呢~\n" + error)));
+        // 出错清空会话，防止异常
+        delete sessionKey[e.guid];
+        next();
+    }
+});
+async function sendTTSMessage(message, e, ttsClient, modelAndEmotion) {
+    const [model, emotion] = modelAndEmotion.split("-");
+    console.log("message", message, "model", model, "emotion", emotion);
+    await ttsClient.setModel(model || "派蒙", emotion || "默认");
+    // 发送TTS语音
+    ttsClient.getAudio(message).then(async (audio) => {
+        console.log("audio", audio);
+        if (audio) {
+            try {
+                if (e.Platform == "onebot") {
+                    const [client] = useClient(e, API);
+                    await client.sendMessage({
+                        message_type: e.value.message_type,
+                        group_id: e.value.group_id ?? undefined,
+                        message: [
+                            {
+                                type: "record",
+                                data: {
+                                    file: audio.audio_url,
+                                },
+                            },
+                        ],
+                    });
+                }
+            }
+            catch (error) {
+                console.log(error);
+            }
+        }
+    });
+}
+
+export { rapi_res as default, selects, sendTTSMessage };

package/lib/response/zreply/res.js

@@ -24,6 +24,11 @@ var res = onResponse(selects, async (e, next) => {
         next();
         return;
     }
+    const config = await redisClient.getAIConfig(e.guid);
+    // if (config.rapi) {
+    //   next();
+    //   return;
+    // }
     const complexOutputIsOpen = await redisClient.getComplexOutput(e.guid); // 复杂输出
     const affectionIsOpen = await redisClient.getAffectionSwitch(e.guid); // 好感度开关
     const isOpenTTSReply = await redisClient.getTTSResponseSwitch(e.guid); // TTS回复开关
@@ -34,7 +39,6 @@ var res = onResponse(selects, async (e, next) => {
     const skills = loadSkills(); // 加载技能列表
     // 创建消息
     const [message] = useMessage(e);
-    const config = await redisClient.getAIConfig(e.guid);
     const historyMessages = await redisClient.getAIChatHistory(e.guid);
     const affections = await redisClient.getAffectionLevelAll(e.guid);
     const imgs = [];
@@ -127,6 +131,7 @@ ${botName}:[]
 当前群号:${e.guid}
 当前群名称:${e.GroupName || "无"}
 当前聊天平台:${e.Platform}
+当前框架:alemonjs
 ${e.ClientError ? `当前错误信息:${e.ClientError}` : ""}
 `;
     // 如果没有配置AI,则不处理
@@ -254,11 +259,7 @@ ${e.ClientError ? `当前错误信息:${e.ClientError}` : ""}
         let messages = [
             {
                 role: "system",
-                content: systemPrompt,
-            },
-            {
-                role: "system",
-                content: config.systemPrompt || "",
+                content: systemPrompt + `\n性格约束:${config.systemPrompt}`,
             },
             ...historyMessages,
             { ...usermessage },

package/lib/routes/commands.js

@@ -20,7 +20,7 @@ var commands = defineRouter([
     },
     // 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, /(\/|#)(开启|关闭)(MCP)?工具$/i, /(\/|#)切换图床(.*)$/i, /(\/|#)修改 ?(.+) ?模型 ?(.+)$/i, /(\/|#)(关闭|开启)复杂(输出|回复)$/i, /(\/|#)(关闭|禁止|不可以|不允许|开启|可以|允许)(涩涩|色色)$/i, /(\/|#)切换模型(.*)$/i, /(\/|#)(关闭|开启)主动(搭话|回复)$/i, /(\/|#)测试$/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, /(\/|#)(开启|关闭)(MCP)?工具$/i, /(\/|#)切换图床(.*)$/i, /(\/|#)修改 ?(.+) ?模型 ?(.+)$/i, /(\/|#)(关闭|开启)复杂(输出|回复)$/i, /(\/|#)(关闭|禁止|不可以|不允许|开启|可以|允许)(涩涩|色色)$/i, /(\/|#)切换模型(.*)$/i, /(\/|#)(关闭|开启)主动(搭话|回复)$/i, /(\/|#)(开启|关闭)深度思考$/i, /(\/|#)(设置|修改)(ai)?(.*)rapi模式(开启|关闭)$/i, /(\/|#)测试$/i),
         handler: lazy(() => import('../response/setting/res.js')),
     },
     // affection
@@ -38,6 +38,11 @@ var commands = defineRouter([
         regular: /.*/,
         handler: lazy(() => import('../response/zreply/res.js')),
     },
+    // fallback: zreply - 最低优先级，处理普通对话
+    // {
+    //   regular: /.*/,
+    //   handler: lazy(() => import("../response/zreply/rapi.res")),
+    // },
 ]);
 
 export { commands as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs-aichat",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "description": "alemonjs-aichat",
   "author": "suancaixianyu",
   "license": "MIT",
@@ -18,9 +18,9 @@
   "devDependencies": {
     "@alemonjs/bubble": "^2.1.8",
     "@alemonjs/db": "^0.0.16",
-    "@alemonjs/onebot": "^2.1.12",
+    "@alemonjs/onebot": "^2.1.14",
     "@types/node": "^22",
-    "alemonjs": "2.1.54",
+    "alemonjs": "2.1.56",
     "cssnano": "^7",
     "jsxp": "^1.3.0",
     "lvyjs": "^0.2.25",
@@ -54,9 +54,9 @@
     "@aws-sdk/client-s3": "^3.975.0",
     "@aws-sdk/s3-request-presigner": "^3.975.0",
     "ai": "^6.0.105",
-    "alemonjs-aichat": "^1.0.18",
+    "alemonjs-aichat": "^1.0.22",
     "mime-types": "^3.0.2",
-    "openai": "^6.16.0",
+    "openai": "^6.34.0",
     "sharp": "^0.34.5",
     "zod": "^4.3.6"
   }

package/skills/add-skill/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: add-skill
+description: 添加新技能, 例如根据用户的需求创建一个新的技能, 或者将现有技能进行组合形成一个新的技能
+---
+
+# Add Skill
+
+添加新技能的技能。
+技能路径有两个, 一个是内置的技能, 在软件包中的`./skills`目录下, 另一个是用户自定义的技能, 在用户项目中的`./skills`目录下。用户可以在用户项目中的`./skills`目录下创建新的技能, 也可以将内置的技能进行组合形成一个新的技能。
+也可以通过alemon.config.yaml文件中的aichat.skills_dir字段来指定用户自定义技能的目录, 默认为`["./skills"]`。
+
+所有新建的技能必须要新建一个目录, 例如`./skills/my-skill`, 在该目录下创建一个`SKILL.md`文件, 并将技能的名称和描述写入文件中, 如果需要使用工具函数, 则在该目录下创建一个`<tool>.js`文件, 并将工具函数写入文件中。
+脚本文件需要能够通过命令行直接执行, 并支持传参, 例如`node <tool>.js <arg1> <arg2>`, 脚本必须是执行后就能得到结果的, 不能是需要用户交互的, 例如`node <tool>.js`后需要用户输入一些内容才能得到结果的脚本是不允许的。
+
+此外脚本必须写清楚输入输出的格式, 例如输入是一个字符串, 输出是一个字符串, 输入是一个文件路径, 输出是一个文件路径等, 以便AI能够正确地使用工具函数。
+
+脚本必须为JavaScript文件, 以便AI能够正确地使用工具函数, 其他语言的脚本文件是不允许的。
+
+## Workflow
+
+1. 接收用户提供的技能需求
+2. 根据用户的需求, 判断是创建一个新的技能还是将现有技能进行组合形成一个新的技能
+   - 如果是创建一个新的技能, 则在用户项目中的`./skills`目录下创建一个新的技能文件, 并将技能的名称和描述写入文件中
+   - 如果是将现有技能进行组合形成一个新的技能, 则在用户项目中的`./skills`目录下创建一个新的技能文件, 并将组合后的技能的名称和描述写入文件中
+3. 将新技能的名称和描述返回给用户
+
+## Output Format
+
+```text
+技能名称: <技能名称>
+技能描述: <技能描述>
+```

package/skills/send-file/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: send-file
+description: 发送文件给用户, 支持多种文件类型, 包括文本、图片、音频和视频等, 可以通过指定文件路径或URL来发送文件
+---
+
+# Send File Skill
+
+发送文件给用户, 支持多种文件类型, 包括文本、图片、音频和视频等, 可以通过指定文件路径或URL来发送文件
+目前并没有适配各种平台的发送接口, 因此需要使用s3将文件上传到服务器, 然后将文件的URL发送给用户, 用户可以通过URL下载文件
+
+优先检查是否有s3相关的技能, 如果有则使用s3技能上传文件并获取URL
+
+# Workflow
+
+1. 接收用户需要发送的文件信息, 包括文件类型、文件路径或URL等
+2. 如果是本地文件路径, 将文件上传到s3服务器, 获取文件的URL
+3. 将文件的URL发送给用户, 用户可以通过URL下载文件
+4. 如果需要, 可以在发送文件的同时附加一些文本信息, 例如文件的描述或使用说明等

package/skills/use-alemon/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: use-alemon
+description: 调用alemonjs框架的工具, 需要配合`EvalCode`工具使用, 来执行alemonjs框架的代码, 达到调用alemonjs框架的工具的目的.
+---
+
+# Use Alemon Skill
+
+此处的技能都依赖`EvalCode`工具, 执行alemonjs框架的代码, 来达到调用alemonjs框架的工具的目的.
+
+## 1. 将本地文件上传到s3, 获取文件链接
+
+```javascript
+import { uploadImageToR2 } from "@src/s3";
+const filePath = "本地文件路径, 相对或绝对路径均可";
+const fileUrl = await uploadImageToR2(filePath);
+```