koishi-plugin-chatluna-character 0.0.47 → 0.0.48

package/lib/index.cjs

@@ -5,15 +5,6 @@ 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 });
@@ -36,11 +27,22 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/plugins/chat.ts
-var chat_exports = {};
-__export(chat_exports, {
-  apply: () => apply
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply6,
+  inject: () => inject,
+  inject2: () => inject2,
+  name: () => name
 });
+module.exports = __toCommonJS(src_exports);
+var import_koishi6 = require("koishi");
+
+// src/plugins/chat.ts
+var import_messages = require("@langchain/core/messages");
+var import_koishi = require("koishi");
+var import_count_tokens = require("koishi-plugin-chatluna/llm-core/utils/count_tokens");
 async function apply(ctx, config) {
   const service = ctx.chatluna_character;
   const preset = service.preset;
@@ -108,7 +110,8 @@ async function apply(ctx, config) {
       await currentPreset.input.format({
         history_new: recentMessage,
         history_last: lastMessage,
-        time: (/* @__PURE__ */ new Date()).toLocaleString()
+        time: (/* @__PURE__ */ new Date()).toLocaleString(),
+        status: temp.status ?? currentPreset.status ?? ""
       })
     );
     const completionMessages = await formatCompletionMessages(
@@ -150,11 +153,10 @@ async function apply(ctx, config) {
       return;
     }
     temp.completionMessages.push(humanMessage, responseMessage);
-    if (temp.completionMessages.length > 8) {
-      while (temp.completionMessages.length <= 4) {
-        temp.completionMessages.shift();
-      }
+    if (temp.completionMessages.length > 2) {
+      temp.completionMessages.length = 0;
     }
+    temp.status = parsedResponse.status;
     const random = new import_koishi.Random();
     for (const elements of parsedResponse.elements) {
       const text = elements.map((element) => element.attrs.content ?? "").join("");
@@ -165,9 +167,14 @@ async function apply(ctx, config) {
       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 })
-        );
+        try {
+          await session.send(
+            await ctx.vits.say({ input: parsedResponse.rawMessage })
+          );
+        } catch (e) {
+          logger.error(e);
+          await session.send(elements);
+        }
         break;
       }
       try {
@@ -201,16 +208,20 @@ async function apply(ctx, config) {
     await service.broadcastOnBot(session, parsedResponse.elements.flat());
   });
 }
+__name(apply, "apply");
 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);
 }
+__name(isEmoticonStatement, "isEmoticonStatement");
 function parseResponse(response, useAt = true) {
   let rawMessage;
   let parsedMessage = "";
   let messageType = "text";
+  let status = "";
   try {
     rawMessage = response.match(/<message>\s*(.*?)\s*<\/message>/)?.[1];
+    status = response.match(/<status>(.*?)<\/status>/)?.[1];
     if (rawMessage == null) {
       logger.debug("failed to parse response: " + response);
       rawMessage = response.substring(
@@ -273,9 +284,11 @@ function parseResponse(response, useAt = true) {
   return {
     elements: resultElements,
     rawMessage: parsedMessage,
+    status,
     messageType
   };
 }
+__name(parseResponse, "parseResponse");
 function splitSentence(text) {
   const result = [];
   const lines = text.split("\n").filter((line) => line.trim().length > 0).join(" ");
@@ -352,6 +365,7 @@ function splitSentence(text) {
   }
   return result.filter((item) => punctuations.indexOf(item) === -1);
 }
+__name(splitSentence, "splitSentence");
 function matchAt(str) {
   const atRegex = /([(（]).*-(\d+)-<at>([)）])/g;
   return [...str.matchAll(atRegex)].map((item) => {
@@ -362,6 +376,7 @@ function matchAt(str) {
     };
   });
 }
+__name(matchAt, "matchAt");
 async function formatCompletionMessages(messages, humanMessage, config, model) {
   const maxTokens = config.maxTokens - 600;
   const systemMessage = messages.shift();
@@ -385,6 +400,7 @@ async function formatCompletionMessages(messages, humanMessage, config, model) {
   result.unshift(systemMessage);
   return result;
 }
+__name(formatCompletionMessages, "formatCompletionMessages");
 async function formatMessage(messages, config, model, systemPrompt, historyPrompt) {
   const maxTokens = config.maxTokens - 300;
   let currentTokens = 0;
@@ -413,28 +429,11 @@ async function formatMessage(messages, config, model, systemPrompt, historyPromp
   }
   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");
-  }
-});
+__name(formatMessage, "formatMessage");
+var logger;
 
 // src/plugins/filter.ts
-var filter_exports = {};
-__export(filter_exports, {
-  apply: () => apply2,
-  groupInfos: () => groupInfos
-});
+var groupInfos = {};
 async function apply2(ctx, config) {
   const maxMessages = config.messageInterval;
   const service = ctx.chatluna_character;
@@ -517,19 +516,9 @@ async function apply2(ctx, config) {
     return false;
   });
 }
-var groupInfos;
-var init_filter = __esm({
-  "src/plugins/filter.ts"() {
-    groupInfos = {};
-    __name(apply2, "apply");
-  }
-});
+__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(
@@ -553,18 +542,11 @@ function apply3(ctx, config) {
     return `已清除群组 ${groupId} 的聊天记录`;
   });
 }
-var init_commands = __esm({
-  "src/plugins/commands.ts"() {
-    init_filter();
-    __name(apply3, "apply");
-  }
-});
+__name(apply3, "apply");
 
 // src/plugins/config.ts
-var config_exports = {};
-__export(config_exports, {
-  apply: () => apply4
-});
+var import_koishi2 = require("koishi");
+var import_types = require("koishi-plugin-chatluna/llm-core/platform/types");
 async function apply4(ctx, config) {
   ctx.on("chatluna/model-added", async (service) => {
     ctx.schema.set("model", import_koishi2.Schema.union(await getModelNames(service)));
@@ -577,24 +559,13 @@ async function apply4(ctx, config) {
     import_koishi2.Schema.union(await getModelNames(ctx.chatluna.platform))
   );
 }
+__name(apply4, "apply");
 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");
-  }
-});
+__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;
@@ -622,63 +593,34 @@ function apply5(ctx, config) {
     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))
-});
+__name(apply5, "apply");
 
 // 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);
-    }
+async function plugins(ctx, parent) {
+  const middlewares = (
+    // middleware start
+    [apply, apply3, apply4, apply2, apply5]
+  );
+  for (const middleware of middlewares) {
+    await middleware(ctx, parent);
   }
 }
 __name(plugins, "plugins");
 
 // src/service/message.ts
-var import_events = __toESM(require("events"));
+var import_events = __toESM(require("events"), 1);
 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_promises = __toESM(require("fs/promises"), 1);
 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 import_path = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_meta = {};
 var Preset = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -690,19 +632,19 @@ var Preset = class {
   async loadAllPreset() {
     await this._checkPresetDir();
     const presetDir = this.resolvePresetDir();
-    const files = await import_promises2.default.readdir(presetDir);
+    const files = await import_promises.default.readdir(presetDir);
     this._presets.length = 0;
     for (const file of files) {
-      const extension = import_path2.default.extname(file);
+      const extension = import_path.default.extname(file);
       if (extension !== ".yml") {
         continue;
       }
-      const rawText = await import_promises2.default.readFile(
-        import_path2.default.join(presetDir, file),
+      const rawText = await import_promises.default.readFile(
+        import_path.default.join(presetDir, file),
         "utf-8"
       );
       const preset = loadPreset(rawText);
-      preset.path = import_path2.default.join(presetDir, file);
+      preset.path = import_path.default.join(presetDir, file);
       this._presets.push(preset);
     }
     this.ctx.schema.set(
@@ -753,15 +695,15 @@ var Preset = class {
     await this._copyDefaultPresets();
   }
   resolvePresetDir() {
-    return import_path2.default.resolve(this.ctx.baseDir, "data/chathub/character/presets");
+    return import_path.default.resolve(this.ctx.baseDir, "data/chathub/character/presets");
   }
   async _checkPresetDir() {
-    const presetDir = import_path2.default.join(this.resolvePresetDir());
+    const presetDir = import_path.default.join(this.resolvePresetDir());
     try {
-      await import_promises2.default.access(presetDir);
+      await import_promises.default.access(presetDir);
     } catch (err) {
       if (err.code === "ENOENT") {
-        await import_promises2.default.mkdir(presetDir, { recursive: true });
+        await import_promises.default.mkdir(presetDir, { recursive: true });
         await this._copyDefaultPresets();
       } else {
         throw err;
@@ -769,18 +711,19 @@ var Preset = class {
     }
   }
   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);
+    const currentPresetDir = import_path.default.join(this.resolvePresetDir());
+    const dirname = __dirname?.length > 0 ? __dirname : (0, import_url.fileURLToPath)(import_meta.url);
+    const defaultPresetDir = import_path.default.join(dirname, "../resources/presets");
+    const files = await import_promises.default.readdir(defaultPresetDir);
     for (const file of files) {
-      const filePath = import_path2.default.join(defaultPresetDir, file);
-      const fileStat = await import_promises2.default.stat(filePath);
+      const filePath = import_path.default.join(defaultPresetDir, file);
+      const fileStat = await import_promises.default.stat(filePath);
       if (fileStat.isFile()) {
-        await import_promises2.default.mkdir(currentPresetDir, { recursive: true });
+        await import_promises.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));
+        await import_promises.default.copyFile(filePath, import_path.default.join(currentPresetDir, file));
       }
     }
   }
@@ -799,8 +742,10 @@ __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 import_path2 = __toESM(require("path"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_url2 = require("url");
+var import_meta2 = {};
 var StickerService = class {
   constructor(_ctx, _config) {
     this._ctx = _ctx;
@@ -811,24 +756,25 @@ var StickerService = class {
   }
   _stickers;
   async init() {
-    const sickerDir = import_path3.default.resolve(
+    const sickerDir = import_path2.default.resolve(
       this._ctx.baseDir,
       "data/chathub/character/sticker"
     );
     try {
-      await import_promises3.default.access(sickerDir);
+      await import_promises2.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"),
+      await import_promises2.default.mkdir(sickerDir, { recursive: true });
+      const dirname = __dirname?.length > 0 ? __dirname : (0, import_url2.fileURLToPath)(import_meta2.url);
+      await import_promises2.default.cp(
+        import_path2.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));
+    const files = await import_promises2.default.readdir(sickerDir);
+    this._stickers = files.map((file) => import_path2.default.resolve(sickerDir, file));
   }
   async randomStick() {
     const random = Math.random();
@@ -843,11 +789,11 @@ var StickerService = class {
     this._ctx.root.chatluna_character.logger.debug(
       `send sticker: ${sticker}`
     );
-    return import_koishi4.h.image(await (0, import_promises3.readFile)(sticker), `image/${getFileType(sticker)}`);
+    return import_koishi4.h.image(await (0, import_promises2.readFile)(sticker), `image/${getFileType(sticker)}`);
   }
 };
-function getFileType(path4) {
-  const type = path4.split(".").pop().toLocaleLowerCase();
+function getFileType(path3) {
+  const type = path3.split(".").pop().toLocaleLowerCase();
   if (type === "jpg") {
     return "jpeg";
   }
@@ -1000,7 +946,7 @@ var MessageCollector = class extends import_koishi5.Service {
     }
     const message = {
       content,
-      name: session.author.name,
+      name: session.author.nick ?? session.author.name,
       id: session.author.id,
       quote: session.quote ? {
         content: mapElementToString(
@@ -1069,7 +1015,7 @@ function apply6(ctx, config) {
         await ctx2.chatluna_character.preset.loadAllPreset();
         await plugins(ctx2, config2);
       },
-      inject: Object.assign({}, inject, {
+      inject: Object.assign({}, inject2, {
         chatluna_character: {
           required: true
         }
@@ -1101,6 +1047,10 @@ function apply6(ctx, config) {
 }
 __name(apply6, "apply");
 var inject = {
+  required: ["chatluna", "cache"],
+  optional: ["chatluna_character", "vits"]
+};
+var inject2 = {
   chatluna: {
     required: true
   },
@@ -1175,5 +1125,6 @@ var name = "chatluna-character";
   Config,
   apply,
   inject,
+  inject2,
   name
 });

package/lib/index.d.ts

@@ -1,44 +1,148 @@
-import { Context, Schema } from 'koishi';
-import { ChatLunaPlugin } from 'koishi-plugin-chatluna/services/chat';
-import { GuildConfig } from './types';
-export declare function apply(ctx: Context, config: Config): void;
-export declare const inject: {
-    chatluna: {
-        required: boolean;
-    };
-    cache: {
-        required: boolean;
-    };
-    chatluna_character: {
-        required: boolean;
-    };
-    vits: {
-        required: boolean;
-    };
-};
-export interface Config extends ChatLunaPlugin.Config {
-    model: string;
-    maxMessages: number;
-    messageInterval: number;
-    messageProbability: number;
-    maxTokens: number;
-    applyGroup: string[];
-    modelOverride: {
-        groupId: string;
-        model: string;
-    }[];
-    configs: Record<string, GuildConfig>;
-    defaultPreset: string;
-    isNickname: boolean;
-    isForceMute: boolean;
-    sendStickerProbability: number;
-    coolDownTime: number;
-    typingTime: number;
-    muteTime: number;
-    disableChatLuna: boolean;
-    whiteListDisableChatLuna: string[];
-    splitVoice: boolean;
-    isAt: boolean;
-}
-export declare const Config: Schema<Config>;
-export declare const name = "chatluna-character";
+import { BaseMessage } from '@langchain/core/messages';
+import { PromptTemplate } from '@langchain/core/prompts';
+import { Context, h, Logger, Service, Session, Schema } from 'koishi';
+import { ChatLunaPlugin } from 'koishi-plugin-chatluna/services/chat';
+export interface Message {
+    content: string;
+    name: string;
+    id: string;
+    quote?: Message;
+}
+export interface GroupTemp {
+    completionMessages: BaseMessage[];
+    status?: string;
+}
+export interface GuildConfig {
+    preset: string;
+    messageInterval: number;
+    maxTokens: number;
+    isNickname: boolean;
+    isForceMute: boolean;
+    sendStickerProbability: number;
+    coolDownTime: number;
+    splitVoice: boolean;
+    isAt: boolean;
+    typingTime: number;
+    messageProbability: number;
+    muteTime: number;
+}
+export interface PresetTemplate {
+    name: string;
+    status?: string;
+    nick_name: string[];
+    input: PromptTemplate;
+    system: PromptTemplate;
+    mute_keyword?: string[];
+    path?: string;
+}
+export interface GroupInfo {
+    messageCount: number;
+    messageSendProbability: number;
+}
+export function apply(ctx: Context, config: Config): Promise<void>;
+export const groupInfos: Record<string, GroupInfo>;
+export function apply(ctx: Context, config: Config): Promise<void>;
+export function apply(ctx: Context, config: Config): void;
+export function apply(ctx: Context, config: Config): Promise<void>;
+export function apply(ctx: Context, config: Config): void;
+export function plugins(ctx: Context, parent: Config): Promise<void>;
+export class Preset {
+    private readonly ctx;
+    private readonly _presets;
+    constructor(ctx: Context);
+    loadAllPreset(): Promise<void>;
+    getPreset(triggerKeyword: string, loadForDisk?: boolean, throwError?: boolean): Promise<PresetTemplate>;
+    getPresetForCache(triggerKeyword: string, throwError?: boolean): PresetTemplate;
+    getDefaultPreset(): Promise<PresetTemplate>;
+    getAllPreset(): Promise<string[]>;
+    resetDefaultPreset(): Promise<void>;
+    resolvePresetDir(): string;
+    private _checkPresetDir;
+    private _copyDefaultPresets;
+}
+export function loadPreset(text: string): PresetTemplate;
+export class StickerService {
+    private _ctx;
+    private _config;
+    private _stickers;
+    constructor(_ctx: Context, _config: Config);
+    init(): Promise<void>;
+    randomStick(): Promise<h>;
+}
+export class MessageCollector extends Service {
+    readonly ctx: Context;
+    _config: Config;
+    private _messages;
+    private _eventEmitter;
+    private _filters;
+    private _groupLocks;
+    private _groupTemp;
+    stickerService: StickerService;
+    preset: Preset;
+    logger: Logger;
+    constructor(ctx: Context, _config: Config);
+    addFilter(filter: MessageCollectorFilter): void;
+    mute(session: Session, time: number): void;
+    collect(func: (session: Session, messages: Message[]) => Promise<void>): void;
+    getMessages(groupId: string): Message[];
+    isMute(session: Session): boolean;
+    updateTemp(session: Session, temp: GroupTemp): Promise<void>;
+    getTemp(session: Session): Promise<GroupTemp>;
+    private _getGroupLocks;
+    private _lock;
+    private _unlock;
+    clear(groupId?: string): void;
+    broadcastOnBot(session: Session, elements: h[]): Promise<void>;
+    broadcast(session: Session): Promise<boolean>;
+}
+type MessageCollectorFilter = (session: Session, message: Message) => boolean;
+declare module 'koishi' {
+    interface Context {
+        chatluna_character: MessageCollector;
+    }
+}
+export function apply(ctx: Context, config: Config): void;
+export const inject: {
+    required: string[];
+    optional: string[];
+};
+export const inject2: {
+    chatluna: {
+        required: boolean;
+    };
+    cache: {
+        required: boolean;
+    };
+    chatluna_character: {
+        required: boolean;
+    };
+    vits: {
+        required: boolean;
+    };
+};
+export interface Config extends ChatLunaPlugin.Config {
+    model: string;
+    maxMessages: number;
+    messageInterval: number;
+    messageProbability: number;
+    maxTokens: number;
+    applyGroup: string[];
+    modelOverride: {
+        groupId: string;
+        model: string;
+    }[];
+    configs: Record<string, GuildConfig>;
+    defaultPreset: string;
+    isNickname: boolean;
+    isForceMute: boolean;
+    sendStickerProbability: number;
+    coolDownTime: number;
+    typingTime: number;
+    muteTime: number;
+    disableChatLuna: boolean;
+    whiteListDisableChatLuna: string[];
+    splitVoice: boolean;
+    isAt: boolean;
+}
+export const Config: Schema<Config>;
+export const name = "chatluna-character";