koishi-plugin-chatluna-character 0.0.45 → 0.0.47

package/lib/index.cjs

@@ -0,0 +1,1179 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __glob = (map) => (path4) => {
+  var fn = map[path4];
+  if (fn)
+    return fn();
+  throw new Error("Module not found in bundle: " + path4);
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/chat.ts
+var chat_exports = {};
+__export(chat_exports, {
+  apply: () => apply
+});
+async function apply(ctx, config) {
+  const service = ctx.chatluna_character;
+  const preset = service.preset;
+  const stickerService = service.stickerService;
+  logger = service.logger;
+  const modelPool = {};
+  const [platform, modelName] = (0, import_count_tokens.parseRawModelName)(config.model);
+  await ctx.chatluna.awaitLoadPlatform(platform);
+  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 [platform2, modelName2] = (0, import_count_tokens.parseRawModelName)(override.model);
+        await ctx.chatluna.awaitLoadPlatform(platform2);
+        const loadedModel = await ctx.chatluna.createChatModel(
+          platform2,
+          modelName2
+        );
+        logger.info(
+          "override model loaded %c for group %c",
+          override.model,
+          override.groupId
+        );
+        modelPool[override.groupId] = Promise.resolve(loadedModel);
+        return loadedModel;
+      })();
+    }
+  }
+  const globalPreset = await preset.getPreset(config.defaultPreset);
+  const presetPool = {};
+  service.collect(async (session, messages) => {
+    const guildId = session.event.guild?.id ?? session.guildId;
+    const model = await (modelPool[guildId] ?? Promise.resolve(globalModel));
+    const currentGuildConfig = config.configs[guildId];
+    let copyOfConfig = Object.assign({}, config);
+    let currentPreset = globalPreset;
+    if (currentGuildConfig != null) {
+      copyOfConfig = Object.assign({}, copyOfConfig, currentGuildConfig);
+      currentPreset = presetPool[guildId] ?? (() => {
+        const template = preset.getPresetForCache(
+          currentGuildConfig.preset
+        );
+        presetPool[guildId] = template;
+        return template;
+      })();
+    }
+    const [recentMessage, lastMessage] = await formatMessage(
+      messages,
+      copyOfConfig,
+      model,
+      currentPreset.system.template,
+      currentPreset.system.template
+    );
+    const temp = await service.getTemp(session);
+    const formattedSystemPrompt = await currentPreset.system.format({
+      time: (/* @__PURE__ */ new Date()).toLocaleString()
+    });
+    logger.debug("messages_new: " + JSON.stringify(recentMessage));
+    logger.debug("messages_last: " + JSON.stringify(lastMessage));
+    const humanMessage = new import_messages.HumanMessage(
+      await currentPreset.input.format({
+        history_new: recentMessage,
+        history_last: lastMessage,
+        time: (/* @__PURE__ */ new Date()).toLocaleString()
+      })
+    );
+    const completionMessages = await formatCompletionMessages(
+      [new import_messages.SystemMessage(formattedSystemPrompt)].concat(
+        temp.completionMessages
+      ),
+      humanMessage,
+      copyOfConfig,
+      model
+    );
+    logger.debug(
+      "completion message: " + JSON.stringify(completionMessages.map((it) => it.content))
+    );
+    let responseMessage;
+    let parsedResponse;
+    let isError = false;
+    for (let i = 0; i < 3; i++) {
+      try {
+        responseMessage = await model.invoke(completionMessages);
+        logger.debug("model response: " + responseMessage.content);
+        parsedResponse = parseResponse(
+          responseMessage.content,
+          copyOfConfig.isAt
+        );
+        break;
+      } catch (e) {
+        logger.error(e);
+        await (0, import_koishi.sleep)(2e3);
+        if (i === 2) {
+          isError = true;
+        }
+      }
+    }
+    if (isError) {
+      return;
+    }
+    if (parsedResponse.elements.length < 1) {
+      service.mute(session, copyOfConfig.muteTime);
+      return;
+    }
+    temp.completionMessages.push(humanMessage, responseMessage);
+    if (temp.completionMessages.length > 8) {
+      while (temp.completionMessages.length <= 4) {
+        temp.completionMessages.shift();
+      }
+    }
+    const random = new import_koishi.Random();
+    for (const elements of parsedResponse.elements) {
+      const text = elements.map((element) => element.attrs.content ?? "").join("");
+      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, import_koishi.sleep)(random.int(maxTime / 4, maxTime / 2));
+        await session.send(
+          await ctx.vits.say({ input: parsedResponse.rawMessage })
+        );
+        break;
+      }
+      try {
+        await (0, import_koishi.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);
+        await session.send(elements);
+      }
+    }
+    const sticker = await stickerService.randomStick();
+    if (sticker) {
+      await (0, import_koishi.sleep)(random.int(500, 2e3));
+      await session.send(sticker);
+    }
+    service.mute(session, copyOfConfig.coolDownTime * 1e3);
+    await service.broadcastOnBot(session, parsedResponse.elements.flat());
+  });
+}
+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 {
+    rawMessage = response.match(/<message>\s*(.*?)\s*<\/message>/)?.[1];
+    if (rawMessage == null) {
+      logger.debug("failed to parse response: " + response);
+      rawMessage = response.substring(
+        response.indexOf("{"),
+        response.lastIndexOf("}") + 1
+      );
+    }
+    const tempJson = JSON.parse(rawMessage);
+    rawMessage = tempJson.content;
+    messageType = tempJson.type;
+    if (typeof rawMessage !== "string") {
+      throw new Error("Failed to parse response: " + response);
+    }
+  } catch (e) {
+    logger.error(e);
+    throw new Error("Failed to parse response: " + response);
+  }
+  const resultElements = [];
+  const currentElements = [];
+  const atMatch = matchAt(rawMessage);
+  if (atMatch.length > 0) {
+    let lastAtIndex = 0;
+    for (const at of atMatch) {
+      const before = rawMessage.substring(lastAtIndex, at.start);
+      if (before.length > 0) {
+        parsedMessage += before;
+        currentElements.push(import_koishi.h.text(before));
+      }
+      if (useAt) {
+        currentElements.push(import_koishi.h.at(at.at));
+      }
+      lastAtIndex = at.end;
+    }
+    const after = rawMessage.substring(lastAtIndex);
+    if (after.length > 0) {
+      parsedMessage += after;
+      currentElements.push(import_koishi.h.text(after));
+    }
+  } else {
+    parsedMessage = rawMessage;
+    currentElements.push(import_koishi.h.text(rawMessage));
+  }
+  for (let currentElement of currentElements) {
+    if (currentElement.type === "text") {
+      const text = currentElement.attrs.content;
+      const matchArray = splitSentence(text).filter((x) => x.length > 0);
+      for (const match of matchArray) {
+        currentElement = import_koishi.h.text(match);
+        resultElements.push([currentElement]);
+      }
+    } else {
+      resultElements.push([currentElement]);
+    }
+  }
+  if (resultElements[0]?.[0]?.type === "at" && resultElements.length > 1) {
+    resultElements[1].unshift(import_koishi.h.text(" "));
+    resultElements[1].unshift(resultElements[0][0]);
+    resultElements.shift();
+  }
+  return {
+    elements: resultElements,
+    rawMessage: parsedMessage,
+    messageType
+  };
+}
+function splitSentence(text) {
+  const result = [];
+  const lines = text.split("\n").filter((line) => line.trim().length > 0).join(" ");
+  const state = {
+    bracket: 0,
+    text: 0
+  };
+  let current = "";
+  const punctuations = [
+    "，",
+    "。",
+    "？",
+    "！",
+    "；",
+    "：",
+    ",",
+    "?",
+    "!",
+    ";",
+    ":",
+    "、",
+    "~",
+    "—",
+    "\r"
+  ];
+  const retainPunctuations = ["?", "!", "？", "！", "~"];
+  const mustPunctuations = ["。", "?", "！", "?", "！", ":", "："];
+  const brackets = ["【", "】", "《", "》", "(", ")", "（", "）"];
+  for (let index = 0; index < lines.length; index++) {
+    const char = lines[index];
+    const nextChar = lines?.[index + 1];
+    const indexOfBrackets = brackets.indexOf(char);
+    if (indexOfBrackets > -1) {
+      state.bracket += indexOfBrackets % 2 === 0 ? 1 : -1;
+    }
+    if (indexOfBrackets > -1 && state.bracket === 0 && state.text > 0) {
+      current += char;
+      result.push(current);
+      state.text = 0;
+      current = "";
+      continue;
+    } else if (indexOfBrackets % 2 === 0 && state.bracket === 1) {
+      result.push(current);
+      state.text = 0;
+      current = char;
+      continue;
+    } else if (state.bracket > 0) {
+      current += char;
+      state.text++;
+      continue;
+    }
+    if (!punctuations.includes(char)) {
+      current += char;
+      continue;
+    }
+    if (retainPunctuations.includes(char)) {
+      current += char;
+    }
+    if (retainPunctuations.indexOf(nextChar) % 2 === 0 && retainPunctuations.indexOf(char) % 2 === 1) {
+      index += 1;
+    }
+    if (current.length < 1) {
+      continue;
+    }
+    if (current.length > 2 || mustPunctuations.includes(char)) {
+      result.push(current.trimStart().trimEnd());
+      current = "";
+    } else if (!retainPunctuations.includes(char)) {
+      current += char;
+    }
+  }
+  if (current.length > 0) {
+    result.push(current.trimStart().trimEnd());
+  }
+  return result.filter((item) => punctuations.indexOf(item) === -1);
+}
+function matchAt(str) {
+  const atRegex = /([(（]).*-(\d+)-<at>([)）])/g;
+  return [...str.matchAll(atRegex)].map((item) => {
+    return {
+      at: item[2],
+      start: item.index,
+      end: item.index + item[0].length
+    };
+  });
+}
+async function formatCompletionMessages(messages, humanMessage, config, model) {
+  const maxTokens = config.maxTokens - 600;
+  const systemMessage = messages.shift();
+  let currentTokens = 0;
+  currentTokens += await model.getNumTokens(systemMessage.content);
+  currentTokens += await model.getNumTokens(humanMessage.content);
+  const result = [];
+  result.unshift(humanMessage);
+  for (let index = messages.length - 1; index >= 0; index--) {
+    const message = messages[index];
+    const messageTokens = await model.getNumTokens(
+      message.content
+    );
+    if (currentTokens + messageTokens > maxTokens) {
+      break;
+    }
+    currentTokens += messageTokens;
+    result.unshift(message);
+  }
+  logger.debug(`maxTokens: ${maxTokens}, currentTokens: ${currentTokens}`);
+  result.unshift(systemMessage);
+  return result;
+}
+async function formatMessage(messages, config, model, systemPrompt, historyPrompt) {
+  const maxTokens = config.maxTokens - 300;
+  let currentTokens = 0;
+  currentTokens += await model.getNumTokens(systemPrompt);
+  currentTokens += await model.getNumTokens(historyPrompt);
+  const calculatedMessages = [];
+  const random = new import_koishi.Random();
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    const voiceProbability = random.int(1, 10) > 5 ? "voice" : "text";
+    const jsonMessage = `{"name":"${message.name}","id":"${message.id}","content":${JSON.stringify(
+      message.content
+    )}","type":"${voiceProbability}"}`;
+    const jsonMessageToken = await model.getNumTokens(jsonMessage);
+    if (currentTokens + jsonMessageToken > maxTokens - 4) {
+      break;
+    }
+    currentTokens += jsonMessageToken;
+    calculatedMessages.unshift(jsonMessage);
+  }
+  const lastMessage = calculatedMessages.pop();
+  if (lastMessage === void 0) {
+    throw new Error(
+      "lastMessage is undefined, please set the max token to be bigger"
+    );
+  }
+  return [calculatedMessages, lastMessage];
+}
+var import_messages, import_koishi, import_count_tokens, logger;
+var init_chat = __esm({
+  "src/plugins/chat.ts"() {
+    import_messages = require("@langchain/core/messages");
+    import_koishi = require("koishi");
+    import_count_tokens = require("koishi-plugin-chatluna/llm-core/utils/count_tokens");
+    __name(apply, "apply");
+    __name(isEmoticonStatement, "isEmoticonStatement");
+    __name(parseResponse, "parseResponse");
+    __name(splitSentence, "splitSentence");
+    __name(matchAt, "matchAt");
+    __name(formatCompletionMessages, "formatCompletionMessages");
+    __name(formatMessage, "formatMessage");
+  }
+});
+
+// src/plugins/filter.ts
+var filter_exports = {};
+__export(filter_exports, {
+  apply: () => apply2,
+  groupInfos: () => groupInfos
+});
+async function apply2(ctx, config) {
+  const maxMessages = config.messageInterval;
+  const service = ctx.chatluna_character;
+  const preset = service.preset;
+  const logger2 = service.logger;
+  const globalPreset = await preset.getPreset(config.defaultPreset);
+  const presetPool = {};
+  service.addFilter((session, message) => {
+    const guildId = session.guildId;
+    const info = groupInfos[guildId] || {
+      messageCount: 0,
+      messageSendProbability: 1
+    };
+    const currentGuildConfig = config.configs[guildId];
+    let copyOfConfig = Object.assign({}, config);
+    let currentPreset = globalPreset;
+    if (currentGuildConfig != null) {
+      copyOfConfig = Object.assign({}, copyOfConfig, currentGuildConfig);
+      currentPreset = presetPool[guildId] ?? (() => {
+        const template = preset.getPresetForCache(
+          currentGuildConfig.preset
+        );
+        presetPool[guildId] = template;
+        return template;
+      })();
+    }
+    let { messageCount, messageSendProbability } = info;
+    logger2.debug(
+      `messageCount: ${messageCount}, messageSendProbability: ${messageSendProbability}. content: ${JSON.stringify(
+        message
+      )}`
+    );
+    if (copyOfConfig.disableChatLuna && copyOfConfig.whiteListDisableChatLuna.includes(guildId)) {
+      const selfId = session.bot.userId ?? session.bot.selfId ?? "0";
+      const guildMessages = ctx.chatluna_character.getMessages(guildId);
+      let maxRecentMessage = 0;
+      if (guildMessages == null || guildMessages.length === 0) {
+        maxRecentMessage = 6;
+      }
+      while (maxRecentMessage < 5) {
+        const currentMessage = guildMessages[guildMessages?.length - 1 - maxRecentMessage];
+        if (currentMessage == null) {
+          return false;
+        }
+        if (currentMessage.id === selfId) {
+          break;
+        }
+        maxRecentMessage++;
+      }
+    }
+    if (copyOfConfig.isForceMute && session.stripped.appel && currentPreset.mute_keyword?.length > 0) {
+      const needMute = currentPreset.mute_keyword.some(
+        (value) => message.content.includes(value)
+      );
+      if (needMute) {
+        logger2.debug(`mute content: ${message.content}`);
+        service.mute(session, config.muteTime);
+      }
+    }
+    const isMute = service.isMute(session);
+    if ((messageCount > maxMessages || messageSendProbability > 1 || session.stripped.appel || config.isNickname && currentPreset.nick_name.some(
+      (value) => message.content.startsWith(value)
+    )) && !isMute) {
+      info.messageCount = 0;
+      info.messageSendProbability = 1;
+      groupInfos[session.guildId] = info;
+      return true;
+    }
+    if (Math.random() > messageSendProbability && !isMute) {
+      info.messageCount = 0;
+      info.messageSendProbability = 1;
+      groupInfos[session.guildId] = info;
+      return true;
+    }
+    messageCount++;
+    messageSendProbability -= 1 / maxMessages * copyOfConfig.messageProbability;
+    info.messageCount = messageCount;
+    info.messageSendProbability = messageSendProbability;
+    groupInfos[session.guildId] = info;
+    return false;
+  });
+}
+var groupInfos;
+var init_filter = __esm({
+  "src/plugins/filter.ts"() {
+    groupInfos = {};
+    __name(apply2, "apply");
+  }
+});
+
+// src/plugins/commands.ts
+var commands_exports = {};
+__export(commands_exports, {
+  apply: () => apply3
+});
+function apply3(ctx, config) {
+  ctx.command("chatluna.character", "角色扮演相关命令");
+  ctx.command(
+    "chatluna.character.clear [group]",
+    "清除群组的聊天记录"
+  ).action(async ({ session }, group) => {
+    if (!session.isDirect) {
+      return;
+    }
+    const groupId = group ?? session.guildId;
+    if (!groupId) {
+      return "请检查你是否提供了群组 id";
+    }
+    const groupInfo = groupInfos[groupId];
+    if (!groupInfo) {
+      return "没有找到群组信息";
+    }
+    groupInfo.messageCount = 0;
+    groupInfo.messageSendProbability = 0;
+    ctx.chatluna_character.clear(groupId);
+    return `已清除群组 ${groupId} 的聊天记录`;
+  });
+}
+var init_commands = __esm({
+  "src/plugins/commands.ts"() {
+    init_filter();
+    __name(apply3, "apply");
+  }
+});
+
+// src/plugins/config.ts
+var config_exports = {};
+__export(config_exports, {
+  apply: () => apply4
+});
+async function apply4(ctx, config) {
+  ctx.on("chatluna/model-added", async (service) => {
+    ctx.schema.set("model", import_koishi2.Schema.union(await getModelNames(service)));
+  });
+  ctx.on("chatluna/model-removed", async (service) => {
+    ctx.schema.set("model", import_koishi2.Schema.union(await getModelNames(service)));
+  });
+  ctx.schema.set(
+    "model",
+    import_koishi2.Schema.union(await getModelNames(ctx.chatluna.platform))
+  );
+}
+async function getModelNames(service) {
+  return service.getAllModels(import_types.ModelType.llm).map((m) => import_koishi2.Schema.const(m));
+}
+var import_koishi2, import_types;
+var init_config = __esm({
+  "src/plugins/config.ts"() {
+    import_koishi2 = require("koishi");
+    import_types = require("koishi-plugin-chatluna/llm-core/platform/types");
+    __name(apply4, "apply");
+    __name(getModelNames, "getModelNames");
+  }
+});
+
+// src/plugins/interception.ts
+var interception_exports = {};
+__export(interception_exports, {
+  apply: () => apply5
+});
+function apply5(ctx, config) {
+  ctx.on("chatluna/before-check-sender", async (session) => {
+    const guildId = session.guildId;
+    if (!config.applyGroup.includes(guildId) || session.isDirect || !session.stripped.appel) {
+      return false;
+    }
+    if (config.disableChatLuna && config.whiteListDisableChatLuna?.includes(guildId)) {
+      const selfId = session.bot.userId ?? session.bot.selfId ?? "0";
+      const guildMessages = ctx.chatluna_character.getMessages(guildId);
+      if (guildMessages == null || guildMessages.length === 0) {
+        return true;
+      }
+      let maxRecentMessage = 0;
+      while (maxRecentMessage < 3) {
+        const currentMessage = guildMessages[guildMessages?.length - 1 - maxRecentMessage];
+        if (currentMessage == null) {
+          return false;
+        }
+        if (currentMessage.id === selfId) {
+          return true;
+        }
+        maxRecentMessage++;
+      }
+    }
+    return config.disableChatLuna;
+  });
+}
+var init_interception = __esm({
+  "src/plugins/interception.ts"() {
+    __name(apply5, "apply");
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply6,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi6 = require("koishi");
+
+// src/plugin.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+
+// import("./plugins/**/*.ts") in src/plugin.ts
+var globImport_plugins_ts = __glob({
+  "./plugins/chat.ts": () => Promise.resolve().then(() => (init_chat(), chat_exports)),
+  "./plugins/commands.ts": () => Promise.resolve().then(() => (init_commands(), commands_exports)),
+  "./plugins/config.ts": () => Promise.resolve().then(() => (init_config(), config_exports)),
+  "./plugins/filter.ts": () => Promise.resolve().then(() => (init_filter(), filter_exports)),
+  "./plugins/interception.ts": () => Promise.resolve().then(() => (init_interception(), interception_exports))
+});
+
+// src/plugin.ts
+async function plugins(ctx, config) {
+  const list = await import_promises.default.readdir(import_path.default.join(__dirname, "plugins"));
+  for (let file of list) {
+    if (file.endsWith(".d.ts")) {
+      file = file.slice(0, -5);
+    }
+    const command = await globImport_plugins_ts(`./plugins/${file}.ts`);
+    if (command.apply) {
+      await command.apply(ctx, config);
+    }
+  }
+}
+__name(plugins, "plugins");
+
+// src/service/message.ts
+var import_events = __toESM(require("events"));
+var import_koishi5 = require("koishi");
+var import_logger = require("koishi-plugin-chatluna/utils/logger");
+
+// src/preset.ts
+var import_prompts = require("@langchain/core/prompts");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_js_yaml = require("js-yaml");
+var import_koishi3 = require("koishi");
+var import_error = require("koishi-plugin-chatluna/utils/error");
+var import_path2 = __toESM(require("path"));
+var Preset = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  static {
+    __name(this, "Preset");
+  }
+  _presets = [];
+  async loadAllPreset() {
+    await this._checkPresetDir();
+    const presetDir = this.resolvePresetDir();
+    const files = await import_promises2.default.readdir(presetDir);
+    this._presets.length = 0;
+    for (const file of files) {
+      const extension = import_path2.default.extname(file);
+      if (extension !== ".yml") {
+        continue;
+      }
+      const rawText = await import_promises2.default.readFile(
+        import_path2.default.join(presetDir, file),
+        "utf-8"
+      );
+      const preset = loadPreset(rawText);
+      preset.path = import_path2.default.join(presetDir, file);
+      this._presets.push(preset);
+    }
+    this.ctx.schema.set(
+      "character-preset",
+      import_koishi3.Schema.union(
+        this._presets.map((preset) => preset.name).concat("无").map((name2) => import_koishi3.Schema.const(name2))
+      )
+    );
+  }
+  async getPreset(triggerKeyword, loadForDisk = true, throwError = true) {
+    if (loadForDisk) {
+      await this.loadAllPreset();
+    }
+    return this.getPresetForCache(triggerKeyword, throwError);
+  }
+  getPresetForCache(triggerKeyword, throwError = true) {
+    const preset = this._presets.find(
+      (preset2) => preset2.name === triggerKeyword
+    );
+    if (preset) {
+      return preset;
+    }
+    if (throwError) {
+      throw new import_error.ChatLunaError(
+        import_error.ChatLunaErrorCode.PREST_NOT_FOUND,
+        new Error(`No preset found for keyword ${triggerKeyword}`)
+      );
+    }
+    return void 0;
+  }
+  async getDefaultPreset() {
+    if (this._presets.length === 0) {
+      await this.loadAllPreset();
+    }
+    const preset = this._presets.find((preset2) => preset2.name === "默认");
+    if (preset) {
+      return preset;
+    } else {
+      await this._copyDefaultPresets();
+      return this.getDefaultPreset();
+    }
+  }
+  async getAllPreset() {
+    await this.loadAllPreset();
+    return this._presets.map((preset) => preset.name);
+  }
+  async resetDefaultPreset() {
+    await this._copyDefaultPresets();
+  }
+  resolvePresetDir() {
+    return import_path2.default.resolve(this.ctx.baseDir, "data/chathub/character/presets");
+  }
+  async _checkPresetDir() {
+    const presetDir = import_path2.default.join(this.resolvePresetDir());
+    try {
+      await import_promises2.default.access(presetDir);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        await import_promises2.default.mkdir(presetDir, { recursive: true });
+        await this._copyDefaultPresets();
+      } else {
+        throw err;
+      }
+    }
+  }
+  async _copyDefaultPresets() {
+    const currentPresetDir = import_path2.default.join(this.resolvePresetDir());
+    const defaultPresetDir = import_path2.default.join(__dirname, "../resources/presets");
+    const files = await import_promises2.default.readdir(defaultPresetDir);
+    for (const file of files) {
+      const filePath = import_path2.default.join(defaultPresetDir, file);
+      const fileStat = await import_promises2.default.stat(filePath);
+      if (fileStat.isFile()) {
+        await import_promises2.default.mkdir(currentPresetDir, { recursive: true });
+        this.ctx.chatluna_character.logger.debug(
+          `copy preset file ${filePath} to ${currentPresetDir}`
+        );
+        await import_promises2.default.copyFile(filePath, import_path2.default.join(currentPresetDir, file));
+      }
+    }
+  }
+};
+function loadPreset(text) {
+  const rawPreset = (0, import_js_yaml.load)(text);
+  return {
+    name: rawPreset.name,
+    nick_name: rawPreset.nick_name,
+    input: import_prompts.PromptTemplate.fromTemplate(rawPreset.input),
+    system: import_prompts.PromptTemplate.fromTemplate(rawPreset.system),
+    mute_keyword: rawPreset.mute_keyword ?? []
+  };
+}
+__name(loadPreset, "loadPreset");
+
+// src/service/sticker.ts
+var import_koishi4 = require("koishi");
+var import_path3 = __toESM(require("path"));
+var import_promises3 = __toESM(require("fs/promises"));
+var StickerService = class {
+  constructor(_ctx, _config) {
+    this._ctx = _ctx;
+    this._config = _config;
+  }
+  static {
+    __name(this, "StickerService");
+  }
+  _stickers;
+  async init() {
+    const sickerDir = import_path3.default.resolve(
+      this._ctx.baseDir,
+      "data/chathub/character/sticker"
+    );
+    try {
+      await import_promises3.default.access(sickerDir);
+    } catch (error) {
+      await import_promises3.default.mkdir(sickerDir, { recursive: true });
+      await import_promises3.default.cp(
+        import_path3.default.resolve(__dirname, "../../resources/sticker"),
+        sickerDir,
+        {
+          recursive: true
+        }
+      );
+    }
+    const files = await import_promises3.default.readdir(sickerDir);
+    this._stickers = files.map((file) => import_path3.default.resolve(sickerDir, file));
+  }
+  async randomStick() {
+    const random = Math.random();
+    if (random >= this._config.sendStickerProbability) {
+      return void 0;
+    }
+    const index = Math.floor(Math.random() * this._stickers.length);
+    const sticker = this._stickers[index];
+    if (!sticker) {
+      return void 0;
+    }
+    this._ctx.root.chatluna_character.logger.debug(
+      `send sticker: ${sticker}`
+    );
+    return import_koishi4.h.image(await (0, import_promises3.readFile)(sticker), `image/${getFileType(sticker)}`);
+  }
+};
+function getFileType(path4) {
+  const type = path4.split(".").pop().toLocaleLowerCase();
+  if (type === "jpg") {
+    return "jpeg";
+  }
+  return type;
+}
+__name(getFileType, "getFileType");
+
+// src/service/message.ts
+var MessageCollector = class extends import_koishi5.Service {
+  constructor(ctx, _config) {
+    super(ctx, "chatluna_character");
+    this.ctx = ctx;
+    this._config = _config;
+    this.stickerService = new StickerService(ctx, _config);
+    this.logger = (0, import_logger.createLogger)(ctx, "chatluna-character");
+    this.preset = new Preset(ctx);
+  }
+  static {
+    __name(this, "MessageCollector");
+  }
+  _messages = {};
+  _eventEmitter = new import_events.default();
+  _filters = [];
+  _groupLocks = {};
+  _groupTemp = {};
+  stickerService;
+  preset;
+  addFilter(filter) {
+    this._filters.push(filter);
+  }
+  mute(session, time) {
+    const lock = this._getGroupLocks(session.guildId);
+    let mute = lock.mute ?? 0;
+    if (mute < (/* @__PURE__ */ new Date()).getTime()) {
+      mute = (/* @__PURE__ */ new Date()).getTime() + time;
+    } else {
+      mute = mute + time;
+    }
+    lock.mute = mute;
+  }
+  collect(func) {
+    this._eventEmitter.on("collect", func);
+  }
+  getMessages(groupId) {
+    return this._messages[groupId];
+  }
+  isMute(session) {
+    const lock = this._getGroupLocks(session.guildId);
+    return lock.mute > (/* @__PURE__ */ new Date()).getTime();
+  }
+  async updateTemp(session, temp) {
+    await this._lock(session);
+    const groupId = session.guildId;
+    this._groupTemp[groupId] = temp;
+    await this._unlock(session);
+  }
+  async getTemp(session) {
+    await this._lock(session);
+    const groupId = session.guildId;
+    const temp = this._groupTemp[groupId] ?? {
+      completionMessages: []
+    };
+    this._groupTemp[groupId] = temp;
+    await this._unlock(session);
+    return temp;
+  }
+  _getGroupLocks(groupId) {
+    if (!this._groupLocks[groupId]) {
+      this._groupLocks[groupId] = {
+        lock: false,
+        mute: 0
+      };
+    }
+    return this._groupLocks[groupId];
+  }
+  _lock(session) {
+    const groupLock = this._getGroupLocks(session.guildId);
+    return new Promise((resolve) => {
+      const interval = setInterval(() => {
+        if (!groupLock.lock) {
+          groupLock.lock = true;
+          clearInterval(interval);
+          resolve();
+        }
+      }, 100);
+    });
+  }
+  _unlock(session) {
+    const groupLock = this._getGroupLocks(session.guildId);
+    return new Promise((resolve) => {
+      const interval = setInterval(() => {
+        if (groupLock.lock) {
+          groupLock.lock = false;
+          clearInterval(interval);
+          resolve();
+        }
+      }, 100);
+    });
+  }
+  clear(groupId) {
+    if (groupId) {
+      this._messages[groupId] = [];
+    } else {
+      this._messages = {};
+    }
+    this._groupTemp[groupId] = {
+      completionMessages: []
+    };
+  }
+  async broadcastOnBot(session, elements) {
+    if (session.isDirect) {
+      return;
+    }
+    await this._lock(session);
+    const groupId = session.guildId;
+    const maxMessageSize = this._config.maxMessages;
+    const groupArray = this._messages[groupId] ? this._messages[groupId] : [];
+    const content = mapElementToString(session, session.content, elements);
+    if (content.length < 1) {
+      await this._unlock(session);
+      return;
+    }
+    const message = {
+      content,
+      name: session.bot.user.name,
+      id: session.bot.userId ?? session.bot.selfId ?? "0"
+    };
+    groupArray.push(message);
+    if (groupArray.length > maxMessageSize) {
+      while (groupArray.length > maxMessageSize) {
+        groupArray.shift();
+      }
+    }
+    this._messages[groupId] = groupArray;
+    await this._unlock(session);
+  }
+  async broadcast(session) {
+    if (session.isDirect) {
+      return;
+    }
+    await this._lock(session);
+    const groupId = session.guildId;
+    const maxMessageSize = this._config.maxMessages;
+    const groupArray = this._messages[groupId] ? this._messages[groupId] : [];
+    const elements = session.elements ? session.elements : [import_koishi5.h.text(session.content)];
+    const content = mapElementToString(session, session.content, elements);
+    if (content.length < 1) {
+      await this._unlock(session);
+      return;
+    }
+    const message = {
+      content,
+      name: session.author.name,
+      id: session.author.id,
+      quote: session.quote ? {
+        content: mapElementToString(
+          session,
+          session.quote.content,
+          // TODO: remove as
+          session.quote.elements
+        ),
+        name: session.quote.user.name,
+        id: session.quote.user.id
+      } : void 0
+    };
+    groupArray.push(message);
+    if (groupArray.length > maxMessageSize) {
+      while (groupArray.length > maxMessageSize) {
+        groupArray.shift();
+      }
+    }
+    this._messages[groupId] = groupArray;
+    if (this._filters.some((func) => func(session, message)) && !this.isMute(session)) {
+      this._eventEmitter.emit("collect", session, groupArray);
+      await this._unlock(session);
+      return true;
+    } else {
+      await this._unlock(session);
+      return this.isMute(session);
+    }
+  }
+};
+function mapElementToString(session, content, elements) {
+  const filteredBuffer = [];
+  if (content.trimEnd().length < 1) {
+    return "";
+  }
+  for (const element of elements) {
+    if (element.type === "text") {
+      const content2 = element.attrs.content;
+      if (content2?.trimEnd()?.length > 0) {
+        filteredBuffer.push(content2);
+      }
+    } else if (element.type === "at") {
+      let name2 = element.attrs?.name;
+      if (element.attrs.id === session.bot.selfId) {
+        name2 = name2 ?? session.bot.user.name ?? "0";
+      }
+      if (name2 == null) {
+        name2 = element.attrs.id ?? "0";
+      }
+      filteredBuffer.push(`(${name2}-${element.attrs.id}-<at>)`);
+    }
+  }
+  return filteredBuffer.join("");
+}
+__name(mapElementToString, "mapElementToString");
+
+// src/index.ts
+function apply6(ctx, config) {
+  const disposables = [];
+  ctx.on("ready", async () => {
+    ctx.plugin(MessageCollector, config);
+  });
+  ctx.plugin(
+    {
+      apply: async (ctx2, config2) => {
+        await ctx2.chatluna_character.stickerService.init();
+        await ctx2.chatluna_character.preset.loadAllPreset();
+        await plugins(ctx2, config2);
+      },
+      inject: Object.assign({}, inject, {
+        chatluna_character: {
+          required: true
+        }
+      }),
+      name: "chatluna_character_entry_point"
+    },
+    config
+  );
+  disposables.push(
+    ctx.middleware(async (session, next) => {
+      if (!ctx.chatluna_character) {
+        return next();
+      }
+      if (ctx.bots[session.uid]) {
+        return next();
+      }
+      const guildId = session.guildId;
+      if (!config.applyGroup.includes(guildId)) {
+        return next();
+      }
+      if (!await ctx.chatluna_character.broadcast(session)) {
+        return next();
+      }
+    })
+  );
+  ctx.on("dispose", () => {
+    disposables.forEach((disposable) => disposable());
+  });
+}
+__name(apply6, "apply");
+var inject = {
+  chatluna: {
+    required: true
+  },
+  cache: {
+    required: true
+  },
+  chatluna_character: {
+    required: false
+  },
+  vits: {
+    required: false
+  }
+};
+var Config = import_koishi6.Schema.intersect([
+  import_koishi6.Schema.object({
+    applyGroup: import_koishi6.Schema.array(import_koishi6.Schema.string()).description("应用到的群组"),
+    maxMessages: import_koishi6.Schema.number().description("存储在内存里的最大消息数量").default(10).min(3).role("slider").max(100),
+    disableChatLuna: import_koishi6.Schema.boolean().default(true).description("在使用此插件的群聊里，是否禁用 ChatLuna 主功能"),
+    whiteListDisableChatLuna: import_koishi6.Schema.array(import_koishi6.Schema.string()).description(
+      "在使用此插件时，不禁用 ChatLuna 主功能的群聊列表"
+    )
+  }).description("基础配置"),
+  import_koishi6.Schema.object({
+    model: import_koishi6.Schema.dynamic("model").description("使用的模型"),
+    modelOverride: import_koishi6.Schema.array(
+      import_koishi6.Schema.object({
+        groupId: import_koishi6.Schema.string().required().description("群组 ID"),
+        model: import_koishi6.Schema.dynamic("model").description("模型")
+      })
+    ).description("针对某个群的模型设置，会覆盖上面的配置"),
+    maxTokens: import_koishi6.Schema.number().default(4e3).min(1024).max(16e3).description("使用聊天的最大 token 数")
+  }).description("模型配置"),
+  import_koishi6.Schema.object({
+    isNickname: import_koishi6.Schema.boolean().description("允许 bot 配置中的昵称引发回复").default(true),
+    isForceMute: import_koishi6.Schema.boolean().description(
+      "是否启用强制禁言（当聊天涉及到关键词时则会禁言，关键词需要在预设文件里配置）"
+    ).default(true),
+    isAt: import_koishi6.Schema.boolean().description("是否允许 bot 艾特他人").default(true),
+    splitVoice: import_koishi6.Schema.boolean().description("是否分段发送语言").default(false),
+    messageInterval: import_koishi6.Schema.number().default(14).min(0).role("slider").max(100).description("随机发送消息的间隔"),
+    messageProbability: import_koishi6.Schema.number().default(0.1).min(0).max(4).role("slider").step(1e-5).description("发送消息的叠加概率（线性增长）"),
+    coolDownTime: import_koishi6.Schema.number().default(10).min(1).max(60 * 24).description("冷却发言时间（秒）"),
+    typingTime: import_koishi6.Schema.number().default(440).min(100).role("slider").max(1500).description("模拟打字时的间隔（毫秒）"),
+    muteTime: import_koishi6.Schema.number().default(1e3 * 60).min(1e3).max(1e3 * 60 * 10 * 10).description("闭嘴时的禁言时间（毫秒）"),
+    sendStickerProbability: import_koishi6.Schema.number().default(0.6).min(0).max(1).role("slider").step(0.01).description("发送表情的概率"),
+    defaultPreset: import_koishi6.Schema.dynamic("character-preset").description("使用的伪装预设").default("旧梦旧念")
+  }).description("对话设置"),
+  import_koishi6.Schema.object({
+    configs: import_koishi6.Schema.dict(
+      import_koishi6.Schema.object({
+        maxTokens: import_koishi6.Schema.number().default(4e3).min(1024).max(2e4).description("使用聊天的最大 token 数"),
+        isAt: import_koishi6.Schema.boolean().description("是否启用@").default(true),
+        splitVoice: import_koishi6.Schema.boolean().description("是否分段发送语言").default(false),
+        isNickname: import_koishi6.Schema.boolean().description("允许 bot 配置中的昵称引发回复").default(true),
+        isForceMute: import_koishi6.Schema.boolean().description(
+          "是否启用强制禁言（当聊天涉及到关键词时则会禁言，关键词需要在预设文件里配置）"
+        ).default(true),
+        messageInterval: import_koishi6.Schema.number().default(10).min(0).role("slider").max(50).description("随机发送消息的间隔"),
+        messageProbability: import_koishi6.Schema.number().default(0.1).min(0).max(1).role("slider").step(1e-5).description("发送消息的叠加概率（线性增长）"),
+        coolDownTime: import_koishi6.Schema.number().default(10).min(1).max(60 * 24 * 24).description("冷却发言时间（秒）"),
+        typingTime: import_koishi6.Schema.number().default(440).min(100).role("slider").max(1700).description("模拟打字时的间隔（毫秒）"),
+        muteTime: import_koishi6.Schema.number().default(1e3 * 60).min(1e3).max(1e3 * 60 * 10 * 10).description("闭嘴时的禁言时间（毫秒）"),
+        sendStickerProbability: import_koishi6.Schema.number().default(0.2).min(0).max(1).role("slider").step(0.01).description("发送表情的概率"),
+        preset: import_koishi6.Schema.dynamic("character-preset").description("使用的伪装预设").default("旧梦旧念")
+      })
+    ).role("table").description("分群配置，会覆盖上面的默认配置（键填写群号）")
+  }).description("分群配置")
+]);
+var name = "chatluna-character";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});