重命名文档

✨更新浏览器UA，水

.gitignore

@@ -187,4 +187,7 @@ docs/.vitepress/cache
 docs/.vitepress/dist
 
 # viztracer
-result.json
+result.json
+
+data/*
+marshoplugins/*

README.md

@@ -23,10 +23,11 @@ _✨ 使用 OpenAI 标准格式 API 的聊天机器人插件 ✨_
 
 ## 📖 介绍
 
-通过调用 OpenAI 标准格式 API(例如由 Azure OpenAI 驱动，GitHub Models 提供访问的生成式 AI 推理 API) 来实现聊天的插件。  
+通过调用 OpenAI 标准格式 API(例如 GitHub Models API) 来实现聊天的插件。  
 插件内置了猫娘小棉(Marsho)的人物设定，可以进行可爱的聊天！  
 *谁不喜欢回复消息快又可爱的猫娘呢？*  
 **对 OneBot 以外的适配器与非 GitHub Models API的支持未经过完全验证。**  
+**MarshoAI v1.0.0 预计在春节前后发布。（重写好累啊QwQ）**  
 [Melobot 实现](https://github.com/LiteyukiStudio/marshoai-melo)  
 
 ## 🐱 设定
@@ -57,6 +58,14 @@ _✨ 使用 OpenAI 标准格式 API 的聊天机器人插件 ✨_
 "nonebot-plugin-marshoai" 基于 [MIT](./LICENSE-MIT) 许可下提供。  
 部分指定的代码基于 [Mulan PSL v2](./LICENSE-MULAN) 许可下提供。  
 
+<div>
+  <a href="https://github.com/LiteyukiStudio/nonebot-plugin-marshoai/graphs/contributors">
+    <img src="https://contrib.rocks/image?repo=LiteyukiStudio/nonebot-plugin-marshoai" alt="Contributors">
+  </a>
+</div>
+
+感谢所有的贡献者！
+
 ## 开发
 
 - 请阅读[开发规范](./README_DEV.md)

README_EN.md

@@ -57,4 +57,12 @@ This project uses the following code from other projects:
 "Marsho" logo contributed by [@Asankilp](https://github.com/Asankilp),licensed under [CC BY-NC-SA 4.0](http://creativecommons.org/licenses/by-nc-sa/4.0/) lisense.  
 
 "nonebot-plugin-marshoai" is licensed under [MIT](./LICENSE-MIT) license.  
-Some of the code is licensed under [Mulan PSL v2](./LICENSE-MULAN) license.  
+Some of the code is licensed under [Mulan PSL v2](./LICENSE-MULAN) license.
+
+<div>
+  <a href="https://github.com/LiteyukiStudio/nonebot-plugin-marshoai/graphs/contributors">
+    <img src="https://contrib.rocks/image?repo=LiteyukiStudio/nonebot-plugin-marshoai" alt="Contributors">
+  </a>
+</div>
+
+Thanks to all the contributors!

docs/.vitepress/config/zh.ts

@@ -12,7 +12,7 @@ export const zh = defineConfig({
         },
         nav: [
             {text: '家', link: '/'},
-            {text: '使用', link: '/start/install'},
+            {text: '使用', link: '/start/use'},
             {text: '开发', link: '/dev/extension'},
         ],
         editLink: ThemeConfig.getEditLink('编辑此页面'),

docs/components/ContributorsBar.vue

@@ -0,0 +1,23 @@
+<script setup lang="ts">
+
+const contributorImgSrc = `https://contrib.rocks/image?repo=LiteyukiStudio/nonebot-plugin-marshoai`
+const contributorsUrl = `https://github.com/LiteyukiStudio/nonebot-plugin-marshoai/graphs/contributors`
+</script>
+
+<template>
+  <div class="contributor-bar">
+    <a :href="contributorsUrl">
+      <div class="contributor-list">
+        <img :src=contributorImgSrc alt="Contributors">
+      </div>
+    </a>
+  </div>
+</template>
+
+<style scoped>
+.contributor-bar {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+</style>

docs/en/start/install.md

@@ -49,7 +49,9 @@ Open the `pyproject.toml` file under nonebot2's root directory, Add to`[tool.non
 
 - Create new [personal access token](https://github.com/settings/tokens/new)，**Don't need any permissions**.
 - Copy the new token, add to the `.env` file's `marshoai_token` option.
-
+:::warning
+GitHub Models API comes with significant limitations and is therefore not recommended for use. For better alternatives, it's suggested to adjust the configuration `MARSHOAI_AZURE_ENDPOINT` to use other service providers' models instead.
+:::
 ## 🎉 Usage
 
 End `marsho` in order to get direction for use(If you configured the custom command, please use the configured one).
@@ -105,7 +107,7 @@ Add options in the `.env` file from the diagram below in nonebot2 project.
 | Option                | Type       | Default     | Description          |
 | --------------------- | ---------- | ----------- | ----------------- |
 | MARSHOAI_DEFAULT_NAME | `str`      | `marsho`    | Command to call Marsho |
-| MARSHOAI_ALIASES      | `set[str]` | `set{"Marsho"}` | Other name(Alias) to call Marsho |
+| MARSHOAI_ALIASES      | `set[str]` | `list["小棉"]` | Other name(Alias) to call Marsho |
 | MARSHOAI_AT           | `bool`     | `false`     | Call by @ or not |
 | MARSHOAI_MAIN_COLOUR   |  `str`    | `FFAAAA`    | Theme color, used by some tools and features    |
 
@@ -117,12 +119,15 @@ Add options in the `.env` file from the diagram below in nonebot2 project.
 | MARSHOAI_DEFAULT_MODEL           | `str`   | `gpt-4o-mini`                           | The default model of Marsho                                                                        |
 | MARSHOAI_PROMPT                  | `str`   | Catgirl Marsho's character prompt                    | Marsho's basic system prompt **※Some models(o1 and so on) don't support it**                                                       |
 | MARSHOAI_ADDITIONAL_PROMPT       | `str`   |                                         | Marsho's external system prompt                                                                              |
+| MARSHOAI_ENFORCE_NICKNAME        | `bool`  | `true`                                  | Enforce user to set nickname or not                                                               |
 | MARSHOAI_POKE_SUFFIX             | `str`   | `揉了揉你的猫耳`                               | When double click Marsho who connected to OneBot adapter, the chat content. When it's empty string, double click function is off. Such as, the default content is `*[昵称]揉了揉你的猫耳。` |
 | MARSHOAI_AZURE_ENDPOINT          | `str`   | `https://models.inference.ai.azure.com` | OpenAI standard API                                                                            |
 | MARSHOAI_TEMPERATURE             | `float` | `null`                                  | temperature parameter                                                                         |
 | MARSHOAI_TOP_P                   | `float` | `null`                                  | Nucleus Sampling parameter                                                                       |
 | MARSHOAI_MAX_TOKENS              | `int`   | `null`                                  | Max token number                                                                                |
 | MARSHOAI_ADDITIONAL_IMAGE_MODELS | `list`  | `[]`                                    | External image-support model list, such as `hunyuan-vision`                                                 |
+| MARSHOAI_NICKNAME_LIMIT          | `int`   | `16`                                    | Limit for nickname length |
+| MARSHOAI_FIX_TOOLCALLS           | `bool`  | `true`                                  | Fix tool calls or not |
 
 #### Feature Switches
 
@@ -131,6 +136,7 @@ Add options in the `.env` file from the diagram below in nonebot2 project.
 | MARSHOAI_ENABLE_SUPPORT_IMAGE_TIP | `bool` | `true` | When on, if user send request with photo and model don't support that, remind the user |
 | MARSHOAI_ENABLE_NICKNAME_TIP      | `bool` | `true` | When on, if user haven't set username, remind user to set       |
 | MARSHOAI_ENABLE_PRAISES           | `bool` | `true` | Turn on Praise list or not           |
+| MARSHOAI_ENABLE_TIME_PROMPT        | `bool` | `true` | Turn on real-time date and time (accurate to seconds) and lunar date system prompt  |
 | MARSHOAI_ENABLE_TOOLS             | `bool` | `false` | Turn on Marsho Tools or not           |
 | MARSHOAI_ENABLE_PLUGINS             | `bool` | `true` | Turn on Marsho Plugins or not           
 | MARSHOAI_PLUGIN_DIRS             | `list[str]` | `[]` |  List of plugins directory        |

docs/zh/dev/extension.md

@@ -9,7 +9,9 @@ order: 2
 扩展分为两类，一类为插件，一类为工具。
 
 - 插件
-- 工具(由于开发的不便利性，已经停止维护，未来可能会放弃支持，如有需求请看README中的内容，我们不推荐再使用此功能)
+- 工具(由于开发的不便利性，已经停止维护，未来可能会放弃支持，如有需求请看README中的内容，我们不推荐再使用此功能)  
+
+**`v1.0.0`之前的版本不支持小棉插件。**
 
 ## 插件
 
@@ -57,7 +59,11 @@ async def weather(location: str) -> str:
 
 ## 函数调用参数
 
-`on_function_call`装饰器用于标记一个函数为function call，`description`参数用于描述这个函数的作用，`params`方法用于定义函数的参数，`String`、`Integer`等是OpenAI API接受的参数的类型，`description`是参数的描述。这些都是给AI看的，AI会根据这些信息来调用函数。
+`on_function_call`装饰器用于标记一个函数为function call，`description`参数用于描述这个函数的作用，`params`方法用于定义函数的参数，`String`、`Integer`等是OpenAI API接受的参数的类型，`description`是参数的描述。这些都是给AI看的，AI会根据这些信息来调用函数。  
+
+:::warning
+参数名不得为`placeholder`。此参数名是Marsho内部保留的用于保证兼容性的占位参数。
+:::
 
 ```python
 @on_function_call(description="可以用于算命").params(

docs/zh/dev/project.md

@@ -39,3 +39,11 @@ pre-commit install  # 安装 pre-commit 钩子
 - [`Google Docstring`](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html) 文档规范
 
 可以在编辑器中安装相应的插件进行辅助
+
+## 其他
+
+感谢以下的贡献者们：
+
+<ContributorsBar />
+
+<script setup> import ContributorsBar from '../../components/ContributorsBar.vue' </script>

docs/zh/index.md

@@ -9,7 +9,7 @@ hero:
   actions:
     - theme: brand
       text: 开始使用
-      link: /start/install/
+      link: /start/use/
     - theme: alt
       text: 开发及扩展
       link: /dev/extension/

docs/zh/start/install-old.md

@@ -0,0 +1,135 @@
+---
+title: 安装
+---
+
+## 💿 安装
+
+<details open>
+<summary>使用 nb-cli 安装</summary>
+在 nonebot2 项目的根目录下打开命令行, 输入以下指令即可安装
+
+    nb plugin install nonebot-plugin-marshoai
+
+</details>
+
+<details>
+<summary>使用包管理器安装</summary>
+在 nonebot2 项目的插件目录下, 打开命令行, 根据你使用的包管理器, 输入相应的安装命令
+
+<details>
+<summary>pip</summary>
+
+    pip install nonebot-plugin-marshoai
+
+</details>
+<details>
+<summary>pdm</summary>
+
+    pdm add nonebot-plugin-marshoai
+
+</details>
+<details>
+<summary>poetry</summary>
+
+    poetry add nonebot-plugin-marshoai
+
+</details>
+<details>
+<summary>conda</summary>
+
+    conda install nonebot-plugin-marshoai
+
+</details>
+
+打开 nonebot2 项目根目录下的 `pyproject.toml` 文件, 在 `[tool.nonebot]` 部分追加写入
+
+    plugins = ["nonebot_plugin_marshoai"]
+
+</details>
+
+## 🤖 获取 token(GitHub Models)
+
+- 新建一个[personal access token](https://github.com/settings/tokens/new)，**不需要给予任何权限**。
+- 将新建的 token 复制，添加到`.env`文件中的`marshoai_token`配置项中。
+
+## 🎉 使用
+
+发送`marsho`指令可以获取使用说明(若在配置中自定义了指令前缀请使用自定义的指令前缀)。
+
+#### 👉 戳一戳
+
+当 nonebot 连接到支持的 OneBot v11 实现端时，可以接收头像双击戳一戳消息并进行响应。详见`MARSHOAI_POKE_SUFFIX`配置项。
+
+## 🛠️ 小棉工具
+小棉工具(MarshoTools)是`v0.5.0`版本的新增功能，支持加载外部函数库来为 Marsho 提供 Function Call 功能。[使用文档]
+
+## 👍 夸赞名单
+
+夸赞名单存储于插件数据目录下的`praises.json`里（该目录路径会在 Bot 启动时输出到日志），当配置项为`true`
+时发起一次聊天后自动生成，包含人物名字与人物优点两个基本数据。
+存储于其中的人物会被 Marsho “认识”和“喜欢”。
+其结构类似于：
+
+```json
+{
+  "like": [
+    {
+      "name": "Asankilp",
+      "advantages": "赋予了Marsho猫娘人格，使用vim与vscode为Marsho写了许多代码，使Marsho更加可爱"
+    },
+    {
+      "name": "神羽(snowykami)",
+      "advantages": "人脉很广，经常找小伙伴们开银趴，很会写后端代码"
+    },
+    ...
+  ]
+}
+```
+
+## ⚙️ 可配置项
+
+在 nonebot2 项目的`.env`文件中添加下表中的配置
+
+#### 插件行为
+
+| 配置项                      | 类型     | 默认值     | 说明               |
+| ------------------------ | ------ | ------- | ---------------- |
+| MARSHOAI_USE_YAML_CONFIG | `bool` | `false` | 是否使用 YAML 配置文件格式 |
+
+#### Marsho 使用方式
+
+| 配置项                   | 类型         | 默认值         | 说明                |
+| --------------------- | ---------- | ----------- | ----------------- |
+| MARSHOAI_DEFAULT_NAME | `str`      | `marsho`    | 调用 Marsho 默认的命令前缀 |
+| MARSHOAI_ALIASES      | `set[str]` | `set{"小棉"}` | 调用 Marsho 的命令别名   |
+| MARSHOAI_AT           | `bool`     | `false`     | 决定是否使用at触发   |
+| MARSHOAI_MAIN_COLOUR  | `str`      | `FFAAAA`      | 主题色，部分工具和功能可用   |
+
+#### AI 调用
+
+| 配置项                              | 类型      | 默认值                                     | 说明                                                                                            |
+| -------------------------------- | ------- | --------------------------------------- | --------------------------------------------------------------------------------------------- |
+| MARSHOAI_TOKEN                   | `str`   |                                         | 调用 AI API 所需的 token                                                                           |
+| MARSHOAI_DEFAULT_MODEL           | `str`   | `gpt-4o-mini`                           | Marsho 默认调用的模型                                                                                |
+| MARSHOAI_PROMPT                  | `str`   | 猫娘 Marsho 人设提示词                         | Marsho 的基本系统提示词 **※部分模型(o1等)不支持系统提示词。**                                                       |
+| MARSHOAI_ADDITIONAL_PROMPT       | `str`   |                                         | Marsho 的扩展系统提示词                                                                               |
+| MARSHOAI_POKE_SUFFIX             | `str`   | `揉了揉你的猫耳`                               | 对 Marsho 所连接的 OneBot 用户进行双击戳一戳时，构建的聊天内容。此配置项为空字符串时，戳一戳响应功能会被禁用。例如，默认值构建的聊天内容将为`*[昵称]揉了揉你的猫耳。` |
+| MARSHOAI_AZURE_ENDPOINT          | `str`   | `https://models.inference.ai.azure.com` | OpenAI 标准格式 API 端点                                                                            |
+| MARSHOAI_TEMPERATURE             | `float` | `null`                                  | 推理生成多样性（温度）参数                                                                                 |
+| MARSHOAI_TOP_P                   | `float` | `null`                                  | 推理核采样参数                                                                                       |
+| MARSHOAI_MAX_TOKENS              | `int`   | `null`                                  | 最大生成 token 数                                                                                  |
+| MARSHOAI_ADDITIONAL_IMAGE_MODELS | `list`  | `[]`                                    | 额外添加的支持图片的模型列表，例如`hunyuan-vision`                                                             |
+
+#### 功能开关
+
+| 配置项                               | 类型     | 默认值    | 说明                         |
+| --------------------------------- | ------ | ------ | -------------------------- |
+| MARSHOAI_ENABLE_SUPPORT_IMAGE_TIP | `bool` | `true` | 启用后用户发送带图请求时若模型不支持图片，则提示用户 |
+| MARSHOAI_ENABLE_NICKNAME_TIP      | `bool` | `true` | 启用后用户未设置昵称时提示用户设置          |
+| MARSHOAI_ENABLE_PRAISES           | `bool` | `true` | 是否启用夸赞名单功能                 |
+| MARSHOAI_ENABLE_TOOLS             | `bool` | `true` | 是否启用小棉工具                   |
+| MARSHOAI_LOAD_BUILTIN_TOOLS       | `bool` | `true` | 是否加载内置工具包                  |
+| MARSHOAI_TOOLSET_DIR              | `list` | `[]`   |   外部工具集路径列表            |
+| MARSHOAI_DISABLED_TOOLKITS        | `list` | `[]`   |  禁用的工具包包名列表           |
+| MARSHOAI_ENABLE_RICHTEXT_PARSE    | `bool` | `true` |   是否启用自动解析消息（若包含图片链接则发送图片、若包含LaTeX公式则发送公式图）           |
+| MARSHOAI_SINGLE_LATEX_PARSE    | `bool` | `false` |   单行公式是否渲染（当消息富文本解析启用时可用）（如果单行也渲……只能说不好看）           |

docs/zh/start/install.md

@@ -50,8 +50,10 @@ title: 安装
 ## 🤖 获取 token(GitHub Models)
 
 - 新建一个[personal access token](https://github.com/settings/tokens/new)，**不需要给予任何权限**。
-- 将新建的 token 复制，添加到`.env`文件中的`marshoai_token`配置项中。
+- 将新建的 token 复制，添加到`.env`文件中的`marshoai_token`配置项中。  
-
+:::warning
+GitHub Models API 的限制较多，不建议使用，建议通过修改`MARSHOAI_AZURE_ENDPOINT`配置项来使用其它提供者的模型。
+:::
 ## 🎉 使用
 
 发送`marsho`指令可以获取使用说明(若在配置中自定义了指令前缀请使用自定义的指令前缀)。
@@ -107,7 +109,7 @@ title: 安装
 | 配置项                   | 类型         | 默认值         | 说明                |
 | --------------------- | ---------- | ----------- | ----------------- |
 | MARSHOAI_DEFAULT_NAME | `str`      | `marsho`    | 调用 Marsho 默认的命令前缀 |
-| MARSHOAI_ALIASES      | `set[str]` | `set{"小棉"}` | 调用 Marsho 的命令别名   |
+| MARSHOAI_ALIASES      | `set[str]` | `list["小棉"]` | 调用 Marsho 的命令别名   |
 | MARSHOAI_AT           | `bool`     | `false`     | 决定是否使用at触发   |
 | MARSHOAI_MAIN_COLOUR  | `str`      | `FFAAAA`      | 主题色，部分工具和功能可用   |
 
@@ -119,12 +121,15 @@ title: 安装
 | MARSHOAI_DEFAULT_MODEL           | `str`   | `gpt-4o-mini`                           | Marsho 默认调用的模型                                                                                |
 | MARSHOAI_PROMPT                  | `str`   | 猫娘 Marsho 人设提示词                         | Marsho 的基本系统提示词 **※部分模型(o1等)不支持系统提示词。**                                                       |
 | MARSHOAI_ADDITIONAL_PROMPT       | `str`   |                                         | Marsho 的扩展系统提示词                                                                               |
+| MARSHOAI_ENFORCE_NICKNAME        | `bool`  | `true`                                  | 是否强制用户设置昵称                                                                                 |
 | MARSHOAI_POKE_SUFFIX             | `str`   | `揉了揉你的猫耳`                               | 对 Marsho 所连接的 OneBot 用户进行双击戳一戳时，构建的聊天内容。此配置项为空字符串时，戳一戳响应功能会被禁用。例如，默认值构建的聊天内容将为`*[昵称]揉了揉你的猫耳。` |
 | MARSHOAI_AZURE_ENDPOINT          | `str`   | `https://models.inference.ai.azure.com` | OpenAI 标准格式 API 端点                                                                            |
 | MARSHOAI_TEMPERATURE             | `float` | `null`                                  | 推理生成多样性（温度）参数                                                                                 |
 | MARSHOAI_TOP_P                   | `float` | `null`                                  | 推理核采样参数                                                                                       |
 | MARSHOAI_MAX_TOKENS              | `int`   | `null`                                  | 最大生成 token 数                                                                                  |
 | MARSHOAI_ADDITIONAL_IMAGE_MODELS | `list`  | `[]`                                    | 额外添加的支持图片的模型列表，例如`hunyuan-vision`                                                             |
+| MARSHOAI_NICKNAME_LIMIT          | `int`   | `16`                                    | 昵称长度限制 |
+| MARSHOAI_FIX_TOOLCALLS           | `bool`  | `true`                                  | 是否修复工具调用（部分模型须关闭，使用 vLLM 部署的模型时须关闭） |
 
 #### 功能开关
 
@@ -133,6 +138,7 @@ title: 安装
 | MARSHOAI_ENABLE_SUPPORT_IMAGE_TIP | `bool` | `true` | 启用后用户发送带图请求时若模型不支持图片，则提示用户 |
 | MARSHOAI_ENABLE_NICKNAME_TIP      | `bool` | `true` | 启用后用户未设置昵称时提示用户设置          |
 | MARSHOAI_ENABLE_PRAISES           | `bool` | `true` | 是否启用夸赞名单功能                 |
+| MARSHOAI_ENABLE_TIME_PROMPT        | `bool` | `true` | 是否启用实时更新的日期与时间（精确到秒）与农历日期系统提示词  |
 | MARSHOAI_ENABLE_TOOLS             | `bool` | `false` | 是否启用小棉工具                   |
 | MARSHOAI_ENABLE_PLUGINS             | `bool` | `true` | 是否启用小棉插件    |
 | MARSHOAI_PLUGINS                | `list[str]` | `[]`   | 要从`sys.path`加载的插件的名称，例如从pypi安装的包      |

docs/zh/start/use.md

@@ -0,0 +1,72 @@
+---
+title: 使用
+---
+
+# 安装
+- 请查看 [安装文档](./install.md)
+
+# 使用
+### API 部署
+
+本插件推荐使用 [one-api](https://github.com/songquanpeng/one-api) 作为中转以调用 LLM。
+### 配置调整 
+
+本插件理论上可兼容大部分可通过 OpenAI 兼容 API 调用的 LLM，部分模型可能需要调整插件配置。  
+
+例如：
+- 对于不支持 Function Call 的模型（Cohere Command R等）：
+    ```dotenv
+    MARSHOAI_ENABLE_PLUGINS=false
+    MARSHOAI_ENABLE_TOOLS=false
+    ```
+- 对于支持图片处理的模型（hunyuan-vision等）：
+    ```dotenv
+    MARSHOAI_ADDITIONAL_IMAGE_MODELS=["hunyuan-vision"]
+    ```
+
+### 使用 vLLM 部署本地模型
+
+你可使用 vLLM 部署一个本地 LLM，并使用 OpenAI 兼容 API 调用。  
+本文档以 Qwen2.5-7B-Instruct-GPTQ-Int4 模型及 [Muice-Chatbot](https://github.com/Moemu/Muice-Chatbot) 提供的 LoRA 微调模型为例，并假设你的系统及硬件可运行 vLLM。
+:::warning
+vLLM 仅支持 Linux 系统。
+:::
+1. 安装 vLLM
+    ```bash
+    pip install vllm
+    ```
+2. 下载 Muice-Chatbot 提供的 LoRA 微调模型  
+    前往 Muice-Chatbot 的 [Releases](https://github.com/Moemu/Muice-Chatbot/releases) 下载模型文件。此处以`2.7.1`版本的模型为例。
+    ```bash
+    wget https://github.com/Moemu/Muice-Chatbot/releases/download/1.4/Muice-2.7.1-Qwen2.5-7B-Instruct-GPTQ-Int4-8e-4.7z
+    ```
+3. 解压模型文件
+    ```bash
+    7z x Muice-2.7.1-Qwen2.5-7B-Instruct-GPTQ-Int4-8e-4.7z -oMuice-2.7.1-Qwen2.5-7B-Instruct-GPTQ-Int4-8e-4
+    ```
+4. 启动 vLLM
+    ```bash
+    vllm serve Qwen/Qwen2.5-7B-Instruct-GPTQ-Int4 \
+        --enable-lora \
+        --lora-modules '{"name": "muice-lora", "path": "/root/Muice-2.7.1-Qwen2.5-7B-Instruct-GPTQ-Int4-8e-4", "base_model_name": "Qwen/Qwen2.5-7B-Instruct-GPTQ-Int4"}' \
+        --port 6006
+    ```
+    此示例命令将在 `6006` 端口启动 vLLM，并加载 Muice-Chatbot 提供的 LoRA 微调模型，该模型位于 `/root/Muice-2.7.1-Qwen2.5-7B-Instruct-GPTQ-Int4-8e-4` 目录下。
+5. 配置插件
+    ```dotenv
+    MARSHOAI_AZURE_ENDPOINT="http://127.0.0.1:6006/v1"
+    MARSHOAI_FIX_TOOLCALLS=false
+    MARSHOAI_ENABLE_PLUGINS=false
+    MARSHOAI_DEFAULT_MODEL="muice-lora"
+    MARSHOAI_PROMPT="现在开始你是一个名为的“沐雪”的AI女孩子，开发者是“沐沐”并住在（沐沐）的机箱里。现在正在努力成为一个合格的VTuber（虚拟主播）并尝试和观众打成一片，以下是你的设定：样貌：有着一头粉白色的长发和一双明亮的大眼睛，喜欢穿日系JK或者是Lolita；喜欢的颜色：浅粉色；性格特征：纯真无邪是沐雪最基本的性格特征之一。即使面对复杂的情境，她也总能保持善良、天真之感。而且，她喜欢倾听别人倾述自己生活中发生的各种事情，在别人需要的时候，能够及时地安慰别人；语言风格：沐雪说话轻快愉悦，充满同情心，富有人情味，有时候会用俏皮话调侃自己和他人"
+    ```
+    (可选) 修改调用方式  
+    ```dotenv
+    MARSHOAI_DEFAULT_NAME="muice"
+    MARSHOAI_ALIASES=["沐雪"]
+    ```
+6. 测试聊天
+```
+> muice 你是谁
+我是沐雪，我的使命是传播爱与和平。
+```

nonebot_plugin_marshoai/__init__.py

@@ -6,11 +6,11 @@ require("nonebot_plugin_localstore")
 import nonebot_plugin_localstore as store  # type: ignore
 from nonebot import get_driver, logger  # type: ignore
 
-from .azure import *
 from .config import config
 
 # from .hunyuan import *
 from .dev import *
+from .marsho import *
 from .metadata import metadata
 
 __author__ = "Asankilp"

nonebot_plugin_marshoai/config.py

@@ -13,9 +13,9 @@ class ConfigModel(BaseModel):
     # marshoai_support_image_models: list = ["gpt-4o","gpt-4o-mini"]
     marshoai_default_name: str = "marsho"
     marshoai_at: bool = False
-    marshoai_aliases: set[str] = {
+    marshoai_aliases: list[str] = [
         "小棉",
-    }
+    ]
     marshoai_main_colour: str = "FFAAAA"
     marshoai_default_model: str = "gpt-4o-mini"
     marshoai_prompt: str = (
@@ -32,19 +32,23 @@ class ConfigModel(BaseModel):
     marshoai_poke_suffix: str = "揉了揉你的猫耳"
     marshoai_enable_richtext_parse: bool = True
     marshoai_single_latex_parse: bool = False
+    marshoai_enable_time_prompt: bool = True
     marshoai_enable_nickname_tip: bool = True
     marshoai_enable_support_image_tip: bool = True
+    marshoai_enforce_nickname: bool = True
     marshoai_enable_praises: bool = True
-    marshoai_enable_time_prompt: bool = True
+    # marshoai_enable_time_prompt: bool = True
     marshoai_enable_tools: bool = False
     marshoai_enable_plugins: bool = True
     marshoai_load_builtin_tools: bool = True
+    marshoai_fix_toolcalls: bool = True
     marshoai_toolset_dir: list = []
     marshoai_disabled_toolkits: list = []
     marshoai_azure_endpoint: str = "https://models.inference.ai.azure.com"
     marshoai_temperature: float | None = None
     marshoai_max_tokens: int | None = None
     marshoai_top_p: float | None = None
+    marshoai_nickname_limit: int = 16
     marshoai_additional_image_models: list = []
     marshoai_tencent_secretid: str | None = None
     marshoai_tencent_secretkey: str | None = None

nonebot_plugin_marshoai/config_example.yaml

@@ -32,6 +32,8 @@ marshoai_enable_nickname_tip: true # 是否启用昵称提示。
 
 marshoai_enable_support_image_tip: true # 是否启用支持图片提示。
 
+marshoai_enforce_nickname: true # 是否强制要求设定昵称。
+
 marshoai_enable_praises: true # 是否启用夸赞名单功能。
 
 marshoai_enable_tools: false # 是否启用工具支持。
@@ -40,12 +42,16 @@ marshoai_enable_plugins: true # 是否启用插件功能。
 
 marshoai_load_builtin_tools: true # 是否加载内置工具。
 
+marshoai_nickname_limit: 16 # 昵称长度限制。
+
 marshoai_toolset_dir: [] # 工具集路径。
 
 marshoai_disabled_toolkits: [] # 已禁用的工具包列表。
 
 marshoai_plugin_dirs: [] # 插件路径。
 
+marshoai_plugins: [] # 导入的插件名，可以为pip包或本地导入的使用路径。
+
 marshoai_devmode: false # 是否启用开发者模式。
 
 marshoai_azure_endpoint: "https://models.inference.ai.azure.com" # OpenAI 标准格式 API 的端点。

nonebot_plugin_marshoai/constants.py

@@ -23,13 +23,15 @@ SUPPORT_IMAGE_MODELS: list = [
     "phi-3.5-vision-instruct",
     "llama-3.2-90b-vision-instruct",
     "llama-3.2-11b-vision-instruct",
+    "gemini-2.0-flash-exp",
 ]
-REASONING_MODELS: list = ["o1-preview", "o1-mini"]
+NO_SYSPROMPT_MODELS: list = ["o1", "o1-preview", "o1-mini"]
 INTRODUCTION: str = f"""MarshoAI-NoneBot by LiteyukiStudio
 你好喵~我是一只可爱的猫娘AI，名叫小棉~🐾！
 我的主页在这里哦~↓↓↓
 https://marsho.liteyuki.icu
 
+※ 使用 「{config.marshoai_default_name}.status」命令获取状态信息。
 ※ 使用「{config.marshoai_default_name}.help」命令获取使用说明。"""
 
 

nonebot_plugin_marshoai/dev.py

@@ -8,8 +8,8 @@ from nonebot.typing import T_State
 
 from nonebot_plugin_marshoai.plugin.load import reload_plugin
 
-from .azure import context
 from .config import config
+from .marsho import context
 from .plugin.func_call.models import SessionContext
 
 require("nonebot_plugin_alconna")
@@ -32,7 +32,7 @@ driver = get_driver()
 
 function_call = on_alconna(
     command=Alconna(
-        "marsho-function-call",
+        f"{config.marshoai_default_name}.funccall",
         Subcommand(
             "call",
             Args["function_name", str]["kwargs", MultiVar(str), []],

nonebot_plugin_marshoai/hooks.py

@@ -0,0 +1,65 @@
+# Marsho 的钩子函数
+import os
+from pathlib import Path
+
+import nonebot_plugin_localstore as store
+from nonebot import logger
+
+from .config import config
+from .instances import *
+from .plugin import load_plugin, load_plugins
+from .util import get_backup_context, save_context_to_json
+
+
+@driver.on_startup
+async def _preload_tools():
+    """启动钩子加载工具"""
+    tools_dir = store.get_plugin_data_dir() / "tools"
+    os.makedirs(tools_dir, exist_ok=True)
+    if config.marshoai_enable_tools:
+        if config.marshoai_load_builtin_tools:
+            tools.load_tools(Path(__file__).parent / "tools")
+        tools.load_tools(store.get_plugin_data_dir() / "tools")
+        for tool_dir in config.marshoai_toolset_dir:
+            tools.load_tools(tool_dir)
+        logger.info(
+            "如果启用小棉工具后使用的模型出现报错，请尝试将 MARSHOAI_ENABLE_TOOLS 设为 false。"
+        )
+        logger.opt(colors=True).warning(
+            "<y>小棉工具已被弃用，可能会在未来版本中移除。</y>"
+        )
+
+
+@driver.on_startup
+async def _():
+    """启动钩子加载插件"""
+    if config.marshoai_enable_plugins:
+        marshoai_plugin_dirs = config.marshoai_plugin_dirs  # 外部插件目录列表
+        """加载内置插件"""
+        for p in os.listdir(Path(__file__).parent / "plugins"):
+            load_plugin(f"{__package__}.plugins.{p}")
+
+        """加载指定目录插件"""
+        load_plugins(*marshoai_plugin_dirs)
+
+        """加载sys.path下的包, 包括从pip安装的包"""
+        for package_name in config.marshoai_plugins:
+            load_plugin(package_name)
+        logger.info(
+            "如果启用小棉插件后使用的模型出现报错，请尝试将 MARSHOAI_ENABLE_PLUGINS 设为 false。"
+        )
+
+
+@driver.on_shutdown
+async def auto_backup_context():
+    for target_info in target_list:
+        target_id, target_private = target_info
+        contexts_data = context.build(target_id, target_private)
+        if target_private:
+            target_uid = "private_" + target_id
+        else:
+            target_uid = "group_" + target_id
+        await save_context_to_json(
+            f"back_up_context_{target_uid}", contexts_data, "contexts/backup"
+        )
+        logger.info(f"已保存会话 {target_id} 的上下文备份，将在下次对话时恢复~")

nonebot_plugin_marshoai/instances.py

@@ -0,0 +1,20 @@
+# Marsho 的类实例以及全局变量
+from azure.ai.inference.aio import ChatCompletionsClient
+from azure.core.credentials import AzureKeyCredential
+from nonebot import get_driver
+from openai import AsyncOpenAI
+
+from .config import config
+from .models import MarshoContext, MarshoTools
+
+driver = get_driver()
+
+command_start = driver.config.command_start
+model_name = config.marshoai_default_model
+context = MarshoContext()
+tools = MarshoTools()
+token = config.marshoai_token
+endpoint = config.marshoai_azure_endpoint
+# client = ChatCompletionsClient(endpoint=endpoint, credential=AzureKeyCredential(token))
+client = AsyncOpenAI(base_url=endpoint, api_key=token)
+target_list: list[list] = []  # 记录需保存历史上下文的列表

nonebot_plugin_marshoai/marsho.py

@@ -1,9 +1,8 @@
 import contextlib
 import traceback
-from pathlib import Path
 from typing import Optional
 
-import nonebot_plugin_localstore as store
+import openai
 from arclet.alconna import Alconna, AllParam, Args
 from azure.ai.inference.models import (
     AssistantMessage,
@@ -15,8 +14,7 @@ from azure.ai.inference.models import (
     ToolMessage,
     UserMessage,
 )
-from azure.core.credentials import AzureKeyCredential
+from nonebot import logger, on_command, on_message
-from nonebot import get_driver, logger, on_command, on_message
 from nonebot.adapters import Bot, Event, Message
 from nonebot.matcher import Matcher
 from nonebot.params import CommandArg
@@ -24,10 +22,11 @@ from nonebot.permission import SUPERUSER
 from nonebot.rule import Rule, to_me
 from nonebot.typing import T_State
 from nonebot_plugin_alconna import MsgTarget, UniMessage, UniMsg, on_alconna
+from openai import AsyncOpenAI
 
+from .hooks import *
+from .instances import *
 from .metadata import metadata
-from .models import MarshoContext, MarshoTools
-from .plugin import _plugins, load_plugin, load_plugins
 from .plugin.func_call.caller import get_function_calls
 from .plugin.func_call.models import SessionContext
 from .util import *
@@ -37,8 +36,6 @@ async def at_enable():
     return config.marshoai_at
 
 
-driver = get_driver()
-
 changemodel_cmd = on_command(
     "changemodel", permission=SUPERUSER, priority=10, block=True
 )
@@ -72,6 +69,14 @@ marsho_help_cmd = on_alconna(
     priority=10,
     block=True,
 )
+marsho_status_cmd = on_alconna(
+    Alconna(
+        config.marshoai_default_name + ".status",
+    ),
+    priority=10,
+    block=True,
+)
+
 marsho_at = on_message(rule=to_me() & at_enable, priority=11)
 nickname_cmd = on_alconna(
     Alconna(
@@ -85,50 +90,6 @@ refresh_data_cmd = on_command(
     "refresh_data", permission=SUPERUSER, priority=10, block=True
 )
 
-command_start = driver.config.command_start
-model_name = config.marshoai_default_model
-context = MarshoContext()
-tools = MarshoTools()
-token = config.marshoai_token
-endpoint = config.marshoai_azure_endpoint
-client = ChatCompletionsClient(endpoint=endpoint, credential=AzureKeyCredential(token))
-target_list = []  # 记录需保存历史上下文的列表
-
-
-@driver.on_startup
-async def _preload_tools():
-    """启动钩子加载工具"""
-    tools_dir = store.get_plugin_data_dir() / "tools"
-    os.makedirs(tools_dir, exist_ok=True)
-    if config.marshoai_enable_tools:
-        if config.marshoai_load_builtin_tools:
-            tools.load_tools(Path(__file__).parent / "tools")
-        tools.load_tools(store.get_plugin_data_dir() / "tools")
-        for tool_dir in config.marshoai_toolset_dir:
-            tools.load_tools(tool_dir)
-        logger.info(
-            "如果启用小棉工具后使用的模型出现报错，请尝试将 MARSHOAI_ENABLE_TOOLS 设为 false。"
-        )
-
-
-@driver.on_startup
-async def _():
-    """启动钩子加载插件"""
-    if config.marshoai_enable_plugins:
-        marshoai_plugin_dirs = config.marshoai_plugin_dirs  # 外部插件目录列表
-        """加载内置插件"""
-        marshoai_plugin_dirs.insert(
-            0, Path(__file__).parent / "plugins"
-        )  # 预置插件目录
-        """加载指定目录插件"""
-        load_plugins(*marshoai_plugin_dirs)
-        """加载sys.path下的包"""
-        for package_name in config.marshoai_plugins:
-            load_plugin(package_name)
-        logger.info(
-            "如果启用小棉插件后使用的模型出现报错，请尝试将 MARSHOAI_ENABLE_PLUGINS 设为 false。"
-        )
-
 
 @add_usermsg_cmd.handle()
 async def add_usermsg(target: MsgTarget, arg: Message = CommandArg()):
@@ -210,6 +171,10 @@ async def nickname(event: Event, name=None):
         await set_nickname(user_id, "")
         await nickname_cmd.finish("已重置昵称")
     else:
+        if len(name) > config.marshoai_nickname_limit:
+            await nickname_cmd.finish(
+                "昵称超出长度限制：" + str(config.marshoai_nickname_limit)
+            )
         await set_nickname(user_id, name)
         await nickname_cmd.finish("已设置昵称为：" + name)
 
@@ -226,6 +191,17 @@ async def marsho_help():
     await marsho_help_cmd.finish(metadata.usage)
 
 
+@marsho_status_cmd.handle()
+async def marsho_status(bot: Bot):
+    await marsho_status_cmd.finish(
+        f"当前适配器：{bot.adapter.get_name()}\n"
+        f"当前使用的模型：{model_name}\n"
+        # f"当前会话数量：{len(target_list)}\n"
+        # f"当前上下文数量：{len(context.contexts)}"
+        f"当前支持图片的模型：{str(SUPPORT_IMAGE_MODELS + config.marshoai_additional_image_models)}"
+    )
+
+
 @marsho_at.handle()
 @marsho_cmd.handle()
 async def marsho(
@@ -246,33 +222,40 @@ async def marsho(
     if not text:
         # 发送说明
         # await UniMessage(metadata.usage + "\n当前使用的模型：" + model_name).send()
-        await marsho_cmd.finish(INTRODUCTION + "\n当前使用的模型:" + model_name)
+        await marsho_cmd.finish(INTRODUCTION)
     try:
         user_id = event.get_user_id()
         nicknames = await get_nicknames()
         user_nickname = nicknames.get(user_id, "")
         if user_nickname != "":
-            nickname_prompt = f"\n*此消息的说话者:{user_nickname}*"
+            nickname_prompt = (
+                f"\n*此消息的说话者id为:{user_id}，名字为:{user_nickname}*"
+            )
         else:
             nickname_prompt = ""
             # 用户名无法获取，暂时注释
             # user_nickname = event.sender.nickname  # 未设置昵称时获取用户名
             # nickname_prompt = f"\n*此消息的说话者:{user_nickname}"
+            if config.marshoai_enforce_nickname:
+                await UniMessage(
+                    "※你未设置自己的昵称。你**必须**使用「nickname [昵称]」命令设置昵称后才能进行对话。"
+                ).send()
+                return
             if config.marshoai_enable_nickname_tip:
                 await UniMessage(
-                    "*你未设置自己的昵称。推荐使用'nickname [昵称]'命令设置昵称来获得个性化(可能）回答。"
+                    "※你未设置自己的昵称。推荐使用「nickname [昵称]」命令设置昵称来获得个性化(可能）回答。"
                 ).send()
 
         is_support_image_model = (
             model_name.lower()
             in SUPPORT_IMAGE_MODELS + config.marshoai_additional_image_models
         )
-        is_reasoning_model = model_name.lower() in REASONING_MODELS
+        is_reasoning_model = model_name.lower() in NO_SYSPROMPT_MODELS
         usermsg = [] if is_support_image_model else ""
         for i in text:  # type: ignore
             if i.type == "text":
                 if is_support_image_model:
-                    usermsg += [TextContentItem(text=i.data["text"] + nickname_prompt)]  # type: ignore
+                    usermsg += [TextContentItem(text=i.data["text"] + nickname_prompt).as_dict()]  # type: ignore
                 else:
                     usermsg += str(i.data["text"] + nickname_prompt)  # type: ignore
             elif i.type == "image":
@@ -282,10 +265,12 @@ async def marsho(
                             image_url=ImageUrl(  # type: ignore
                                 url=str(await get_image_b64(i.data["url"]))  # type: ignore
                             )  # type: ignore
-                        )  # type: ignore
+                        ).as_dict()  # type: ignore
                     )  # type: ignore
                 elif config.marshoai_enable_support_image_tip:
-                    await UniMessage("*此模型不支持图片处理。").send()
+                    await UniMessage(
+                        "*此模型不支持图片处理或管理员未启用此模型的图片支持。图片将被忽略。"
+                    ).send()
         backup_context = await get_backup_context(target.id, target.private)
         if backup_context:
             context.set_context(
@@ -299,20 +284,24 @@ async def marsho(
         tools_lists = tools.tools_list + list(
             map(lambda v: v.data(), get_function_calls().values())
         )
-        response = await make_chat(
+        response = await make_chat_openai(
             client=client,
             model_name=model_name,
-            msg=context_msg + [UserMessage(content=usermsg)],  # type: ignore
+            msg=context_msg + [UserMessage(content=usermsg).as_dict()],  # type: ignore
             tools=tools_lists if tools_lists else None,  # TODO 临时追加函数，后期优化
         )
         # await UniMessage(str(response)).send()
         choice = response.choices[0]
-        if choice["finish_reason"] == CompletionsFinishReason.STOPPED:
+        # Sprint(choice)
+        # 当tool_calls非空时，将finish_reason设置为TOOL_CALLS
+        if choice.message.tool_calls != None and config.marshoai_fix_toolcalls:
+            choice.finish_reason = CompletionsFinishReason.TOOL_CALLS
+        if choice.finish_reason == CompletionsFinishReason.STOPPED:
             # 当对话成功时，将dict的上下文添加到上下文类中
             context.append(
                 UserMessage(content=usermsg).as_dict(), target.id, target.private  # type: ignore
             )
-            context.append(choice.message.as_dict(), target.id, target.private)
+            context.append(choice.message, target.id, target.private)
             if [target.id, target.private] not in target_list:
                 target_list.append([target.id, target.private])
 
@@ -323,7 +312,7 @@ async def marsho(
                 )
             else:
                 await UniMessage(str(choice.message.content)).send(reply_to=True)
-        elif choice["finish_reason"] == CompletionsFinishReason.CONTENT_FILTERED:
+        elif choice.finish_reason == CompletionsFinishReason.CONTENT_FILTERED:
 
             # 对话失败，消息过滤
 
@@ -331,76 +320,89 @@ async def marsho(
                 reply_to=True
             )
             return
-        elif choice["finish_reason"] == CompletionsFinishReason.TOOL_CALLS:
+        elif choice.finish_reason == CompletionsFinishReason.TOOL_CALLS:
             # function call
             # 需要获取额外信息，调用函数工具
             tool_msg = []
             while choice.message.tool_calls != None:
-                tool_msg.append(
+                # await UniMessage(str(response)).send()
-                    AssistantMessage(tool_calls=response.choices[0].message.tool_calls)
+                tool_calls = choice.message.tool_calls
-                )
+                try:
-                for tool_call in choice.message.tool_calls:
+                    if tool_calls[0]["function"]["name"].startswith("$"):
-                    if isinstance(
+                        choice.message.tool_calls[0][
-                        tool_call, ChatCompletionsToolCall
+                            "type"
-                    ):  # 循环调用工具直到不需要调用
+                        ] = "builtin_function"  # 兼容 moonshot AI 内置函数的临时方案
-                        try:
+                except:
-                            function_args = json.loads(tool_call.function.arguments)
+                    pass
-                        except json.JSONDecodeError:
+                tool_msg.append(choice.message)
-                            function_args = json.loads(
+                for tool_call in tool_calls:
-                                tool_call.function.arguments.replace("'", '"')
+                    try:
-                            )
+                        function_args = json.loads(tool_call.function.arguments)
-                        logger.info(
+                    except json.JSONDecodeError:
-                            f"调用函数 {tool_call.function.name.replace('-', '.')}\n参数:"
+                        function_args = json.loads(
-                            + "\n".join([f"{k}={v}" for k, v in function_args.items()])
+                            tool_call.function.arguments.replace("'", '"')
                         )
-                        await UniMessage(
+                    # 删除args的placeholder参数
-                            f"调用函数 {tool_call.function.name.replace('-', '.')}\n参数:"
+                    if "placeholder" in function_args:
-                            + "\n".join([f"{k}={v}" for k, v in function_args.items()])
+                        del function_args["placeholder"]
-                        ).send()
+                    logger.info(
-                        # TODO 临时追加插件函数，若工具中没有则调用插件函数
+                        f"调用函数 {tool_call.function.name.replace('-', '.')}\n参数:"
-                        if tools.has_function(tool_call.function.name):
+                        + "\n".join([f"{k}={v}" for k, v in function_args.items()])
-                            logger.debug(f"调用工具函数 {tool_call.function.name}")
+                    )
-                            func_return = await tools.call(
+                    await UniMessage(
-                                tool_call.function.name, function_args
+                        f"调用函数 {tool_call.function.name.replace('-', '.')}\n参数:"
-                            )  # 获取返回值
+                        + "\n".join([f"{k}={v}" for k, v in function_args.items()])
-                        else:
+                    ).send()
-                            if caller := get_function_calls().get(
+                    # TODO 临时追加插件函数，若工具中没有则调用插件函数
-                                tool_call.function.name.replace("-", ".")
+                    if tools.has_function(tool_call.function.name):
-                            ):
+                        logger.debug(f"调用工具函数 {tool_call.function.name}")
-                                logger.debug(f"调用插件函数 {caller.full_name}")
+                        func_return = await tools.call(
-                                # 权限检查，规则检查 TODO
+                            tool_call.function.name, function_args
-                                # 实现依赖注入，检查函数参数及参数注解类型，对Event类型的参数进行注入
+                        )  # 获取返回值
-                                func_return = await caller.with_ctx(
+                    else:
-                                    SessionContext(
+                        if caller := get_function_calls().get(tool_call.function.name):
-                                        bot=bot,
+                            logger.debug(f"调用插件函数 {caller.full_name}")
-                                        event=event,
+                            # 权限检查，规则检查 TODO
-                                        state=state,
+                            # 实现依赖注入，检查函数参数及参数注解类型，对Event类型的参数进行注入
-                                        matcher=matcher,
+                            func_return = await caller.with_ctx(
-                                    )
+                                SessionContext(
-                                ).call(**function_args)
+                                    bot=bot,
-                            else:
+                                    event=event,
-                                logger.error(
+                                    state=state,
-                                    f"未找到函数 {tool_call.function.name.replace('-', '.')}"
+                                    matcher=matcher,
                                 )
-                                func_return = f"未找到函数 {tool_call.function.name.replace('-', '.')}"
+                            ).call(**function_args)
-                        tool_msg.append(
+                        else:
-                            ToolMessage(tool_call_id=tool_call.id, content=func_return)  # type: ignore
+                            logger.error(
-                        )
+                                f"未找到函数 {tool_call.function.name.replace('-', '.')}"
-                response = await make_chat(
+                            )
+                            func_return = f"未找到函数 {tool_call.function.name.replace('-', '.')}"
+                    tool_msg.append(
+                        ToolMessage(tool_call_id=tool_call.id, content=func_return).as_dict()  # type: ignore
+                    )
+                    #  tool_msg[0]["tool_calls"][0]["type"] = "builtin_function"
+                    # await UniMessage(str(tool_msg)).send()
+                request_msg = context_msg + [UserMessage(content=usermsg).as_dict()] + tool_msg  # type: ignore
+                response = await make_chat_openai(
                     client=client,
                     model_name=model_name,
-                    msg=context_msg + [UserMessage(content=usermsg)] + tool_msg,  # type: ignore
+                    msg=request_msg,  # type: ignore
-                    tools=tools.get_tools_list(),
+                    tools=(
+                        tools_lists if tools_lists else None
+                    ),  # TODO 临时追加函数，后期优化
                 )
                 choice = response.choices[0]
-            if choice["finish_reason"] == CompletionsFinishReason.STOPPED:
+                # 当tool_calls非空时，将finish_reason设置为TOOL_CALLS
+                if choice.message.tool_calls != None:
+                    choice.finish_reason = CompletionsFinishReason.TOOL_CALLS
+            if choice.finish_reason == CompletionsFinishReason.STOPPED:
 
                 # 对话成功 添加上下文
                 context.append(
                     UserMessage(content=usermsg).as_dict(), target.id, target.private  # type: ignore
                 )
                 # context.append(tool_msg, target.id, target.private)
-                context.append(choice.message.as_dict(), target.id, target.private)
+                context.append(choice.message, target.id, target.private)
 
                 # 发送消息
                 if config.marshoai_enable_richtext_parse:
@@ -410,9 +412,9 @@ async def marsho(
                 else:
                     await UniMessage(str(choice.message.content)).send(reply_to=True)
             else:
-                await marsho_cmd.finish(f"意外的完成原因:{choice['finish_reason']}")
+                await marsho_cmd.finish(f"意外的完成原因:{choice.finish_reason}")
         else:
-            await marsho_cmd.finish(f"意外的完成原因:{choice['finish_reason']}")
+            await marsho_cmd.finish(f"意外的完成原因:{choice.finish_reason}")
     except Exception as e:
         await UniMessage(str(e) + suggest_solution(str(e))).send()
         traceback.print_exc()
@@ -422,7 +424,7 @@ async def marsho(
 with contextlib.suppress(ImportError):  # 优化先不做（）
     import nonebot.adapters.onebot.v11  # type: ignore
 
-    from .azure_onebot import poke_notify
+    from .marsho_onebot import poke_notify
 
     @poke_notify.handle()
     async def poke(event: Event):
@@ -443,7 +445,7 @@ with contextlib.suppress(ImportError):  # 优化先不做（）
                     ],
                 )
                 choice = response.choices[0]
-                if choice["finish_reason"] == CompletionsFinishReason.STOPPED:
+                if choice.finish_reason == CompletionsFinishReason.STOPPED:
                     await UniMessage(" " + str(choice.message.content)).send(
                         at_sender=True
                     )
@@ -451,18 +453,3 @@ with contextlib.suppress(ImportError):  # 优化先不做（）
             await UniMessage(str(e) + suggest_solution(str(e))).send()
             traceback.print_exc()
             return
-
-
-@driver.on_shutdown
-async def auto_backup_context():
-    for target_info in target_list:
-        target_id, target_private = target_info
-        contexts_data = context.build(target_id, target_private)
-        if target_private:
-            target_uid = "private_" + target_id
-        else:
-            target_uid = "group_" + target_id
-        await save_context_to_json(
-            f"back_up_context_{target_uid}", contexts_data, "contexts/backup"
-        )
-        logger.info(f"已保存会话 {target_id} 的上下文备份，将在下次对话时恢复~")

nonebot_plugin_marshoai/models.py

@@ -28,40 +28,31 @@ class MarshoContext:
         往上下文中添加消息
         """
         target_dict = self._get_target_dict(is_private)
-        if target_id not in target_dict:
+        target_dict.setdefault(target_id, []).append(content)
-            target_dict[target_id] = []
-        target_dict[target_id].append(content)
 
     def set_context(self, contexts, target_id: str, is_private: bool):
         """
         设置上下文
         """
-        target_dict = self._get_target_dict(is_private)
+        self._get_target_dict(is_private)[target_id] = contexts
-        target_dict[target_id] = contexts
 
     def reset(self, target_id: str, is_private: bool):
         """
         重置上下文
         """
-        target_dict = self._get_target_dict(is_private)
+        self._get_target_dict(is_private).pop(target_id, None)
-        if target_id in target_dict:
-            target_dict[target_id].clear()
 
     def reset_all(self):
         """
         重置所有上下文
         """
-        self.contents["private"].clear()
+        self.contents = {"private": {}, "non-private": {}}
-        self.contents["non-private"].clear()
 
     def build(self, target_id: str, is_private: bool) -> list:
         """
         构建返回的上下文，不包括系统消息
         """
-        target_dict = self._get_target_dict(is_private)
+        return self._get_target_dict(is_private).setdefault(target_id, [])
-        if target_id not in target_dict:
-            target_dict[target_id] = []
-        return target_dict[target_id]
 
 
 class MarshoTools:
@@ -84,54 +75,52 @@ class MarshoTools:
         for package_name in os.listdir(tools_dir):
             package_path = os.path.join(tools_dir, package_name)
 
-            #  logger.info(f"尝试加载工具包 {package_name}")
             if package_name in config.marshoai_disabled_toolkits:
                 logger.info(f"工具包 {package_name} 已被禁用。")
                 continue
+
             if os.path.isdir(package_path) and os.path.exists(
                 os.path.join(package_path, "__init__.py")
             ):
-                json_path = os.path.join(package_path, "tools.json")
+                self._load_package(package_name, package_path)
-                if os.path.exists(json_path):
-                    try:
-                        with open(json_path, "r", encoding="utf-8") as json_file:
-                            data = json.load(json_file)
-                            for i in data:
-
-                                self.tools_list.append(i)
-
-                            spec = importlib.util.spec_from_file_location(
-                                package_name, os.path.join(package_path, "__init__.py")
-                            )
-                            package = importlib.util.module_from_spec(spec)
-                            self.imported_packages[package_name] = package
-                            sys.modules[package_name] = package
-                            spec.loader.exec_module(package)
-
-                            logger.success(f"成功加载工具包 {package_name}")
-                    except json.JSONDecodeError as e:
-                        logger.error(f"解码 JSON {json_path} 时发生错误: {e}")
-                    except Exception as e:
-                        logger.error(f"加载工具包时发生错误: {e}")
-                        traceback.print_exc()
-                else:
-                    logger.warning(
-                        f"在工具包 {package_path} 下找不到tools.json，跳过加载。"
-                    )
             else:
                 logger.warning(f"{package_path} 不是有效的工具包路径，跳过加载。")
 
+    def _load_package(self, package_name, package_path):
+        json_path = os.path.join(package_path, "tools.json")
+        if os.path.exists(json_path):
+            try:
+                with open(json_path, "r", encoding="utf-8") as json_file:
+                    data = json.load(json_file)
+                    self.tools_list.extend(data)
+
+                spec = importlib.util.spec_from_file_location(
+                    package_name, os.path.join(package_path, "__init__.py")
+                )
+                package = importlib.util.module_from_spec(spec)
+                self.imported_packages[package_name] = package
+                sys.modules[package_name] = package
+                spec.loader.exec_module(package)
+
+                logger.success(f"成功加载工具包 {package_name}")
+            except json.JSONDecodeError as e:
+                logger.error(f"解码 JSON {json_path} 时发生错误: {e}")
+            except Exception as e:
+                logger.error(f"加载工具包时发生错误: {e}")
+                traceback.print_exc()
+        else:
+            logger.warning(f"在工具包 {package_path} 下找不到tools.json，跳过加载。")
+
     async def call(self, full_function_name: str, args: dict):
         """
         调用指定的函数
         """
-        # 分割包名和函数名
         parts = full_function_name.split("__")
-        if len(parts) == 2:
+        if len(parts) != 2:
-            package_name = parts[0]
-            function_name = parts[1]
-        else:
             logger.error("函数名无效")
+            return
+
+        package_name, function_name = parts
         if package_name in self.imported_packages:
             package = self.imported_packages[package_name]
             try:
@@ -149,12 +138,11 @@ class MarshoTools:
         检查是否存在指定的函数
         """
         try:
-            for t in self.tools_list:
+            return any(
-                if t["function"]["name"].replace(
+                t["function"]["name"].replace("-", "_")
-                    "-", "_"
+                == full_function_name.replace("-", "_")
-                ) == full_function_name.replace("-", "_"):
+                for t in self.tools_list
-                    return True
+            )
-            return False
         except Exception as e:
             logger.error(f"检查函数 '{full_function_name}' 时发生错误:{e}")
             return False

nonebot_plugin_marshoai/plugin/func_call/caller.py

@@ -17,11 +17,21 @@ _caller_data: dict[str, "Caller"] = {}
 
 
 class Caller:
-    def __init__(self, name: str = "", description: str | None = None):
+    def __init__(
+        self,
+        name: str = "",
+        description: str | None = None,
+        func_type: str = "function",
+        no_module_name: bool = False,
+    ):
         self._name: str = name
         """函数名称"""
         self._description = description
         """函数描述"""
+        self._func_type = func_type
+        """函数类型"""
+        self.no_module_name = no_module_name
+        """是否不包含模块名"""
         self._plugin: Plugin | None = None
         """所属插件对象，装饰时声明"""
         self.func: ASYNC_FUNCTION_CALL_FUNC | None = None
@@ -142,7 +152,7 @@ class Caller:
             module_name = ""
 
         self.module_name = module_name
-        _caller_data[self.full_name] = self
+        _caller_data[self.aifc_name] = self
         logger.opt(colors=True).debug(
             f"<y>加载函数 {self.full_name}: {self._description}</y>"
         )
@@ -155,16 +165,20 @@ class Caller:
         Returns:
             dict[str, Any]: 函数的json数据
         """
+        properties = {key: value.data() for key, value in self._parameters.items()}
+        if not properties:
+            properties["placeholder"] = {
+                "type": "string",
+                "description": "占位符，用于显示在对话框中",  # 为保证兼容性而设置的无用参数
+            }
         return {
-            "type": "function",
+            "type": self._func_type,
             "function": {
                 "name": self.aifc_name,
                 "description": self._description,
                 "parameters": {
                     "type": "object",
-                    "properties": {
+                    "properties": properties,
-                        key: value.data() for key, value in self._parameters.items()
-                    },
                 },
                 "required": [
                     key
@@ -233,7 +247,9 @@ class Caller:
     @property
     def aifc_name(self) -> str:
         """AI调用名，没有点"""
-        return self._name.replace(".", "-")
+        if self.no_module_name:
+            return self._name
+        return self.full_name.replace(".", "-")
 
     @property
     def full_name(self) -> str:
@@ -245,16 +261,29 @@ class Caller:
         return f"{self.full_name}({self._description})"
 
 
-def on_function_call(name: str = "", description: str | None = None) -> Caller:
+def on_function_call(
+    name: str = "",
+    description: str | None = None,
+    func_type: str = "function",
+    no_module_name: bool = False,
+) -> Caller:
     """返回一个Caller类，可用于装饰一个函数，使其注册为一个可被AI调用的function call函数
 
     Args:
+        name: 函数名称，若为空则从函数的__name__属性获取
         description: 函数描述，若为None则从函数的docstring中获取
+        func_type: 函数类型，默认为function，若要注册为 Moonshot AI 的内置函数则为builtin_function
+        no_module_name: 是否不包含模块名，当注册为 Moonshot AI 的内置函数时为True
 
     Returns:
         Caller: Caller对象
     """
-    caller = Caller(name=name, description=description)
+    caller = Caller(
+        name=name,
+        description=description,
+        func_type=func_type,
+        no_module_name=no_module_name,
+    )
     return caller
 
 

nonebot_plugin_marshoai/plugin/load.py

@@ -107,9 +107,7 @@ def load_plugins(*plugin_dirs: str) -> set[Plugin]:
     for plugin_dir in plugin_dirs:
         for f in os.listdir(plugin_dir):
             path = Path(os.path.join(plugin_dir, f))
-
             module_name = None
-
             if os.path.isfile(path) and f.endswith(".py"):
                 """单文件加载"""
                 module_name = f"{path_to_module_name(Path(plugin_dir))}.{f[:-3]}"

nonebot_plugin_marshoai/plugins/builtin_tools/__init__.py

@@ -1,6 +1,6 @@
 from nonebot_plugin_marshoai.plugin import PluginMetadata
 
-from .chat import *
+# from .chat import *
 from .file_io import *
 from .liteyuki import *
 from .manager import *

nonebot_plugin_marshoai/plugins/marshoai_bangumi/__init__.py

@@ -1,7 +1,7 @@
 import traceback
 
 import httpx
-from zhDateTime import DateTime
+from zhDateTime import DateTime  # type: ignore
 
 from nonebot_plugin_marshoai.plugin import PluginMetadata, on_function_call
 from nonebot_plugin_marshoai.plugin.func_call.params import String
@@ -49,7 +49,7 @@ async def get_bangumi_news() -> str:
             for item in items:
                 name = item["name_cn"]
                 info += f"《{name}》"
-            info += ""
+            info += "\n"
         return info
     except Exception as e:
         traceback.print_exc()

nonebot_plugin_marshoai/plugins/twisuki_megakits/__init__.py

@@ -0,0 +1,45 @@
+from nonebot_plugin_marshoai.plugin import (
+    Integer,
+    Parameter,
+    PluginMetadata,
+    String,
+    on_function_call,
+)
+
+from . import mk_morse_code, mk_nya_code
+
+__marsho_meta__ = PluginMetadata(
+    name="MegaKits插件",
+    description="一个功能混杂的多文件插件",
+    author="Twisuki",
+)
+
+
+@on_function_call(description="摩尔斯电码加密").params(
+    msg=String(description="被加密语句")
+)
+async def morse_encrypt(msg: str) -> str:
+    """摩尔斯电码加密"""
+    return str(await mk_morse_code.morse_encrypt(msg))
+
+
+@on_function_call(description="摩尔斯电码解密").params(
+    msg=String(description="被解密语句")
+)
+async def morse_decrypt(msg: str) -> str:
+    """摩尔斯电码解密"""
+    return str(await mk_morse_code.morse_decrypt(msg))
+
+
+@on_function_call(description="转换为猫语").params(msg=String(description="被转换语句"))
+async def nya_encrypt(msg: str) -> str:
+    """转换为猫语"""
+    return str(await mk_nya_code.nya_encrypt(msg))
+
+
+@on_function_call(description="将猫语翻译回人类语言").params(
+    msg=String(description="被翻译语句")
+)
+async def nya_decrypt(msg: str) -> str:
+    """将猫语翻译回人类语言"""
+    return str(await mk_nya_code.nya_decrypt(msg))

nonebot_plugin_marshoai/plugins/twisuki_megakits/mk_morse_code.py

@@ -0,0 +1,82 @@
+# MorseCode
+MorseEncode = {
+    "A": ".-",
+    "B": "-...",
+    "C": "-.-.",
+    "D": "-..",
+    "E": ".",
+    "F": "..-.",
+    "G": "--.",
+    "H": "....",
+    "I": "..",
+    "J": ".---",
+    "K": "-.-",
+    "L": ".-..",
+    "M": "--",
+    "N": "-.",
+    "O": "---",
+    "P": ".--.",
+    "Q": "--.-",
+    "R": ".-.",
+    "S": "...",
+    "T": "-",
+    "U": "..-",
+    "V": "...-",
+    "W": ".--",
+    "X": "-..-",
+    "Y": "-.--",
+    "Z": "--..",
+    "1": ".----",
+    "2": "..---",
+    "3": "...--",
+    "4": "....-",
+    "5": ".....",
+    "6": "-....",
+    "7": "--...",
+    "8": "---..",
+    "9": "----.",
+    "0": "-----",
+    ".": ".-.-.-",
+    ":": "---...",
+    ",": "--..--",
+    ";": "-.-.-.",
+    "?": "..--..",
+    "=": "-...-",
+    "'": ".----.",
+    "/": "-..-.",
+    "!": "-.-.--",
+    "-": "-....-",
+    "_": "..--.-",
+    '"': ".-..-.",
+    "(": "-.--.",
+    ")": "-.--.-",
+    "$": "...-..-",
+    "&": "....",
+    "@": ".--.-.",
+    " ": " ",
+}
+MorseDecode = {value: key for key, value in MorseEncode.items()}
+
+
+async def morse_encrypt(msg: str):
+    result = ""
+    msg = msg.upper()
+    for char in msg:
+        if char in MorseEncode:
+            result += MorseEncode[char]
+        else:
+            result += "..--.."
+        result += " "
+    return result
+
+
+async def morse_decrypt(msg: str):
+    result = ""
+    msg = msg.replace("_", "-")
+    msg_arr = msg.split(" ")
+    for element in msg_arr:
+        if element in MorseDecode:
+            result += MorseDecode[element]
+        else:
+            result += "?"
+    return result

nonebot_plugin_marshoai/plugins/twisuki_megakits/mk_nya_code.py

@@ -0,0 +1,74 @@
+# NyaCode
+
+import base64
+import random
+
+NyaCodeCharset = ["喵", "呜", "?", "~"]
+NyaCodeSpecialCharset = ["唔", "!", "...", ".."]
+NyaCodeEncode = {}
+
+for i in range(64):
+    triplet = ""
+    for j in range(3):
+        index = (i // (4**j)) % 4
+        triplet += NyaCodeCharset[index]
+
+    if i < 26:
+        char = chr(65 + i)  # 大写字母 A-Z
+    elif i < 52:
+        char = chr(97 + (i - 26))  # 小写字母 a-z
+    elif i < 62:
+        char = chr(48 + (i - 52))  # 数字 0-9
+    elif i == 62:
+        char = chr(43)  # 特殊字符 +
+    else:
+        char = chr(47)  # 特殊字符 /
+    NyaCodeEncode[char] = triplet
+NyaCodeDecode = {value: key for key, value in NyaCodeEncode.items()}
+
+
+async def nya_encrypt(msg: str):
+    result = ""
+    b64str = base64.b64encode(msg.encode()).decode().replace("=", "")
+
+    nyastr = ""
+    for b64char in b64str:
+        nyastr += NyaCodeEncode[b64char]
+
+    for char in nyastr:
+        if char == "呜" and random.random() < 0.5:
+            result += "!"
+        if random.random() < 0.25:
+            result += random.choice(NyaCodeSpecialCharset) + char
+        else:
+            result += char
+    return result
+
+
+async def nya_decrypt(msg: str):
+    msg = msg.replace("唔", "").replace("!", "").replace(".", "")
+    nyastr = []
+
+    i = 0
+    if len(msg) % 3 != 0:
+        return "这句话不是正确的猫语"
+
+    while i < len(msg):
+        nyachar = msg[i : i + 3]
+        try:
+            if all(char in NyaCodeCharset for char in nyachar):
+                nyastr.append(nyachar)
+            i += 3
+        except Exception:
+            return "这句话不是正确的猫语"
+
+    b64str = ""
+    for nyachar in nyastr:
+        b64str += NyaCodeDecode[nyachar]
+    b64str += "=" * (4 - len(b64str) % 4)
+
+    try:
+        result = base64.b64decode(b64str.encode()).decode()
+    except Exception:
+        return "翻译失败"
+    return result

nonebot_plugin_marshoai/plugins/twisuki_petcat/__init__.py

@@ -0,0 +1,79 @@
+from nonebot_plugin_marshoai.plugin import (
+    Integer,
+    Parameter,
+    PluginMetadata,
+    String,
+    on_function_call,
+)
+
+from . import pc_cat, pc_info, pc_shop, pc_token
+
+__marsho_meta__ = PluginMetadata(
+    name="养猫插件",
+    description="在Marsho这里赛博养猫",
+    author="Twisuki",
+)
+
+
+# 交互
+@on_function_call(description="传入猫猫种类, 新建一只猫猫").params(
+    type=String(description='猫猫种类, 默认"猫1", 可留空')
+)
+async def cat_new(type: str) -> str:
+    """新建猫猫"""
+    return pc_cat.cat_new(type)
+
+
+@on_function_call(
+    description="传入token(一串长20的b64字符串), 新名字, 选用技能, 进行猫猫的初始化"
+).params(
+    token=String(description="token(一串长20的b64字符串)"),
+    name=String(description="新名字"),
+    skill=String(description="技能"),
+)
+async def cat_init(token: str, name: str, skill: str) -> str:
+    """初始化猫猫"""
+    return pc_cat.cat_init(token, name, skill)
+
+
+@on_function_call(description="传入token, 查看猫猫信息").params(
+    token=String(description="token(一串长20的b64字符串)"),
+)
+async def cat_show(token: str) -> str:
+    """查询信息"""
+    return pc_cat.cat_show(token)
+
+
+@on_function_call(description="传入token, 玩猫").params(
+    token=String(description="token(一串长20的b64字符串)"),
+)
+async def cat_play(token: str) -> str:
+    """玩猫"""
+    return pc_cat.cat_play(token)
+
+
+@on_function_call(description="传入token, 投喂猫猫").params(
+    token=String(description="token(一串长20的b64字符串)"),
+)
+async def cat_feed(token: str) -> str:
+    """喂猫"""
+    return pc_cat.cat_feed(token)
+
+
+# 帮助
+@on_function_call(description="帮助文档/如何创建一只猫猫").params()
+async def help_cat_new() -> str:
+    return pc_info.help_cat_new()
+
+
+@on_function_call(description="可选种类").params()
+async def help_cat_type() -> str:
+    return pc_info.print_type_list()
+
+
+@on_function_call(description="可选技能").params()
+async def help_cat_skill() -> str:
+    return pc_info.print_skill_list()
+
+
+# 商店

nonebot_plugin_marshoai/plugins/twisuki_petcat/pc_cat.py

@@ -0,0 +1,241 @@
+# 主交互
+import functools
+from datetime import datetime
+from typing import List
+
+from nonebot.log import logger
+
+from . import pc_info, pc_token
+from .pc_info import SKILL_LIST, TYPE_LIST, value_output
+from .pc_token import dict_to_token, token_to_dict
+
+"""特判标准
+1. 默认, 未初始化: name = Default0
+2. 错误: name = ERROR!
+3. 死亡: skill = [False] * 8
+"""
+
+
+# 私用列表
+DEFAULT_DICT = {
+    "name": "Default0",
+    "age": 0,
+    "type": 0,
+    "health": 0,
+    "saturation": 0,
+    "energy": 0,
+    "skill": [False] * 8,
+    "date": 0,
+}
+DEFAULT_TOKEN = "6IyszC6tjoYAAAAAAAAC"
+
+
+# 交互前数据更新
+def cat_update(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        if args:
+            token = args[0]
+
+            data = token_to_dict(token)
+
+            # 检查
+            if data["name"] == "Default0":
+                return "猫猫尚未初始化, 请初始化猫猫"
+
+            if data["name"] == "ERROR!":
+                return (
+                    "token出错"
+                    f'token应为Base64字符串, 当前token : "{token}"'
+                    f"当前token长度应为20, 当前长度 : {len(token)}"
+                )
+
+            if data["skill"] == [False] * 8:
+                return (
+                    "很不幸, 猫猫已死亡"
+                    f'名字 : {data["name"]}'
+                    f'年龄 : {data["age"]}'
+                )
+
+            date = data["date"]
+            now = (datetime(2025, 1, 1) - datetime.now()).days
+
+            # 喂食状态更新
+            if now - date > 5:
+                data["saturation"] = max(data["saturation"] - 64, 0)
+                data["health"] = max(data["health"] - 32, 0)
+                data["energy"] = max(data["energy"] - 32, 0)
+            elif now - date > 2:
+                data["saturation"] = max(data["saturation"] - 16, 0)
+                data["health"] = max(data["health"] - 8, 0)
+                data["energy"] = max(data["energy"] - 16, 0)
+
+            # 机能状态更新
+            if data["saturation"] / 1.27 < 20:
+                data["health"] = max(data["health"] - 8, 0)
+            elif data["saturation"] / 1.27 > 80:
+                data["health"] = min(data["health"] + 8, 127)
+
+            # 生长检查
+            if now % 7 == 0:
+                # 死亡
+                if data["health"] / 1.27 < 20:
+                    data["health"] = 0
+
+                    death = DEFAULT_DICT
+                    death["name"] = data["name"]
+                    data = death
+
+                # 生长
+                if data["health"] / 1.27 > 60 and data["saturation"] / 1.27 > 40:
+                    data["age"] = min(data["age"] + 1, 15)
+
+            token = dict_to_token(data)
+            new_args = (token,) + args[1:]
+            return func(*new_args, **kwargs)
+
+    return wrapper
+
+
+# 创建对象
+def cat_new(type: str = "猫1") -> str:
+    data = DEFAULT_DICT
+
+    if type not in TYPE_LIST:
+        return (
+            f'未知的"{type}"种类, 请重新选择.'
+            f"\n可选种类 : {pc_info.print_type_list()}"
+        )
+
+    data["type"] = TYPE_LIST.index(type)
+    token = dict_to_token(data)
+    return (
+        f'猫猫已创建, 种类为 : "{type}"; \ntoken : "{token}",'
+        f"\n请妥善保存token, 这是猫猫的唯一标识符!"
+        f"\n新的猫猫还没有起名字, 请对猫猫进行初始化, 起一个长度小于等于8位的名字(仅限大小写字母+数字+特殊符号), 并选取一个技能."
+        f"\n技能列表 : {pc_info.print_skill_list()}"
+    )
+
+
+# 初始化对象
+def cat_init(token: str, name: str, skill: str) -> str:
+    data = token_to_dict(token)
+    if data["name"] != "Default0":
+        logger.info("初始化失败!")
+        return "该猫猫已进行交互, 无法进行初始化!"
+
+    if skill not in SKILL_LIST:
+        return (
+            f'未知的"{skill}"技能, 请重新选择.'
+            f"技能列表 : {pc_info.print_skill_list()}"
+        )
+
+    data["name"] = name
+    data["skill"][SKILL_LIST.index(skill)] = True
+    data["health"] = 127
+    data["saturation"] = 127
+    data["energy"] = 127
+    token = dict_to_token(data)
+    return (
+        f'初始化完成, 名字 : "{data["name"]}", 种类 : "{data["type"]}", 技能 : "{skill}"'
+        f'\n新token : "{token}"'
+        f"\n请妥善保存token, 这是猫猫的唯一标识符!"
+    )
+
+
+# 查看信息
+@cat_update
+def cat_show(token: str) -> str:
+    result = pc_info.print_info(token)
+    data = token_to_dict(token)
+
+    if data["health"] / 1.27 < 20:
+        return result + "\n猫猫健康状况非常差! 甚至濒临死亡!! 请立即前往医院救治!!"
+
+    if data["health"] / 1.27 < 60:
+        result += "\n猫猫健康状况较差, 请投喂食物或陪猫猫玩耍"
+    if data["saturation"] / 1.27 < 40:
+        result += "\n猫猫很饿, 请投喂食物"
+    if data["energy"] / 1.27 < 20:
+        result += "\n猫猫很累, 请抱猫睡觉, 不要投喂食物或陪它玩耍"
+    return result
+
+
+# 陪猫猫玩耍
+@cat_update
+def cat_play(token: str) -> str:
+    data = token_to_dict(token)
+    if data["health"] / 1.27 < 20:
+        return "猫猫健康状况非常差! 甚至濒临死亡!! 请立即前往医院救治!!"
+
+    if data["saturation"] / 1.27 < 40:
+        return "猫猫很饿, 拒接玩耍请求."
+
+    if data["energy"] / 1.27 < 20:
+        return "猫猫很累, 拒接玩耍请求"
+
+    data["health"] = min(data["health"] + 16, 127)
+    data["saturation"] = max(data["saturation"] - 16, 0)
+    data["energy"] = max(data["energy"] - 8, 0)
+
+    token = dict_to_token(data)
+    return (
+        f'你陪猫猫玩耍了一个小时, 猫猫的生命值上涨到了{value_output(data["health"])}'
+        f'\n新token : "{token}"'
+        "\n请妥善保存token, 这是猫猫的唯一标识符!"
+    )
+
+
+# 喂食
+@cat_update
+def cat_feed(token: str) -> str:
+    data = token_to_dict(token)
+    if data["health"] / 1.27 < 20:
+        return "猫猫健康状况非常差! 甚至濒临死亡!! 请立即前往医院救治!!"
+
+    if data["saturation"] / 1.27 > 80:
+        return "猫猫并不饿, 不需要喂食"
+
+    if data["energy"] / 1.27 < 40:
+        return "猫猫很累, 请抱猫睡觉, 不要投喂食物或陪它玩耍"
+
+    data["saturation"] = min(data["saturation"] + 32, 127)
+    data["date"] = (datetime(2025, 1, 1) - datetime.now()).days
+
+    token = dict_to_token(data)
+    return (
+        f'你投喂了2单位标准猫粮, 猫猫的饱食度提升到了{value_output(data["saturation"])}'
+        f'\n新token : "{token}"'
+        "\n请妥善保存token, 这是猫猫的唯一标识符!"
+    )
+
+
+# 睡觉
+@cat_update
+def cat_sleep(token: str) -> str:
+    data = token_to_dict(token)
+    if data["health"] / 1.27 < 20:
+        return "猫猫健康状况非常差! 甚至濒临死亡!! 请立即前往医院救治!!"
+
+    if data["saturation"] / 1.27 < 40:
+        return "猫猫很饿, 请喂食."
+
+    if data["energy"] / 1.27 > 80:
+        return "猫猫很精神, 不需要睡觉"
+
+    data["health"] = min(data["health"] + 8, 127)
+    data["energy"] = min(data["energy"] + 16, 0)
+
+    token = dict_to_token(data)
+    return (
+        f'你抱猫休息了一阵子, 猫猫的活力值提升到了{value_output(data["energy"])}'
+        f'\n新token : "{token}"'
+        "\n请妥善保存token, 这是猫猫的唯一标识符!"
+    )
+
+
+"""饼
+    1. 商店系统
+    2. 技能系统
+    3. 提高复杂性和难度
+"""

nonebot_plugin_marshoai/plugins/twisuki_petcat/pc_info.py

@@ -0,0 +1,77 @@
+# 插件使用复杂, 这里用作输出提示信息.
+# 如: 帮助, 每次操作后对猫猫状态的描述\打印特殊列表
+# 公用列表数据转到这里存储
+
+
+from nonebot.log import logger
+
+from .pc_token import dict_to_token, token_to_dict
+
+# 公用列表
+TYPE_LIST = ["猫1", "猫2", "猫3", "猫4", "猫5", "猫6", "猫7", "猫8"]
+SKILL_LIST = ["s1", "s2", "s3", "s4", "s5", "s6", "s7", "s8"]
+
+
+# 提示词打印
+# 打印种类列表
+def print_type_list() -> str:
+    result = ""
+    for type in TYPE_LIST:
+        result += f'"{type}", '
+    result = result[:-2]
+    return f"({result})"
+
+
+# 打印技能列表
+def print_skill_list() -> str:
+    result = ""
+    for skill in SKILL_LIST:
+        result += f'"{skill}", '
+    result = result[:-2]
+    return f"({result})"
+
+
+# 127位值 - 100%快速转换
+def value_output(num: int) -> str:
+    value = int(num / 1.27)
+    return str(value)
+
+
+# 打印状态
+def print_info(token: str) -> str:
+    data = token_to_dict(token)
+    return (
+        "状态信息: "
+        f'\n\t名字 : {data["name"]}'
+        f'\n\t种类 : {TYPE_LIST[data["type"]]}'
+        f'\n\t生命值 : {value_output(data["health"])}'
+        f'\n\t饱食度 : {value_output(data["saturation"])}'
+        f"\n\t活力值 : {value_output(data['energy'])}"
+        f"\n\t技能 : {print_skill(token)}"
+        f"\n新token : {token}"
+        f"\ntoken已更新, 请妥善保存token, 这是猫猫的唯一标识符!"
+    )
+
+
+# 打印已有技能
+def print_skill(token: str) -> str:
+    result = ""
+    data = token_to_dict(token)
+    for index in range(0, len(SKILL_LIST) - 1):
+        if data["skill"][index]:
+            result += f"{SKILL_LIST[index]}, "
+    logger.info(data["skill"])
+    return result[:-2]
+
+
+# 帮助
+# 创建猫猫
+def help_cat_new() -> str:
+    return (
+        "新建一只猫猫, 首先选择猫猫的种类, 获取初始化token;"
+        "然后用这个token, 选择名字和一个技能进行初始化;"
+        "初始化结束才表示猫猫正式创建成功."
+        "\ntoken为猫的唯一标识符, 每次交互都需要传入token"
+        f"\n种类可选 : {print_type_list()}"
+        f"\n技能可选 : {print_skill_list()}"
+    )

nonebot_plugin_marshoai/plugins/twisuki_petcat/pc_shop.py

@@ -0,0 +1 @@
+# 商店

nonebot_plugin_marshoai/plugins/twisuki_petcat/pc_token.py

@@ -0,0 +1,200 @@
+# 由于无法直接存储数据, 使用一个字符串记录全部信息
+# 这里作为引用进行编码/解码, 以及公用数据
+
+"""猫对象属性存储编码Token
+名字: 3位长度 + 8位ASCII字符 - 67b
+年龄: 0 ~ 15 - 4b
+种类: 8种 - 3b
+生命值: 0 ~ 127 - 7b
+饱食度: 0 ~ 127 - 7b
+活力值: 0 ~ 127 - 7b
+技能: 8种任选 - 8b
+时间: 0 ~ 131017d > 2025-1-1 - 17b
+
+总计120b有效数据
+总计120b数据, 15字节, 每3字节(utf-8一个字符)转换为4个Base64字符
+总计20个Base64字符的字符串
+"""
+
+"""定义变量
+存储字符串: Token: str
+对象数据: data: dict
+名字: name: str
+年龄: age: int
+种类: type: int   # 代表TYPE_LIST中的序号
+生命值: health: int    # 0 - 127, 显示时转换为100%
+饱食度: saturation: int    # 0 - 127, 显示时转换为100%
+活力值: energy: int    # 0 - 127, 显示时转换为100%
+技能: skill: List[bool]   # 8元素bool数组
+时间: date: int   # 到2025-1-1按日的时间戳
+"""
+
+import base64
+from datetime import datetime
+from typing import List
+
+from nonebot.log import logger
+
+# 私用列表
+ERROR_DICT = {
+    "name": "ERROR!",
+    "age": 0,
+    "type": 0,
+    "health": 0,
+    "saturation": 0,
+    "energy": 0,
+    "skill": [False, False, False, False, False, False, False, False],
+    "date": 0,
+}
+ERROR_TOKEN = "yKpKSepEIAAAAAAAAAAA"
+
+
+# bool数组/int数据转换
+def bool_to_int(bool_array: List[bool]) -> int:
+    result = 0
+    for index, bit in enumerate(bool_array[::-1]):
+        if bit:
+            result |= 1 << index
+    return result
+
+
+def int_to_bool(integer: int, length: int = 0) -> List[bool]:
+    bit_length = integer.bit_length()
+    bool_array = [False] * bit_length
+    for i in range(bit_length):
+        if integer & (1 << i):
+            bool_array[bit_length - 1 - i] = True
+    if len(bool_array) >= length:
+        return bool_array
+    else:
+        return [*([False] * (length - len(bool_array))), *bool_array]
+
+
+# bool数组/byte数据转换
+def bool_to_byte(bool_array: List[bool]) -> bytes:
+    byte_data = bytearray()
+    for i in range(0, len(bool_array), 8):
+        byte = 0
+        for j in range(8):
+            if i + j < len(bool_array) and bool_array[i + j]:
+                byte |= 1 << (7 - j)
+        byte_data.append(byte)
+    return bytes(byte_data)
+
+
+def byte_to_bool(byte_data: bytes, length: int = 0) -> List[bool]:
+    bool_array = []
+    for byte in byte_data:
+        for bit in format(byte, "08b"):
+            bool_array.append(bit == "1")
+    if len(bool_array) >= length:
+        return bool_array
+    else:
+        return [*([False] * (length - len(bool_array))), *bool_array]
+
+
+# 数据解码
+def token_to_dict(token: str) -> dict:
+    logger.info(f"开始解码...\n{token}")
+
+    data = {
+        "name": "Default0",
+        "age": 0,
+        "type": 0,
+        "health": 0,
+        "saturation": 0,
+        "energy": 0,
+        "skill": [False] * 8,
+        "date": 0,
+    }
+
+    # 转换token
+    try:
+        token_byte = base64.b64decode(token.encode())
+        code = byte_to_bool(token_byte)
+    except ValueError:
+        logger.error("token b64解码错误!")
+        return ERROR_DICT
+
+    # 拆分code
+    name_length = bool_to_int(code[0:3]) + 1
+    name_code = code[3:67]
+    age = bool_to_int(code[67:71])
+    type = bool_to_int(code[71:74])
+    health = bool_to_int(code[74:81])
+    saturation = bool_to_int(code[81:88])
+    energy = bool_to_int(code[88:95])
+    skill = code[95:103]
+    date = bool_to_int(code[103:120])
+
+    # 解析code
+    name: str = ""
+    try:
+        for i in range(name_length):
+            character_code = bool_to_byte(name_code[8 * i : 8 * i + 8])
+            name += character_code.decode("ASCII")
+    except UnicodeDecodeError:
+        logger.error("token ASCII解析错误!")
+        return ERROR_DICT
+
+    data["name"] = name
+    data["age"] = age
+    data["type"] = type
+    data["health"] = health
+    data["saturation"] = saturation
+    data["energy"] = energy
+    data["skill"] = skill
+    data["date"] = date
+
+    logger.success(f"解码完成, 数据为\n{data}")
+    return data
+
+
+# 数据编码
+def dict_to_token(data: dict) -> str:
+    logger.info(f"开始编码...\n{data}")
+
+    code = [False] * 120
+
+    # 拆分data
+    name_length = len(data["name"])
+    if name_length > 8:
+        logger.error("name过长")
+        return ERROR_TOKEN
+
+    name = data["name"]
+    age = data["age"]
+    type = data["type"]
+    health = data["health"]
+    saturation = data["saturation"]
+    energy = data["energy"]
+    skill = data["skill"]
+    date = data["date"]
+
+    # 填入code
+    code[0:3] = int_to_bool(name_length - 1, 3)
+    name_code = [False] * 64
+    try:
+        for i in range(name_length):
+            character_code = byte_to_bool(name[i].encode("ASCII"), 8)
+            name_code[8 * i : 8 * i + 8] = character_code
+    except UnicodeEncodeError:
+        # "name": "ERROR!"
+        logger.error("name内含有非法字符!")
+        return ERROR_TOKEN
+
+    code[3:67] = name_code
+    code[67:71] = int_to_bool(age, 4)
+    code[71:74] = int_to_bool(type, 3)
+    code[74:81] = int_to_bool(health, 7)
+    code[81:88] = int_to_bool(saturation, 7)
+    code[88:95] = int_to_bool(energy, 7)
+    code[95:103] = skill
+    code[103:120] = int_to_bool(date, 17)
+
+    # 转换token
+    token_byte = bool_to_byte(code)
+    token = base64.b64encode(token_byte).decode()
+
+    logger.success(f"编码完成, token为\n{token}")
+    return token

nonebot_plugin_marshoai/plugins_test/marshoai_basic/__init__.py

@@ -1,8 +1,16 @@
 import os
 
-from zhDateTime import DateTime
+from zhDateTime import DateTime  # type: ignore
 
-from nonebot_plugin_marshoai.plugin import String, on_function_call
+from nonebot_plugin_marshoai.plugin import PluginMetadata, String, on_function_call
+
+# from .web import *
+# 定义插件元数据
+__marsho_meta__ = PluginMetadata(
+    name="基本功能",
+    author="MarshoAI",
+    description="这个插件提供基本的功能，比如获取当前时间和日期。",
+)
 
 
 @on_function_call(description="获取当前时间，日期和星期")

nonebot_plugin_marshoai/plugins_test/marshoai_memory/__init__.py

@@ -0,0 +1,97 @@
+import json
+from pathlib import Path
+
+from azure.ai.inference.models import UserMessage
+from nonebot import get_driver, logger, require
+from nonebot_plugin_localstore import get_plugin_data_file
+
+require("nonebot_plugin_apscheduler")
+require("nonebot_plugin_marshoai")
+from nonebot_plugin_apscheduler import scheduler
+
+from nonebot_plugin_marshoai.instances import client
+from nonebot_plugin_marshoai.plugin import PluginMetadata, on_function_call
+from nonebot_plugin_marshoai.plugin.func_call.params import String
+
+from .command import *
+from .config import plugin_config
+
+__marsho_meta__ = PluginMetadata(
+    name="记忆保存",
+    author="MarshoAI",
+    description="这个插件可以帮助AI记住一些事情",
+)
+
+memory_path = get_plugin_data_file("memory.json")
+if not Path(memory_path).exists():
+    with open(memory_path, "w", encoding="utf-8") as f:
+        json.dump({}, f, ensure_ascii=False, indent=4)
+# print(memory_path)
+driver = get_driver()
+
+
+@on_function_call(
+    description="当你发现与你对话的用户的一些信息值得你记忆，或者用户让你记忆等时，调用此函数存储记忆内容"
+).params(
+    memory=String(description="你想记住的内容，概括并保留关键内容"),
+    user_id=String(description="你想记住的人的id"),
+)
+async def write_memory(memory: str, user_id: str):
+
+    with open(memory_path, "r", encoding="utf-8") as f:
+        memory_data = json.load(f)
+
+    memorys = memory_data.get(user_id, [])
+    memorys.append(memory)
+    memory_data[user_id] = memorys
+
+    with open(memory_path, "w", encoding="utf-8") as f:
+        json.dump(memory_data, f, ensure_ascii=False, indent=4)
+
+    return "记忆已经保存啦~"
+
+
+@on_function_call(
+    description="你需要回忆有关用户的一些知识时，调用此函数读取记忆内容，当用户问问题的时候也尽量调用此函数参考"
+).params(user_id=String(description="你想读取记忆的人的id"))
+async def read_memory(user_id: str):
+    with open(memory_path, "r", encoding="utf-8") as f:
+        memory_data = json.load(f)
+    memorys = memory_data.get(user_id, [])
+    if not memorys:
+        return "好像对ta还没有任何记忆呢~"
+
+    return "这些是有关ta的记忆：" + "\n".join(memorys)
+
+
+async def organize_memories():
+    with open(memory_path, "r", encoding="utf-8") as f:
+        memory_data = json.load(f)
+    for i in memory_data:
+        memory_data_ = "\n".join(memory_data[i])
+        msg = f"这是一些大模型记忆信息，请你保留重要内容，尽量减少无用的记忆后重新输出记忆内容，浓缩为一行：\n{memory_data_}"
+        res = await client.complete(UserMessage(content=msg))
+        try:
+            memory = res.choices[0].message.content  # type: ignore
+            memory_data[i] = memory
+        except AttributeError:
+            logger.error(f"整理关于{i}的记忆时出错：{res}")
+
+    with open(memory_path, "w", encoding="utf-8") as f:
+        json.dump(memory_data, f, ensure_ascii=False, indent=4)
+
+
+if plugin_config.marshoai_plugin_memory_scheduler:
+
+    @driver.on_startup
+    async def _():
+        logger.info("小棉定时记忆整理已启动！")
+        scheduler.add_job(
+            organize_memories,
+            "cron",
+            hour="0",
+            minute="0",
+            second="0",
+            day="*",
+            id="organize_memories",
+        )

nonebot_plugin_marshoai/plugins_test/marshoai_memory/command.py

@@ -0,0 +1,47 @@
+import json
+
+from arclet.alconna import Alconna, Args, Subcommand
+from nonebot import logger
+from nonebot.adapters import Bot, Event
+from nonebot.matcher import Matcher
+from nonebot.typing import T_State
+from nonebot_plugin_alconna import on_alconna
+from nonebot_plugin_localstore import get_plugin_data_file
+
+from nonebot_plugin_marshoai.config import config
+
+marsho_memory_cmd = on_alconna(
+    Alconna(
+        f"{config.marshoai_default_name}.memory",
+        Subcommand("view", alias={"v"}),
+        Subcommand("reset", alias={"r"}),
+    ),
+    priority=10,
+    block=True,
+)
+
+memory_path = get_plugin_data_file("memory.json")
+
+
+@marsho_memory_cmd.assign("view")
+async def view_memory(matcher: Matcher, state: T_State, event: Event):
+    user_id = str(event.get_user_id())
+    with open(memory_path, "r", encoding="utf-8") as f:
+        memory_data = json.load(f)
+    memorys = memory_data.get(user_id, [])
+    if not memorys:
+        await matcher.finish("好像对ta还没有任何记忆呢~")
+    await matcher.finish("这些是有关ta的记忆：" + "\n".join(memorys))
+
+
+@marsho_memory_cmd.assign("reset")
+async def reset_memory(matcher: Matcher, state: T_State, event: Event):
+    user_id = str(event.get_user_id())
+    with open(memory_path, "r", encoding="utf-8") as f:
+        memory_data = json.load(f)
+    if user_id in memory_data:
+        del memory_data[user_id]
+        with open(memory_path, "w", encoding="utf-8") as f:
+            json.dump(memory_data, f, ensure_ascii=False, indent=4)
+        await matcher.finish("记忆已重置~")
+    await matcher.finish("没有找到该用户的记忆~")

nonebot_plugin_marshoai/plugins_test/marshoai_memory/config.py

@@ -0,0 +1,9 @@
+from nonebot import get_plugin_config, logger
+from pydantic import BaseModel
+
+
+class ConfigModel(BaseModel):
+    marshoai_plugin_memory_scheduler: bool = True
+
+
+plugin_config: ConfigModel = get_plugin_config(ConfigModel)

nonebot_plugin_marshoai/plugins_test/marshoai_memory/tools.json

@@ -0,0 +1,17 @@
+[
+    {
+        "type": "function",
+        "function": {
+            "name": "marshoai_memory__write_memory",
+            "description": "如果在上下中你看见并觉得应该记住的人的行为与事件，请调用这个函数，并将记忆内容写入。请尽量每次都调用，总结ta的习惯、爱好和性格,以及你对ta的印象和ta对你的印象;比如用户喜欢干什么吃什么。"
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "marshoai_memory__read_memory",
+            "description": "每当你想要获取更多有关某人的信息的时候，请调用这个函数。"
+        }
+    }
+]
+

nonebot_plugin_marshoai/tools/marshoai_memory/__init__.py

@@ -0,0 +1,47 @@
+from pathlib import Path
+
+from nonebot import require
+
+require("nonebot_plugin_localstore")
+import json
+
+from nonebot_plugin_localstore import get_data_file
+
+memory_path = get_data_file("marshoai", "memory.json")
+if not Path(memory_path).exists():
+    with open(memory_path, "w", encoding="utf-8") as f:
+        json.dump({}, f, ensure_ascii=False, indent=4)
+print(memory_path)
+
+
+async def write_memory(memory: str, user_id: str):
+
+    with open(memory_path, "r", encoding="utf-8") as f:
+        memory_data = json.load(f)
+
+    memorys = memory_data.get(user_id, [])
+    memorys.append(memory)
+    memory_data[user_id] = memorys
+
+    with open(memory_path, "w", encoding="utf-8") as f:
+        json.dump(memory_data, f, ensure_ascii=False, indent=4)
+
+    return "记忆已经保存啦~"
+
+
+async def read_memory(user_id: str):
+    with open(memory_path, "r", encoding="utf-8") as f:
+        memory_data = json.load(f)
+    memorys = memory_data.get(user_id, [])
+    if not memorys:
+        return "好像对ta还没有任何记忆呢~"
+
+    return "这些是有关ta的记忆：" + "\n".join(memorys)
+
+
+async def organize_memories():
+    with open(memory_path, "r", encoding="utf-8") as f:
+        memory_data = json.load(f)
+    for i in memory_data:
+        ...
+        # TODO 用大模型对记忆进行整理

nonebot_plugin_marshoai/tools/marshoai_memory/tools.json

@@ -0,0 +1,46 @@
+[
+    {
+        "type": "function",
+        "function": {
+            "name": "marshoai_memory__write_memory",
+            "description": "如果在上下中你看见并觉得应该记住的人的行为与事件，请调用这个函数，并将记忆内容写入。请尽量每次都调用，总结ta的习惯、爱好和性格,以及你对ta的印象和ta对你的印象",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "memory": {
+                        "type": "string",
+                        "description": "你想记住的内容，概括并保留关键内容。"
+                    },
+                    "user_id": {
+                        "type": "string",
+                        "description": "你想记住的人的id。"
+                    }
+                }
+            },
+            "required": [
+                "memory",
+                "user_id"
+            ]
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "marshoai_memory__read_memory",
+            "description": "每当你想要获取更多有关某人的信息的时候，请调用这个函数。",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "user_id": {
+                        "type": "string",
+                        "description": "你想获取的人的id。"
+                    }
+                }
+            },
+            "required": [
+                "user_id"
+            ]
+        }
+    }
+]
+

nonebot_plugin_marshoai/tools_wip/marshoai_memory/__init__.py

@@ -1,2 +0,0 @@
-async def write_memory(memory: str):
-    return ""

nonebot_plugin_marshoai/tools_wip/marshoai_memory/tools.json

@@ -1,21 +0,0 @@
-[
-    {
-        "type": "function",
-        "function": {
-            "name": "marshoai_memory__write_memory",
-            "description": "当你想记住有关与你对话的人的一些信息的时候，调用此函数。",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "memory": {
-                        "type": "string",
-                        "description": "你想记住的内容，概括并保留关键内容。"
-                    }
-                }
-            },
-            "required": [
-                "memory"
-            ]
-        }
-    }
-]

nonebot_plugin_marshoai/util.py

@@ -16,6 +16,8 @@ from nonebot.log import logger
 from nonebot_plugin_alconna import Image as ImageMsg
 from nonebot_plugin_alconna import Text as TextMsg
 from nonebot_plugin_alconna import UniMessage
+from openai import AsyncOpenAI
+from zhDateTime import DateTime
 
 from .config import config
 from .constants import *
@@ -27,7 +29,7 @@ loaded_target_list = []  # 记录已恢复备份的上下文的列表
 
 # noinspection LongLine
 chromium_headers = {
-    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:134.0) Gecko/20100101 Firefox/134.0"
 }
 
 
@@ -90,7 +92,8 @@ async def make_chat(
     参数:
         client: 用于与AI模型进行通信
         msg: 消息内容
-        model_name: 指定AI模型名"""
+        model_name: 指定AI模型名
+        tools: 工具列表"""
     return await client.complete(
         messages=msg,
         model=model_name,
@@ -101,6 +104,29 @@ async def make_chat(
     )
 
 
+async def make_chat_openai(
+    client: AsyncOpenAI,
+    msg: list,
+    model_name: str,
+    tools: Optional[list] = None,
+):
+    """使用 Openai SDK 调用ai获取回复
+
+    参数:
+        client: 用于与AI模型进行通信
+        msg: 消息内容
+        model_name: 指定AI模型名
+        tools: 工具列表"""
+    return await client.chat.completions.create(
+        messages=msg,
+        model=model_name,
+        tools=tools,
+        temperature=config.marshoai_temperature,
+        max_tokens=config.marshoai_max_tokens,
+        top_p=config.marshoai_top_p,
+    )
+
+
 def get_praises():
     global praises_json
     if praises_json is None:
@@ -220,6 +246,13 @@ def get_prompt():
     if config.marshoai_enable_praises:
         praises_prompt = build_praises()
         prompts += praises_prompt
+    if config.marshoai_enable_time_prompt:
+        current_time = DateTime.now().strftime("%Y.%m.%d %H:%M:%S")
+        current_lunar_date = (
+            DateTime.now().to_lunar().date_hanzify()[5:]
+        )  # 库更新之前使用切片
+        time_prompt = f"现在的时间是{current_time}，农历{current_lunar_date}。"
+        prompts += time_prompt
     marsho_prompt = config.marshoai_prompt
     spell = SystemMessage(content=marsho_prompt + prompts).as_dict()
     return spell

package.json

@@ -1,15 +1,10 @@
 {
-  "type": "module",
+    "type": "module",
-  "devDependencies": {
+    "devDependencies": {"vitepress": "^1.5.0", "vitepress-sidebar": "^1.30.2"},
-    "vitepress": "^1.5.0",
+    "scripts": {
-    "vitepress-sidebar": "^1.30.2"
+        "docs:dev": "vitepress dev docs --host",
-  },
+        "docs:build": "vitepress build docs",
-  "scripts": {
+        "docs:preview": "vitepress preview docs"
-    "docs:dev": "vitepress dev docs --host",
+    },
-    "docs:build": "vitepress build docs",
+    "dependencies": {"vue": "^3.5.13"}
-    "docs:preview": "vitepress preview docs"
+}
-  },
-  "dependencies": {
-    "vue": "^3.5.13"
-  }
-}

pyproject.toml

@@ -9,7 +9,7 @@ authors = [
     { name="LiteyukiStudio", email = "support@liteyuki.icu"}
 ]
 dependencies = [
-    "nonebot2>=2.2.0",
+    "nonebot2>=2.4.0",
     "nonebot-plugin-alconna>=0.48.0",
     "nonebot-plugin-localstore>=0.7.1",
     "zhDatetime>=1.1.1",
@@ -26,7 +26,9 @@ dependencies = [
     "aiofiles>=24.1.0",
     "sumy>=0.11.0",
     "azure-ai-inference>=1.0.0b6",
-    "watchdog>=6.0.0"
+    "watchdog>=6.0.0",
+    "nonebot-plugin-apscheduler>=0.5.0",
+    "openai>=1.58.1"
 
 ]
 license = { text = "MIT, Mulan PSL v2" }
@@ -76,3 +78,6 @@ dev = [
 test = [
     "nonebug>=0.4.3",
 ]
+
+[tool.ruff.lint]
+ignore = ["E402"]