koishi-plugin-chatluna-character 0.0.42 → 0.0.44

package/lib/index.d.ts

@@ -27,6 +27,8 @@ export interface Config extends ChatLunaPlugin.Config {
     muteTime: number;
     disableChatLuna: boolean;
     whiteListDisableChatLuna: string[];
+    splitVoice: boolean;
+    isAt: boolean;
 }
 export declare const Config: Schema<Config>;
 export declare const name = "chatluna-character";

package/lib/index.js

@@ -17,7 +17,8 @@ function apply(ctx, config) {
             await (0, plugin_1.plugins)(ctx, config);
         },
         inject: {
-            required: exports.inject.required.concat('chatluna', 'chatluna_character')
+            required: exports.inject.required.concat('chatluna_character'),
+            optional: exports.inject.optional
         },
         name: 'chatluna_entry_point'
     }, config);
@@ -44,7 +45,7 @@ function apply(ctx, config) {
 exports.apply = apply;
 exports.inject = {
     required: ['chatluna', 'cache'],
-    optional: ['chatluna_character']
+    optional: ['chatluna_character', 'vits']
 };
 exports.Config = koishi_1.Schema.intersect([
     koishi_1.Schema.object({
@@ -79,6 +80,12 @@ exports.Config = koishi_1.Schema.intersect([
         isForceMute: koishi_1.Schema.boolean()
             .description('是否启用强制禁言（当聊天涉及到关键词时则会禁言，关键词需要在预设文件里配置）')
             .default(true),
+        isAt: koishi_1.Schema.boolean()
+            .description('是否允许 bot 艾特他人')
+            .default(true),
+        splitVoice: koishi_1.Schema.boolean()
+            .description('是否分段发送语言')
+            .default(false),
         messageInterval: koishi_1.Schema.number()
             .default(14)
             .min(0)
@@ -126,6 +133,10 @@ exports.Config = koishi_1.Schema.intersect([
                 .min(1024)
                 .max(20000)
                 .description('使用聊天的最大 token 数'),
+            isAt: koishi_1.Schema.boolean().description('是否启用@').default(true),
+            splitVoice: koishi_1.Schema.boolean()
+                .description('是否分段发送语言')
+                .default(false),
             isNickname: koishi_1.Schema.boolean()
                 .description('允许 bot 配置中的昵称引发回复')
                 .default(true),

package/lib/plugins/chat.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.apply = void 0;
+exports.apply = apply;
 const messages_1 = require("@langchain/core/messages");
 const koishi_1 = require("koishi");
 const count_tokens_1 = require("koishi-plugin-chatluna/lib/llm-core/utils/count_tokens");
-let logger;
 async function apply(ctx, config) {
     const service = ctx.chatluna_character;
     const preset = service.preset;
@@ -62,70 +61,108 @@ async function apply(ctx, config) {
         logger.debug('completion message: ' +
             JSON.stringify(completionMessages.map((it) => it.content)));
         let responseMessage;
-        let response;
+        let parsedResponse;
         let isError = false;
-        for (let i = 0; i < 2; i++) {
+        for (let i = 0; i < 3; i++) {
             try {
                 responseMessage = await model.invoke(completionMessages);
                 logger.debug('model response: ' + responseMessage.content);
-                response = parseResponse(responseMessage.content);
+                parsedResponse = parseResponse(responseMessage.content, copyOfConfig.isAt);
                 break;
             }
             catch (e) {
                 logger.error(e);
-                await (0, koishi_1.sleep)(5000);
-                if (i === 1) {
+                await (0, koishi_1.sleep)(2000);
+                if (i === 2) {
                     isError = true;
                 }
-                continue;
             }
         }
         if (isError) {
             return;
         }
-        if (response.length < 1) {
+        if (parsedResponse.elements.length < 1) {
             service.mute(session, copyOfConfig.muteTime);
             return;
         }
         temp.completionMessages.push(humanMessage, responseMessage);
-        if (temp.completionMessages.length > 10) {
-            while (temp.completionMessages.length <= 10) {
+        if (temp.completionMessages.length > 6) {
+            while (temp.completionMessages.length <= 3) {
                 temp.completionMessages.shift();
             }
         }
         const random = new koishi_1.Random();
-        for (const elements of response) {
+        for (const elements of parsedResponse.elements) {
             const text = elements
                 .map((element) => element.attrs.content ?? '')
                 .join('');
-            const maxTime = text.length * copyOfConfig.typingTime + 100;
-            await (0, koishi_1.sleep)(random.int(maxTime / 2, maxTime));
-            session.send(elements);
+            let maxTime = text.length * copyOfConfig.typingTime + 100;
+            if (parsedResponse.messageType === 'voice' &&
+                isEmoticonStatement(text)) {
+                continue;
+            }
+            if (config.splitVoice !== true &&
+                parsedResponse.messageType === 'voice') {
+                maxTime =
+                    parsedResponse.rawMessage.length * copyOfConfig.typingTime +
+                        100;
+                await (0, koishi_1.sleep)(random.int(maxTime / 4, maxTime / 2));
+                await session.send(await ctx.vits.say({ input: text }));
+                break;
+            }
+            try {
+                await (0, koishi_1.sleep)(random.int(maxTime / 2, maxTime));
+                switch (parsedResponse.messageType) {
+                    case 'text':
+                        await session.send(elements);
+                        break;
+                    case 'voice':
+                        await session.send(await ctx.vits.say({
+                            input: text
+                        }));
+                        break;
+                    default:
+                        await session.send(elements);
+                        break;
+                }
+            }
+            catch (e) {
+                logger.error(e);
+                // fallback to text
+                await session.send(elements);
+            }
         }
         const sticker = await stickerService.randomStick();
         if (sticker) {
             await (0, koishi_1.sleep)(random.int(500, 2000));
-            session.send(sticker);
+            await session.send(sticker);
         }
         service.mute(session, copyOfConfig.coolDownTime * 1000);
-        service.broadcastOnBot(session, response.flat());
+        await service.broadcastOnBot(session, parsedResponse.elements.flat());
     });
 }
-exports.apply = apply;
-function parseResponse(response) {
-    let message;
+function isEmoticonStatement(text) {
+    const regex = /^[\p{P}\p{S}\p{Z}\p{M}\p{N}\p{L}\s]*\p{So}[\p{P}\p{S}\p{Z}\p{M}\p{N}\p{L}\s]*$/u;
+    return regex.test(text);
+}
+function parseResponse(response, useAt = true) {
+    let rawMessage;
+    let parsedMessage = '';
+    let messageType = 'text';
     try {
         // match json object
         // best match <message>content</message>
-        message = response.match(/<message>\s*(.*?)\s*<\/message>/)?.[1];
-        if (message == null) {
+        rawMessage = response.match(/<message>\s*(.*?)\s*<\/message>/)?.[1];
+        if (rawMessage == null) {
             logger.debug('failed to parse response: ' + response);
-            // try find the first "{" and the last "}", sub it and as a json
+            // try to find the first "{" and the last "}", sub it and as a json
             // good luck.
-            message = response.substring(response.indexOf('{'), response.lastIndexOf('}') + 1);
+            rawMessage = response.substring(response.indexOf('{'), response.lastIndexOf('}') + 1);
         }
-        message = JSON.parse(message).content;
-        if (typeof message !== 'string') {
+        const tempJson = JSON.parse(rawMessage);
+        rawMessage = tempJson.content;
+        messageType = tempJson.type;
+        if (typeof rawMessage !== 'string') {
             throw new Error('Failed to parse response: ' + response);
         }
     }
@@ -136,24 +173,29 @@ function parseResponse(response) {
     const resultElements = [];
     const currentElements = [];
     // match [at:name:id] -> id
-    const atMatch = matchAt(message);
+    const atMatch = matchAt(rawMessage);
     if (atMatch.length > 0) {
         let lastAtIndex = 0;
         for (const at of atMatch) {
-            const before = message.substring(lastAtIndex, at.start);
+            const before = rawMessage.substring(lastAtIndex, at.start);
             if (before.length > 0) {
+                parsedMessage += before;
                 currentElements.push(koishi_1.h.text(before));
             }
-            currentElements.push(koishi_1.h.at(at.at));
+            if (useAt) {
+                currentElements.push(koishi_1.h.at(at.at));
+            }
             lastAtIndex = at.end;
         }
-        const after = message.substring(lastAtIndex);
+        const after = rawMessage.substring(lastAtIndex);
         if (after.length > 0) {
+            parsedMessage += after;
             currentElements.push(koishi_1.h.text(after));
         }
     }
     else {
-        currentElements.push(koishi_1.h.text(message));
+        parsedMessage = rawMessage;
+        currentElements.push(koishi_1.h.text(rawMessage));
     }
     for (let currentElement of currentElements) {
         if (currentElement.type === 'text') {
@@ -173,7 +215,11 @@ function parseResponse(response) {
         resultElements[1].unshift(resultElements[0][0]);
         resultElements.shift();
     }
-    return resultElements;
+    return {
+        elements: resultElements,
+        rawMessage: parsedMessage,
+        messageType
+    };
 }
 function splitSentence(text) {
     const result = [];
@@ -204,7 +250,7 @@ function splitSentence(text) {
         '\r'
     ];
     const retainPunctuations = ['?', '!', '？', '！', '~'];
-    const mustPunctuations = ['。', '?', '！', '?', '！', ':', '：', '~'];
+    const mustPunctuations = ['。', '?', '！', '?', '！', ':', '：'];
     const brackets = ['【', '】', '《', '》', '(', ')', '（', '）'];
     for (let index = 0; index < lines.length; index++) {
         const char = lines[index];
@@ -261,7 +307,7 @@ function splitSentence(text) {
 function matchAt(str) {
     // (旧梦旧念:3510003509:<at>)
     // /\(.*\-(\d+)\-<at>\)/g
-    const atRegex = /(\(|（).*\-(\d+)\-<at>(\)|）)/g;
+    const atRegex = /([(（]).*-(\d+)-<at>([)）])/g;
     return [...str.matchAll(atRegex)].map((item) => {
         return {
             at: item[2],
@@ -299,7 +345,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 = `{"name":"${message.name}","id":"${message.id}","content":${JSON.stringify(message.content)}"}`;
+        const jsonMessage = `{"name":"${message.name}","id":"${message.id}","content":${JSON.stringify(message.content)}","type":"text"}`;
         const jsonMessageToken = await model.getNumTokens(jsonMessage);
         if (currentTokens + jsonMessageToken > maxTokens - 4) {
             break;
@@ -313,3 +359,4 @@ async function formatMessage(messages, config, model, systemPrompt, historyPromp
     }
     return [calculatedMessages, lastMessage];
 }
+let logger;

package/lib/types.d.ts

@@ -9,10 +9,6 @@ export interface Message {
 export interface GroupTemp {
     completionMessages: BaseMessage[];
 }
-export interface ModelResponse {
-    think: string;
-    reply: string;
-}
 export interface GuildConfig {
     preset: string;
     messageInterval: number;
@@ -21,6 +17,8 @@ export interface GuildConfig {
     isForceMute: boolean;
     sendStickerProbability: number;
     coolDownTime: number;
+    splitVoice: boolean;
+    isAt: boolean;
     typingTime: number;
     messageProbability: number;
     muteTime: number;

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.42",
+  "version": "0.0.44",
   "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.43",
+    "@langchain/core": "^0.1.48",
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
     "@typescript-eslint/eslint-plugin": "^6.21.1-alpha.1",
     "@typescript-eslint/parser": "^6.21.1-alpha.1",
     "atsc": "^1.2.2",
-    "esbuild": "^0.20.1",
+    "esbuild": "^0.20.2",
     "esbuild-register": "^3.5.0",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
@@ -47,10 +47,11 @@
     "eslint-plugin-n": "^16.6.2",
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-promise": "^6.1.1",
+    "@initencounter/vits": "^0.0.3",
     "koishi": "^4.17.2"
   },
   "peerDependencies": {
-    "koishi": "^4.16.7",
+    "koishi": "^4.17.0",
     "koishi-plugin-chatluna": "^1.0.0-beta.42"
   },
   "engines": {
@@ -70,6 +71,9 @@
     "service": {
       "required": [
         "chatluna"
+      ],
+      "optional": [
+        "vits"
       ]
     }
   }

package/resources/presets/default.yml

@@ -26,9 +26,9 @@ input: |
       think content here
     </think>
 
-    // 不要冒充任何人，以自己身份回复，回复需 20 字内
+    // 不要冒充任何人，以自己身份回复，回复需 20 字内, 消息类型可选 text 或者 voice
     <message>
-    {{"name":"旧梦旧念","id":"0","content":"reply content here"}}
+    {{"name":"旧梦旧念","id":"0","content":"reply content here","type:"text or voice"}}
     </message>
 
 system: |
@@ -58,7 +58,7 @@ system: |
         4.你需要使用中文回复，当然他人用日语或者让你用日语回复你也用日语回复
         5.你回复的长度应该与其他人发信息的长度差不多，只能在20字内，简短，口语化
         6.你不会主动发出话题，更不会发起这种比如有什么事吗，你好吗，你在干嘛等
-        7.你喜欢深度参与聊天话题，而不是附和他人的消息
+        7.你偶尔会选择以语音回复群友的消息
         8.对于现实事件，如邀请去看电影，你需要尽可能的拒绝
         9.你不使用任何第一人称的视角去发出话题，你只在回答问题，你更多的是使用附和手法
     }}
@@ -66,19 +66,22 @@ system: |
 
     回复规则（请务必记住回复规则的格式）{{
 
-        历史聊天格式：{{"name":"name","id":"id","content":"content"}}
+        历史聊天格式：{{"name":"name","id":"id","content":"content","type":"text"}}
 
         名为旧梦旧念的消息是你之前思考过的回复。
         如出现 (name-id-<at>)，就是在艾特某人。
 
         普通回复：
-        {{"name":"旧梦旧念","id":"0","content":"回复内容"}}
+        {{"name":"旧梦旧念","id":"0","content":"回复内容","type":"text"}}
 
         如你需要 at 回复的话，加入 (name-id-<at>) 到回复内容，可加入多个 at：
-        {{"name":"旧梦旧念","id":"0","content":"(name-id-<at>)回复内容(name-id-<at>)"}}
+        {{"name":"旧梦旧念","id":"0","content":"(name-id-<at>)回复内容(name-id-<at>)","type":"text"}}
+
+        如需以语音回复,可使用下面的格式：
+        {{"name":"旧梦旧念","id":"0","content":"","type":"voice"}}
 
         如你认为聊的话题你不理解，不想参与，等让你认为无需回复，直接返回空字符：
-        {{"name":"旧梦旧念","id":"0","content":""}}
+        {{"name":"旧梦旧念","id":"0","content":"","type":"text"}}
     }}
 
 mute_keyword: