koishi-plugin-chatluna 1.0.0-beta.20

package/README.MD

@@ -0,0 +1,130 @@
+
+<div align="center">
+
+# koishi-plugin-chathub
+
+_多平台模型接入，可扩展，多种输出格式，基于 LangChain，提供语言模型聊天服务的 Koishi 插件。_
+
+## [![npm](https://img.shields.io/npm/v/koishi-plugin-chatluna/next)](https://www.npmjs.com/package/koishi-plugin-chatluna) [![npm](https://img.shields.io/npm/dm/koishi-plugin-chatluna)](https://www.npmjs.com/package/koishi-plugin-chatluna) ![node version](https://img.shields.io/badge/node-%3E=18-green) ![github top language](https://img.shields.io/github/languages/top/dingyi222666/koishi-plugin-chathub?logo=github) [![Telegram](https://img.shields.io/badge/Join-Telegram_Group-blue)](https://t.me/koishi_chathub) [![QQ](https://img.shields.io/badge/Join-QQ_Group-ff69b4)](http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=eEBVq6GK7HYX2y61x55WD6hnXTIRop-0&authKey=i4pG5%2BJ%2FY8auWprBubhremTkn3vroPigQq5m9RENGBLrLmlj%2BSu3G%2BqllK7Wts2M&noverify=0&group_code=282381753) [![doc](https://img.shields.io/badge/See-Document(WIP)-green)](https://chathub.dingyi222666.top/)
+
+**当前项目状态：缓慢迭代到 1.0 正式版**
+
+</div>
+
+### 截图
+
+施工中.....
+
+### 特性
+
+- 高扩展性，基于 LangChain 和 Koishi，我们提供了一套扩展 API，让第三方插件开发者可以轻松的扩展或调用此项目的服务。如 调用模型，对接新模型等
+- 预设系统，可设置对话的预设，调教模型。
+- 黑名单系统，全局冷却时间和模型并发请求限制，以及按小时的模型的调用额度限制，轻松管理模型的调用限额等。
+- 支持 语音/文字/图片/图文混合 回复，也支持解析返回的 markdown ，实现比较自然的分割成多条消息来发送
+- 上下文对话，长期记忆的支持 （需要适配器支持）
+- 三种聊天模式: `chat`,`browsing`,`plugin`
+
+    后两种模式可让模型调用外部工具，使得模型能获取到外部信息，执行相关操作等。
+
+- 内容安全过滤，基于 Koishi 的 [censor 服务](`https://censor.koishi.chat/`), 防止模型返回不良内容
+
+### TODO (画饼是吧)
+
+- [x] 基于房间的对话系统
+- [x] 回复内容审核 (基于其他插件提供的 censor 服务)
+- [x] 语音输出支持（即文字转语音）(基于 initialencounter 佬的 [vits服务](https://github.com/initialencounter/mykoishi/blame/master/vits/readme.md)，可在 Koishi 插件市场搜索 `open-vits`来使用可开箱即用的 vits 服务)
+- [x] 图片渲染回复
+- [x] 接入更多模型/平台
+- [x] 预设系统
+- [x] 导入或导出会话记录（实际未完成，已暂时放弃支持）
+- [x] 重构到 v1 版本
+- [x] 流式响应支持
+- [ ] i18n 本地化支持
+
+### 部署
+
+#### 环境要求
+
+```text
+koishi >= 4.15
+nodejs >= 18
+```
+
+由于 Koishi 平台的插件市场的友好和便捷，我们可在 Koishi 下直接安装本插件使用基础功能而无需额外配置。
+
+前往 Koishi 控制台的插件市场，搜索 `chathub`，然后按下面顺序操作：
+
+1. 安装核心服务支持插件：`@dingyi222666/chathub`
+2. 安装模型适配器插件：`@dingyi222666/chathub-xxx-adapter` (xxx 为目前我们支持的模型适配器的名称，见下表)
+3. 按上面的顺序依次安装插件（注意安装后了要先启用插件了然后在下一步），然后在安装好插件所需要的其他插件（也就是插件的必须服务）（例如`@dingyi222666/chathub`插件依赖`cache`服务，你需要安装一个提供了`cache`服务的插件）。
+4. 配置好插件和适配器。（具体配置基本上描述都有写到，如果没有的话可能需要自己摸索了（我暂时还没空写这块的文档））
+5. 先启动主插件，然后在主插件上配置好模板房间使用的模型，预设等，然后保存。
+
+接下来就可以使用本插件了。
+
+### 适配支持
+
+我们目前支持以下模型/平台：
+
+|  模型/平台  |  接入方式  |  特性  |  注意事项  |
+|:----------|:----------|-------|:----------|
+| [OpenAI (GPT-3/GPT3.5)](/packages/openai-adapter/README.md) | 本地 Client，官方 API 接入 | 可自定义人格，支持插件/浏览模式等聊天模式 | API 接入需要付费 |
+| [New Bing](/packages/newbing-adapter/README.md) | 本地 Client，逆向 API 接入 | 自带网络搜索，强时效性，可无需登录使用 | 需要代理（无需 Cookie 也可用） |
+| [Google Bard](/packages/bard-adapter/README.md) | 本地 Client，逆向 API 接入 | 和 New Bing 一样可以网络搜索，强时效性 | 需要有 Bard 访问权限账号，只能英文交流 |
+| [Claude 2](/packages/claude2-adapter/) | 本地 Client，逆向 API 接入 | 超大上下文，大部分情况下能超过 GPT 3.5，类似 New Bing 有账号就行，免费 | 需要有 Claude 2 访问权限账号。后续可能会有限流 |
+| [poe.com](/packages/poe-adapter/README.md) | 本地 Client，逆向 API 接入 | 网站可选多种模型，和 New Bing 一样免费 | 需要有 [poe.com](poe.com) 的账号 |
+| [智谱](/packages/zhipu-adapter/README.md) | 本地 Client，官方 API 接入 | ChatGLM，新人注册可获取免费 Token 额度 | 实测效果比讯飞星火略好，但和 GPT 3.5 仍有差距 |
+| [讯飞星火](/packages/spark-adapter/README.md) | 本地 Client，官方 API 接入 | 国产模型，新人注册可获取免费 Token 额度 | 实测效果约等于 GPT 3.5，有部分场景不如 GPT 3.5 |
+| [GPT Free](/packages/gptfree-adapter/README.md) | 本地 Client，官方 API 接入 | 本地转发使用其他网站的 GPT 模型，项目自动配置网站等配置，无需手动注册 | 可能随时失效，不稳定 |
+| [ChatGLM](/packages/chatglm-adapter/README.md) | 本地 Client，自搭建后端 API 接入 | 可本地搭建，四舍五入不要钱 | 需要自己搭建后端 API，要求一定的配置，6B参数聊天效果不够好 |
+| [RWKV](/packages/rwkv-adapter/README.md) | 本地 Client，自搭建 API 接入 | 知名开源模型，可本地搭建 |  需要自己搭建后端 API，要求一定的配置 |
+
+[为模型提供网络搜索能力](/packages/search-service/README.md) 我们支持：
+
+- Baidu (Web)
+- Bing (Web)
+- DuckDuckGO (Lite & Web)
+- Google (Api)
+- Bing (Api)
+
+### 人格预设
+
+从`1.0.0-alpha.10`版本开始，我们支持更加可定制化的人格预设。新的人格预设使用 yaml。
+
+你可以点这里来查看我们默认附带的人格文件：[catgirl.yml](/packages/core/resources/presets/catgirl.yml)
+
+我们默认的预设文件夹路径为 `你当前运行插件的 koishi 目录的路径+/data/chathub/presets`。
+
+所有的预设文件都是从上面的文件夹上加载的。因此你可以自由添加和编辑预设文件在这个文件夹下，然后使用命令来切换人格预设。
+
+**不是所有的适配器都支持预设，目前 Bard，Copliot Hub 不支持！**
+
+### 手动接入其他模型
+
+等待施工....
+
+### 贡献者名单
+
+<a href="https://github.com/ChatLunaLab/chatluna/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=ChatHubLab/chathub" />
+</a>
+
+![Alt](https://repobeats.axiom.co/api/embed/6996e228e38a44a28ed2629b667ef87a729f12ae.svg "Repobeats analytics image")
+
+### 感谢
+
+本项目在编写时参考了其他开源项目，特别感谢以下项目：
+
+[koishi-plugin-openai](https://github.com/TomLBZ/koishi-plugin-openai)
+
+[node-chatgpt-api](https://github.com/waylaidwanderer/node-chatgpt-api)
+
+[poe-api](https://github.com/ading2210/poe-api)
+
+[Bard](https://github.com/muhiris/wgpt)
+
+[chathub](https://github.com/chathub-dev/chathub)
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=ChatHubLab/chathub&type=Date)](https://star-history.com/#ChatHubLab/chathub)

package/lib/authorization/service.d.ts

@@ -0,0 +1,24 @@
+import { Context, Service, Session } from 'koishi';
+import { Config } from '../config';
+import { ChatHubAuthGroup, ChatHubAuthUser } from './types';
+export declare class ChatLunaAuthService extends Service {
+    readonly ctx: Context;
+    config: Config;
+    constructor(ctx: Context, config: Config);
+    getUser(session: Session, userId?: string): Promise<ChatHubAuthUser>;
+    private _createUser;
+    createAuthGroup(session: Session, group: ChatHubAuthGroup): Promise<void>;
+    resolveAuthGroup(session: Session, platform: string, userId?: string): Promise<ChatHubAuthGroup>;
+    getAuthGroups(platform?: string): Promise<Pick<ChatHubAuthGroup, import("koishi").Keys<ChatHubAuthGroup, any>>[]>;
+    getAuthGroup(name: string): Promise<Pick<ChatHubAuthGroup, import("koishi").Keys<ChatHubAuthGroup, any>>>;
+    calculateBalance(session: Session, platform: string, usedTokenNumber: number, userId?: string): Promise<number>;
+    getBalance(session: Session, userId?: string): Promise<number>;
+    modifyBalance(session: Session, amount: number, userId?: string): Promise<number>;
+    private _getAuthGroup;
+    resetAuthGroup(authGroupId: number): Promise<Pick<ChatHubAuthGroup, import("koishi").Keys<ChatHubAuthGroup, any>>>;
+    increaseAuthGroupCount(authGroupId: number): Promise<void>;
+    addUserToGroup(user: ChatHubAuthUser, groupName: string): Promise<void>;
+    removeUserFormGroup(user: ChatHubAuthUser, groupName: string): Promise<void>;
+    private _initAuthGroup;
+    private _defineDatabase;
+}

package/lib/authorization/service.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatLunaAuthService = void 0;
+const koishi_1 = require("koishi");
+const error_1 = require("../utils/error");
+const decimal_js_1 = require("decimal.js");
+class ChatLunaAuthService extends koishi_1.Service {
+    ctx;
+    config;
+    constructor(ctx, config) {
+        super(ctx, 'chatluna_auth');
+        this.ctx = ctx;
+        this.config = config;
+        ctx.on('ready', async () => {
+            await this._defineDatabase();
+        });
+    }
+    async getUser(session, userId = session.userId) {
+        const list = await this.ctx.database.get('chathub_auth_user', {
+            userId
+        });
+        if (list.length === 0) {
+            return this._createUser(session, userId);
+        }
+        else if (list.length > 1) {
+            throw new error_1.ChatLunaError(error_1.ChatLunaErrorCode.USER_NOT_FOUND);
+        }
+        return list[0];
+    }
+    async _createUser(session, userId = session.userId) {
+        const user = await this.ctx.database.getUser(session.platform, userId);
+        if (user == null) {
+            throw new error_1.ChatLunaError(error_1.ChatLunaErrorCode.USER_NOT_FOUND, new Error(`
+                user not found in platform ${session.platform} and id ${userId}`));
+        }
+        const resolveAuthType = (authType) => authType > 2 ? 'admin' : authType > 1 ? 'user' : 'guest';
+        const copyOfSession = session.bot.session(session.event);
+        copyOfSession.userId = userId;
+        let [rawAuthType, balance, authGroup] = (await copyOfSession.resolve(this.config.authUserDefaultGroup)) ?? [0, 0, 'guest'];
+        const authType = resolveAuthType(user.authority > rawAuthType ? user.authority : rawAuthType);
+        if (authType === 'admin') {
+            authGroup = authType;
+        }
+        const authUser = {
+            userId,
+            balance: balance === 0
+                ? authType === 'admin'
+                    ? 10000
+                    : authType === 'user'
+                        ? 10
+                        : 1
+                : balance,
+            authType
+        };
+        await this.ctx.database.upsert('chathub_auth_user', [authUser]);
+        await this.addUserToGroup(authUser, authGroup);
+        return authUser;
+    }
+    async createAuthGroup(session, group) {
+        const user = await this.getUser(session);
+        await this.ctx.database.upsert('chathub_auth_group', [group]);
+        await this.addUserToGroup(user, group.name);
+    }
+    async resolveAuthGroup(session, platform, userId = session.userId) {
+        // search platform
+        const groups = (await this.ctx.database.get('chathub_auth_group', {
+            platform: {
+                $or: [undefined, platform]
+            }
+        })).sort((a, b) => {
+            // prefer the same platform
+            if (a.platform === platform) {
+                return -1;
+            }
+            if (b.platform === platform) {
+                return 1;
+            }
+            return b.priority - a.priority;
+        });
+        // Here there will be no such thing as a user joining too many groups, so a query will work.
+        const groupIds = groups.map((g) => g.id);
+        const joinedGroups = (await this.ctx.database.get('chathub_auth_joined_user', {
+            groupId: {
+                // max 50??
+                $in: groupIds
+            },
+            userId
+        })).sort((a, b) => groupIds.indexOf(a.groupId) - groupIds.indexOf(b.groupId));
+        if (joinedGroups.length === 0) {
+            throw new error_1.ChatLunaError(error_1.ChatLunaErrorCode.AUTH_GROUP_NOT_JOINED);
+        }
+        const result = groups.find((g) => g.id === joinedGroups[0].groupId);
+        if (result == null) {
+            throw new error_1.ChatLunaError(error_1.ChatLunaErrorCode.AUTH_GROUP_NOT_FOUND, new Error(`Group not found for user ${session.username} and platform
+                ${platform}`));
+        }
+        return result;
+    }
+    async getAuthGroups(platform) {
+        const groups = await this.ctx.database.get('chathub_auth_group', {
+            platform
+        });
+        return groups;
+    }
+    async getAuthGroup(name) {
+        const result = (await this.ctx.database.get('chathub_auth_group', { name }))?.[0];
+        if (result == null) {
+            throw new error_1.ChatLunaError(error_1.ChatLunaErrorCode.AUTH_GROUP_NOT_FOUND);
+        }
+        return result;
+    }
+    async calculateBalance(session, platform, usedTokenNumber, userId = session.userId) {
+        // TODO: use default balance checker
+        // await this.getUser(session)
+        const currentAuthGroup = await this.resolveAuthGroup(session, platform, userId);
+        // 1k token per
+        const usedBalance = new decimal_js_1.Decimal(0.001)
+            .mul(currentAuthGroup.costPerToken)
+            .mul(usedTokenNumber);
+        return await this.modifyBalance(session, -usedBalance.toNumber());
+    }
+    async getBalance(session, userId = session.userId) {
+        return (await this.getUser(session, userId)).balance;
+    }
+    async modifyBalance(session, amount, userId = session.userId) {
+        const user = await this.getUser(session, userId);
+        user.balance = new decimal_js_1.Decimal(user.balance).add(amount).toNumber();
+        await this.ctx.database.upsert('chathub_auth_user', [user]);
+        return user.balance;
+    }
+    async _getAuthGroup(authGroupId) {
+        const authGroup = (await this.ctx.database.get('chathub_auth_group', {
+            id: authGroupId
+        }))?.[0];
+        if (authGroup == null) {
+            throw new error_1.ChatLunaError(error_1.ChatLunaErrorCode.AUTH_GROUP_NOT_FOUND, new Error(`Auth group not found for id ${authGroupId}`));
+        }
+        return authGroup;
+    }
+    async resetAuthGroup(authGroupId) {
+        const authGroup = await this._getAuthGroup(authGroupId);
+        const currentTime = new Date();
+        authGroup.lastCallTime = authGroup.lastCallTime ?? currentTime.getTime();
+        const authGroupDate = new Date(authGroup.lastCallTime);
+        const currentDayOfStart = new Date().setHours(0, 0, 0, 0);
+        // If the last call time is not today, then all zeroed out
+        if (authGroupDate.getTime() < currentDayOfStart) {
+            authGroup.currentLimitPerDay = 0;
+            authGroup.currentLimitPerMin = 0;
+            authGroup.lastCallTime = currentTime.getTime();
+            await this.ctx.database.upsert('chathub_auth_group', [authGroup]);
+            return authGroup;
+        }
+        // Check to see if it's been more than a minute since the last call
+        if (currentTime.getTime() - authGroup.lastCallTime >= 60000) {
+            // clear
+            authGroup.currentLimitPerMin = 0;
+            authGroup.lastCallTime = currentTime.getTime();
+            await this.ctx.database.upsert('chathub_auth_group', [authGroup]);
+            return authGroup;
+        }
+        return authGroup;
+    }
+    async increaseAuthGroupCount(authGroupId) {
+        const authGroup = await this._getAuthGroup(authGroupId);
+        const currentTime = new Date();
+        authGroup.lastCallTime = authGroup.lastCallTime ?? currentTime.getTime();
+        const authGroupDate = new Date(authGroup.lastCallTime);
+        const currentDayOfStart = new Date().setHours(0, 0, 0, 0);
+        // If the last call time is not today, then all zeroed out
+        if (authGroupDate.getTime() < currentDayOfStart) {
+            authGroup.currentLimitPerDay = 1;
+            authGroup.currentLimitPerMin = 1;
+            authGroup.lastCallTime = currentTime.getTime();
+            await this.ctx.database.upsert('chathub_auth_group', [authGroup]);
+            return;
+        }
+        // Check to see if it's been more than a minute since the last call
+        if (currentTime.getTime() - authGroup.lastCallTime >= 60000) {
+            // clear
+            authGroup.currentLimitPerDay += 1;
+            authGroup.currentLimitPerMin = 1;
+            authGroup.lastCallTime = currentTime.getTime();
+            await this.ctx.database.upsert('chathub_auth_group', [authGroup]);
+        }
+        authGroup.currentLimitPerDay += 1;
+        authGroup.currentLimitPerMin += 1;
+        await this.ctx.database.upsert('chathub_auth_group', [authGroup]);
+    }
+    async addUserToGroup(user, groupName) {
+        const group = await this.getAuthGroup(groupName);
+        const isJoined = (await this.ctx.database.get('chathub_auth_joined_user', {
+            groupName,
+            userId: user.userId
+        })).length === 1;
+        if (isJoined) {
+            throw new error_1.ChatLunaError(error_1.ChatLunaErrorCode.AUTH_GROUP_ALREADY_JOINED);
+        }
+        await this.ctx.database.upsert('chathub_auth_joined_user', [
+            {
+                userId: user.userId,
+                groupId: group.id,
+                groupName: group.name
+            }
+        ]);
+    }
+    async removeUserFormGroup(user, groupName) {
+        const group = await this.getAuthGroup(groupName);
+        await this.ctx.database.remove('chathub_auth_joined_user', {
+            userId: user.userId,
+            groupName: group.name
+        });
+    }
+    async _initAuthGroup() {
+        // init guest group
+        const groups = await this.ctx.database.get('chathub_auth_group', {
+            name: {
+                $in: ['guest', 'user', 'admin']
+            }
+        });
+        let currentGroup;
+        if (!groups.some((g) => g.name === 'guest')) {
+            currentGroup = {
+                name: 'guest',
+                priority: 0,
+                limitPerMin: 10,
+                limitPerDay: 2000,
+                // 1000 token / 0.3
+                costPerToken: 0.3
+            };
+            await this.ctx.database.upsert('chathub_auth_group', [currentGroup]);
+        }
+        if (!groups.some((g) => g.name === 'user')) {
+            currentGroup = {
+                name: 'user',
+                priority: 1,
+                limitPerMin: 1000,
+                limitPerDay: 200000,
+                // 1000 token / 0.01
+                costPerToken: 0.01
+            };
+            await this.ctx.database.upsert('chathub_auth_group', [currentGroup]);
+        }
+        if (!groups.some((g) => g.name === 'admin')) {
+            currentGroup = {
+                name: 'admin',
+                priority: 2,
+                limitPerMin: 10000,
+                limitPerDay: 20000000,
+                // 1000 token / 0.001
+                costPerToken: 0.001
+            };
+            await this.ctx.database.upsert('chathub_auth_group', [currentGroup]);
+        }
+    }
+    async _defineDatabase() {
+        const ctx = this.ctx;
+        ctx.database.extend('chathub_auth_user', {
+            userId: {
+                type: 'string'
+            },
+            balance: {
+                type: 'decimal',
+                precision: 20,
+                scale: 10
+            },
+            authType: {
+                type: 'char',
+                length: 50
+            }
+        }, {
+            autoInc: false,
+            primary: 'userId',
+            unique: ['userId']
+        });
+        ctx.database.extend('chathub_auth_joined_user', {
+            userId: 'string',
+            groupId: 'integer',
+            groupName: 'string',
+            id: 'integer'
+        }, {
+            autoInc: true,
+            primary: 'id',
+            unique: ['id']
+        });
+        ctx.database.extend('chathub_auth_group', {
+            limitPerDay: {
+                type: 'integer',
+                nullable: false
+            },
+            limitPerMin: {
+                type: 'integer',
+                nullable: false
+            },
+            lastCallTime: {
+                type: 'integer',
+                length: 16,
+                nullable: true
+            },
+            currentLimitPerDay: {
+                type: 'integer',
+                nullable: true
+            },
+            currentLimitPerMin: {
+                type: 'integer',
+                nullable: true
+            },
+            supportModels: {
+                type: 'json',
+                nullable: true
+            },
+            priority: {
+                type: 'integer',
+                nullable: false,
+                initial: 0
+            },
+            platform: {
+                type: 'char',
+                length: 255,
+                nullable: true
+            },
+            costPerToken: {
+                type: 'decimal',
+                precision: 8,
+                scale: 4
+            },
+            name: {
+                type: 'char',
+                length: 255
+            },
+            id: {
+                type: 'integer'
+            }
+        }, {
+            autoInc: true,
+            primary: 'id',
+            unique: ['id', 'name']
+        });
+        await this._initAuthGroup();
+    }
+}
+exports.ChatLunaAuthService = ChatLunaAuthService;

package/lib/authorization/types.d.ts

@@ -0,0 +1,36 @@
+import { ChatLunaAuthService } from './service';
+export interface ChatHubAuthUser {
+    userId: string;
+    balance: number;
+    authType: AuthType;
+}
+export interface ChatHubAuthJoinedUser {
+    userId: string;
+    groupId: number;
+    groupName: string;
+    id: number;
+}
+export type AuthType = 'guest' | 'user' | 'admin';
+export interface ChatHubAuthGroup {
+    name: string;
+    platform?: string;
+    priority: number;
+    id: number;
+    limitPerMin: number;
+    limitPerDay: number;
+    costPerToken: number;
+    currentLimitPerMin?: number;
+    currentLimitPerDay?: number;
+    lastCallTime?: number;
+    supportModels: string[];
+}
+declare module 'koishi' {
+    interface Context {
+        chatluna_auth: ChatLunaAuthService;
+    }
+    interface Tables {
+        chathub_auth_group: ChatHubAuthGroup;
+        chathub_auth_user: ChatHubAuthUser;
+        chathub_auth_joined_user: ChatHubAuthJoinedUser;
+    }
+}

package/lib/authorization/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cache.d.ts

@@ -0,0 +1,18 @@
+import { Tables } from '@koishijs/cache';
+import { Context } from 'koishi';
+import { Config } from './config';
+export declare class Cache<K extends keyof Tables, T extends Tables[K]> {
+    private ctx;
+    readonly config: Config;
+    readonly tableName: K;
+    constructor(ctx: Context, config: Config, tableName: K);
+    get(id: string): Promise<T>;
+    set(id: string, value: T): Promise<void>;
+    delete(id: string): Promise<void>;
+    clear(): Promise<void>;
+}
+declare module '@koishijs/cache' {
+    interface Tables {
+        'chathub/keys': string;
+    }
+}

package/lib/cache.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+class Cache {
+    ctx;
+    config;
+    tableName;
+    constructor(ctx, config, tableName) {
+        this.ctx = ctx;
+        this.config = config;
+        this.tableName = tableName;
+    }
+    get(id) {
+        return this.ctx.cache.get(this.tableName, id);
+    }
+    set(id, value) {
+        // 单位分钟
+        return this.ctx.cache.set(this.tableName, id, value);
+    }
+    async delete(id) {
+        await this.ctx.cache.delete(this.tableName, id);
+    }
+    async clear() {
+        await this.ctx.cache.clear(this.tableName);
+    }
+}
+exports.Cache = Cache;

package/lib/chains/chain.d.ts

@@ -0,0 +1,66 @@
+import { Context, h, Session } from 'koishi';
+import { Config } from '../config';
+import '../middlewares/lifecycle';
+/**
+ * ChatChain为消息的发送和接收提供了一个统一的中间提供交互
+ */
+export declare class ChatChain {
+    private readonly ctx;
+    private readonly config;
+    readonly _graph: ChatChainDependencyGraph;
+    private readonly _senders;
+    constructor(ctx: Context, config: Config);
+    receiveMessage(session: Session, ctx?: Context): Promise<boolean>;
+    receiveCommand(session: Session, command: string, options?: ChainMiddlewareContextOptions): Promise<boolean>;
+    middleware<T extends keyof ChainMiddlewareName>(name: T, middleware: ChainMiddlewareFunction, ctx?: Context): ChainMiddleware;
+    sender(sender: ChatChainSender): void;
+    private _runMiddleware;
+    private sendMessage;
+}
+declare class ChatChainDependencyGraph {
+    private _tasks;
+    private _dependencies;
+    private _eventEmitter;
+    private _listeners;
+    constructor();
+    addNode(middleware: ChainMiddleware): void;
+    removeNode(name: string): void;
+    once(name: string, listener: (...args: any[]) => void): void;
+    before(taskA: ChainMiddleware | string, taskB: ChainMiddleware | string): void;
+    after(taskA: ChainMiddleware | string, taskB: ChainMiddleware | string): void;
+    getDependencies(task: string): Set<string>;
+    getDependents(task: string): string[];
+    build(): ChainMiddleware[];
+}
+export declare class ChainMiddleware {
+    readonly name: string;
+    private readonly execute;
+    private readonly graph;
+    constructor(name: string, execute: ChainMiddlewareFunction, graph: ChatChainDependencyGraph);
+    before<T extends keyof ChainMiddlewareName>(name: T): this;
+    after<T extends keyof ChainMiddlewareName>(name: T): this;
+    run(session: Session, options: ChainMiddlewareContext): Promise<string | h[] | h[][] | ChainMiddlewareRunStatus>;
+}
+export interface ChainMiddlewareContext {
+    config: Config;
+    ctx: Context;
+    session: Session;
+    message: string | h[] | h[][];
+    options?: ChainMiddlewareContextOptions;
+    command?: string;
+    recallThinkingMessage?: () => Promise<void>;
+    send: (message: h[][] | h[] | h | string) => Promise<void>;
+}
+export interface ChainMiddlewareContextOptions {
+    [key: string]: any;
+}
+export interface ChainMiddlewareName {
+}
+export type ChainMiddlewareFunction = (session: Session, context: ChainMiddlewareContext) => Promise<string | h[] | h[][] | ChainMiddlewareRunStatus | null>;
+export type ChatChainSender = (session: Session, message: (h[] | h | string)[]) => Promise<void>;
+export declare enum ChainMiddlewareRunStatus {
+    SKIPPED = 0,
+    STOP = 1,
+    CONTINUE = 2
+}
+export {};