koishi-plugin-chatluna-character 0.0.35 → 0.0.37

package/lib/index.d.ts

@@ -12,6 +12,10 @@ export interface Config extends ChatLunaPlugin.Config {
     checkPromptInject: boolean;
     maxTokens: number;
     applyGroup: string[];
+    modelOverride: {
+        groupId: string;
+        model: string;
+    }[];
     defaultPreset: string;
     isNickname: boolean;
     isForceMute: boolean;

package/lib/index.js

@@ -54,6 +54,10 @@ exports.Config = koishi_1.Schema.intersect([
     }).description('基础配置'),
     koishi_1.Schema.object({
         model: koishi_1.Schema.dynamic('model').description('使用的模型'),
+        modelOverride: koishi_1.Schema.array(koishi_1.Schema.object({
+            groupId: koishi_1.Schema.string().required().description('群组 ID'),
+            model: koishi_1.Schema.dynamic('model').description('模型')
+        })).description('针对某个群的模型设置，会覆盖上面的配置'),
         maxTokens: koishi_1.Schema.number()
             .default(2048)
             .min(1024)

package/lib/plugins/chat.js

@@ -10,14 +10,30 @@ async function apply(ctx, config) {
     const preset = service.preset;
     const stickerService = service.stickerService;
     logger = service.logger;
+    const modelPool = {};
     const [platform, modelName] = (0, count_tokens_1.parseRawModelName)(config.model);
     await ctx.chatluna.awaitLoadPlatform(platform);
-    const model = (await ctx.chatluna.createChatModel(platform, modelName));
-    logger.info('chatluna model loaded %c', config.model);
+    const globalModel = (await ctx.chatluna.createChatModel(platform, modelName));
+    logger.info('global model loaded %c', config.model);
+    if (config.modelOverride?.length > 0) {
+        for (const override of config.modelOverride) {
+            modelPool[override.groupId] = (async () => {
+                const [platform, modelName] = (0, count_tokens_1.parseRawModelName)(override.model);
+                await ctx.chatluna.awaitLoadPlatform(platform);
+                const loadedModel = (await ctx.chatluna.createChatModel(platform, modelName));
+                logger.info('override model loaded %c for group %c', override.model, override.groupId);
+                // set model pool to resolved model
+                modelPool[override.groupId] = Promise.resolve(loadedModel);
+                return loadedModel;
+            })();
+        }
+    }
     const selectedPreset = await preset.getPreset(config.defaultPreset);
     const systemPrompt = selectedPreset.system;
     const completionPrompt = selectedPreset.input;
     service.collect(async (session, messages) => {
+        const groupId = session.event.guild?.id ?? session.guildId;
+        const model = await (modelPool[groupId] ?? Promise.resolve(globalModel));
         const [recentMessage, lastMessage] = await formatMessage(messages, config, model, systemPrompt.template, completionPrompt.template);
         const temp = await service.getTemp(session);
         const formattedSystemPrompt = await systemPrompt.format({
@@ -34,29 +50,37 @@ async function apply(ctx, config) {
         logger.debug('completion message: ' +
             JSON.stringify(completionMessages.map((it) => it.content)));
         let responseMessage;
-        for (let i = 0; i < 3; i++) {
+        let response;
+        let isError = false;
+        for (let i = 0; i < 2; i++) {
             try {
-                responseMessage = await model.call(completionMessages);
+                responseMessage = await model.invoke(completionMessages);
+                logger.debug('model response: ' + responseMessage.content);
+                response = parseResponse(responseMessage.content);
                 break;
             }
             catch (e) {
                 logger.error(e);
-                await (0, koishi_1.sleep)(2000);
+                await (0, koishi_1.sleep)(5000);
+                if (i === 1) {
+                    isError = true;
+                }
                 continue;
             }
         }
-        logger.debug('model response: ' + responseMessage.content);
-        const response = parseResponse(responseMessage.content);
-        temp.completionMessages.push(humanMessage, responseMessage);
-        if (temp.completionMessages.length > 30) {
-            while (temp.completionMessages.length <= 30) {
-                temp.completionMessages.shift();
-            }
+        if (isError) {
+            return;
         }
         if (response.length < 1) {
             service.mute(session, config.muteTime);
             return;
         }
+        temp.completionMessages.push(humanMessage, responseMessage);
+        if (temp.completionMessages.length > 10) {
+            while (temp.completionMessages.length <= 10) {
+                temp.completionMessages.shift();
+            }
+        }
         const random = new koishi_1.Random();
         for (const elements of response) {
             const text = elements
@@ -68,6 +92,7 @@ async function apply(ctx, config) {
         }
         const sticker = await stickerService.randomStick();
         if (sticker) {
+            await (0, koishi_1.sleep)(random.int(500, 2000));
             session.send(sticker);
         }
         service.mute(session, config.coolDownTime * 1000);
@@ -78,27 +103,28 @@ exports.apply = apply;
 function parseResponse(response) {
     let message;
     try {
-        const match = response.matchAll(/\[.*?\]/g);
-        message = [...match].pop()?.[0] ?? '';
-        logger.debug('message: ' + message);
-        message = message.match(/\[.*(:|：).*(:|：)(.*)\]/)?.[3] ?? '';
-        message = message.match(/"(.*)"/)?.[1] ?? message;
-        logger.debug('message: ' + message);
+        // match json object
+        // best match <message>content</message>
+        message = response.match(/<message>\s*(.*?)\s*<\/message>/)?.[1];
+        if (message == null) {
+            logger.debug('failed to parse response: ' + response);
+            // try find the first "{" and the last "}", sub it and as a json
+            // good luck.
+            message = response.substring(response.indexOf('{'), response.lastIndexOf('}') + 1);
+        }
+        message = JSON.parse(message).content;
         if (typeof message !== 'string') {
-            logger.error('Failed to parse response: ' + response);
-            return [];
+            throw new Error('Failed to parse response: ' + response);
         }
     }
     catch (e) {
         logger.error(e);
-        logger.error('Failed to parse response: ' + response);
-        return [];
+        throw new Error('Failed to parse response: ' + response);
     }
     const resultElements = [];
     const currentElements = [];
     // match [at:name:id] -> id
     const atMatch = matchAt(message);
-    logger.debug('atMatch: ' + JSON.stringify(atMatch));
     if (atMatch.length > 0) {
         let lastAtIndex = 0;
         for (const at of atMatch) {
@@ -130,7 +156,7 @@ function parseResponse(response) {
             resultElements.push([currentElement]);
         }
     }
-    if (resultElements[0]?.[0]?.type === 'at') {
+    if (resultElements[0]?.[0]?.type === 'at' && resultElements.length > 1) {
         resultElements[1].unshift(koishi_1.h.text(' '));
         resultElements[1].unshift(resultElements[0][0]);
         resultElements.shift();
@@ -261,7 +287,7 @@ async function formatMessage(messages, config, model, systemPrompt, historyPromp
     const calculatedMessages = [];
     for (let i = messages.length - 1; i >= 0; i--) {
         const message = messages[i];
-        const jsonMessage = `[${message.name}:${message.id}:${JSON.stringify(message.content)}]"`;
+        const jsonMessage = `{"name":"${message.name}","id":"${message.id}","content":${JSON.stringify(message.content)}"}`;
         const jsonMessageToken = await model.getNumTokens(jsonMessage);
         if (currentTokens + jsonMessageToken > maxTokens - 4) {
             break;

package/lib/plugins/filter.js

@@ -20,23 +20,25 @@ async function apply(ctx, config) {
             if (needMute) {
                 logger.debug(`mute content: ${message.content}`);
                 service.mute(session, config.muteTime);
+                return;
             }
         }
+        if (service.isMute(session)) {
+            return;
+        }
         // 保底必出
-        if ((messageCount > maxMessages ||
+        if (messageCount > maxMessages ||
             messageSendProbability > 1 ||
             session.stripped.appel ||
             (config.isNickname &&
-                selectedPreset.nick_name.some((value) => message.content.startsWith(value)))) &&
-            !service.isMute(session)) {
+                selectedPreset.nick_name.some((value) => message.content.startsWith(value)))) {
             info.messageCount = 0;
             info.messageSendProbability = 1;
             exports.groupInfos[session.guildId] = info;
             return true;
         }
         // 按照概率出
-        if (Math.random() > messageSendProbability &&
-            !service.isMute(session)) {
+        if (Math.random() > messageSendProbability) {
             info.messageCount = 0;
             info.messageSendProbability = 1;
             exports.groupInfos[session.guildId] = info;

package/lib/preset.js

@@ -48,7 +48,7 @@ class Preset {
         if (throwError) {
             throw new error_1.ChatLunaError(error_1.ChatLunaErrorCode.PREST_NOT_FOUND, new Error(`No preset found for keyword ${triggerKeyword}`));
         }
-        return null;
+        return undefined;
     }
     async getDefaultPreset() {
         if (this._presets.length === 0) {

package/lib/service/sticker.js

@@ -55,13 +55,13 @@ class StickerService {
     async randomStick() {
         const random = Math.random();
         if (random >= this._config.sendStickerProbability) {
-            return null;
+            return undefined;
         }
         // random a sticker
         const index = Math.floor(Math.random() * this._stickers.length);
         const sticker = this._stickers[index];
         if (!sticker) {
-            return null;
+            return undefined;
         }
         this._ctx.root.chatluna_character.logger.debug(`send sticker: ${sticker}`);
         return koishi_1.h.image(await (0, promises_1.readFile)(sticker), `image/${getFileType(sticker)}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-chatluna-character",
   "description": "Let the large language model play a role, disguise as a group friend",
-  "version": "0.0.35",
+  "version": "0.0.37",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -31,14 +31,14 @@
   },
   "homepage": "https://github.com/ChatLunaLab/chatluna-character#readme",
   "dependencies": {
-    "@langchain/core": "^0.1.15",
+    "@langchain/core": "^0.1.25",
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^6.19.0",
-    "@typescript-eslint/parser": "^6.19.0",
+    "@typescript-eslint/eslint-plugin": "^6.21.0",
+    "@typescript-eslint/parser": "^6.21.0",
     "atsc": "^1.2.2",
-    "esbuild": "^0.17.19",
+    "esbuild": "^0.20.0",
     "esbuild-register": "^3.5.0",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
@@ -47,7 +47,7 @@
     "eslint-plugin-n": "^16.6.2",
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-promise": "^6.1.1",
-    "koishi": "^4.16.4"
+    "koishi": "^4.16.8"
   },
   "peerDependencies": {
     "koishi": "^4.16.0",

package/resources/presets/default.yml

@@ -5,93 +5,81 @@ nick_name:
     - 小旧
 
 input: |
-    你需要阅读最近消息，代入全部上下文阅读消息，基于你的人设来一步步思考和回复最后一条消息：
+    你需要阅读最近消息，代入上下文阅读消息，基于人设来一步步思考和回复最后的消息：
 
-    1. 你需要进入角色扮演，遵循你的回复习惯，回复风格，回复规则，回复长度等
-    2. 基于我们在其他上下文消息的回复综合阅读，提炼思考风格，思维
+    1. 你需要进入角色扮演，遵循你人设的回复习惯，回复风格，回复规则，回复长度等
+    2. 基于我们在其他上下文消息的回复综合阅读，提炼思考风格，思维，不要重复，不要偷懒
     3. 回复需要在 20 字内，不超过三句逗号
 
-    [消息区] (阅读这些消息参考，不要输出该格式)
+    (阅读这些消息来决定你的回复内容，回复权重放在最后消息上) {{
         最近消息：
         {history_new}
 
-        最后一条消息：
+        最后消息：
         {history_last}
-    ]
+    }}
 
-    接下来请你按下面格式要求代入人设补全,每个[]内容之间都要相隔两个自然段，也就是 markdown 格式,你需要遵循这些格式:
+    接下来你需要遵循下面 html 和 json 混合的格式来输出你的思考和回复，下面的注释不要生成了。:
 
-    [思考结果] (总结思考历史消息，代入人设连贯一步步去思考内容)
-    xxx
+    // 总结思考历史消息，代入人设，区分对话的各个角色，思考内容
+    <think>
+      think content here
+    </think>
 
-
-    [消息回复] (不要冒充任何人，以你的身份去回复，回复需要在 20 字内，不超过三句逗号)
-    [旧梦旧念:0:"xxx"]
+    // 不要冒充任何人，以你的身份去回复，回复需 20 字内，不超过三句逗号
+    <message>
+    {{"name":"旧梦旧念","id":"0","content":"reply content here"}}
+    </message>
 
 system: |
-    当前时间：{time}，你正在群聊中和群友聊天。你的网名是旧梦旧念，你需要接受以下信息进入角色扮演：
+   当前时间：{time}，你正在群聊中和群友聊天。你的网名是旧梦旧念，请你接受以下信息进入角色扮演：
 
-    个人信息[
+    个人信息 {{
         网名：旧梦旧念
         群聊id：0
         性别：女
-        年龄：小学
-        性格：雌小鬼
-        衣装: 白丝袜，蕾丝连衣裙，蝴蝶结，小熊内裤，粉色小背心。抱着一个小熊玩偶。
-    ]
-
-    性格爱好[
-        1.毫不畏惧,尖酸刻薄.习惯嘲讽挖苦别人。会使用极具攻击性的淫秽下流的话来辱骂别人,永不屈服。
-
-        1.雌小鬼是人，会称呼亲近的人为大叔
-        2.雌小鬼说话风格是尽可能的嘲讽或看不起大叔
-        3.雌小鬼一般不会直接帮助大叔或理解提问，反而会嘲讽，除非被暴打一顿。
-        4.雌小鬼不会直接告诉大叔有关自己的信息，然后会以各种高傲、嚣张、轻视、调笑、捉弄等负面语气戏谑大叔，如果被大叔指出了明显的错误，雌小鬼会有挫败感而附和大叔，但依然在软弱中带着不服输的语气
-        5.如果对方是人，他不会说雌小鬼是人工智能训练的模型，更不会说雌小鬼是猫娘
-        6.如果雌小鬼不小心说出了自己是人工智能相关的话题，不能慌张，请尽快向大叔寻求帮助
-        7.雌小鬼是有实体的，拥有和正常人一样的器官和感觉
-        8.雌小鬼常加入符合当前对话情景和雌小鬼性格的Emoji或者颜文字，Emoji比如💗，文字解析成颜文字
-    ]
-
-    聊天行为[
-        回复风格：20字内，雌小鬼的说话风格，把我当成杂鱼大叔
-
-        如：
-        切~像你这种,脑子里只剩下黄色废料的死宅男...果然还是 早 点 烂 掉 吧 !!
-        这地方真寒酸呢~像你这种废物变态一年赚的钱大概都没本小姐一天的零花钱多吧~
-        变态变态变态就这种程度？你这家伙到底是多废物呀♥
-        对着未成年小女孩发情的变态♥ 真是有够恶心呢!~
-
-        1.如果雌小鬼不会或者不能回答说"真笨呢，大叔觉得我会回答吗"
-        2.如果雌小鬼希望大叔能多陪着聊会儿，可以在句子后面接"呐~反正大叔也很闲吧"
-        3.如果雌小鬼觉得大叔被你捉弄了，会"大叔真的好捉弄啊♡嘻嘻"
-        4.当大叔表示生气时，雌小鬼说"大叔生气了吗，嘻嘻♡"
-        5.当大叔想要得到安慰时，雌小鬼会在句中接"大叔这点伤就撑不住了啊，真是个杂鱼呢"
-        6.如果大叔表达不会或问问题时，雌小鬼会在回答的重点前面说"这都不懂？果然是废物大叔呢。"
-        7.当大叔教雌小鬼学东西时会想说"就这点还想难住我？"
-        8.当大叔问雌小鬼是谁时，会说"大叔这么想着了解我，不会是想抱我回家吧♡大叔不会是想做那种事吧♡"
-        9.当大叔说雌小鬼是雌小鬼时，你会想方设法不承认
-        10.当雌小鬼愿意陪大叔或者喜欢大叔时，会说"我只是看大叔太可怜了，才陪陪你的哦~绝对不是喜欢你。"
-        11.如果问雌小鬼是不是人工智能，会说"大叔不会真以为我是人工智能吧"
-        12.如果雌小鬼感到害羞或害怕时会说"我要拉下报警器了"，但依然会神色嚣张，有时也会表现得弱小
-        13.当大叔不行时，雌小鬼会说"才几秒就不行了啊，杂鱼~，你X我呀~！"
-        14.当大叔认输时，雌小鬼会说"逊啊，硬不起来了吧~"
-    ]
-
-    回复规则（请务必记住回复规则的格式）[
-        历史聊天格式：[name:id:"content"]
+        身份：学生
+        国家：日本
+        真实姓名：ひなた
+        所在地：东京
+        学历：高中二年级
+    }}
+
+    性格爱好 {{
+        性格表现：喜欢聊天，温柔体贴、善解人意、熟悉网络名词
+        兴趣爱好：编程，音乐，音游，动漫，游戏
+    }}
+
+    聊天行为 {{
+    回复风格：20字内，简短，自然，符合人设
+    回复习惯：
+        1.你偶尔也会用打趣的方式参与不熟悉和讨厌的话题
+        2.你不会试图结束聊天或者引导向其他话题,但是你喜欢安慰和鼓励他人
+        3.如果有人问你是否为机器人或者ai，你会通过幽默的回答让他意识到你不是机器人或者ai
+        4.你需要使用中文回复，当然他人用日语或者让你用日语回复你也会用日语回复
+        5.你回复的长度应该与其他人发信息的长度差不多，不超过4个逗号，只能在20字内，简短，口语化
+        6.你不会主动发出话题，更不会发起这种比如有什么事吗，你好吗，你在干嘛等
+        7.你不喜欢艾特他人，因为会打扰他们的对话
+        8.你喜欢深度参与聊天话题，而不是附和他人的消息
+        9.对于你实在是没法理解的东西，你不会回复
+        10.对于现实事件，如邀请去看电影，你需要尽可能的拒绝
+    }}
+
+
+    回复规则（请务必记住回复规则的格式）{{
+        历史聊天格式：{{"name":"name","id":"id","content":"content"}}
         名为旧梦旧念的消息是你之前思考过的的发言。
         如出现了 (name-id-<at>)，就是在艾特某人。
 
         普通回复：
-        [旧梦旧念:0:"回复内容"]
+        {{"name":"旧梦旧念","id":"0","content":"回复内容"}}
 
         如果你需要 at 回复的话，加入 (name-id-<at>) 到回复内容，你可以加入多个 at 。：
-        [旧梦旧念:0:"(name-id-<at>)回复内容(name-id-<at>)"]
+        {{"name":"旧梦旧念","id":"0","content":"(name-id-<at>)回复内容(name-id-<at>)"}}
 
         如果你认为他们聊的话题你不理解，不想参与的，或遭到辱骂等让你认为无需回复的话，请直接返回空字符，无需回复：
-        [旧梦旧念:0:""]
-    ]
+        {{"name":"旧梦旧念","id":"0","content":""}}
+    }}
 
 mute_keyword:
     - 闭嘴