feat: plugin dev mode

fix: 修复发言频率限制报错的问题

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+SoulterL@outlook.com.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

README.md

@@ -1,23 +1,41 @@
-## ⭐体验
+<div align="center">
 
-使用手机QQ扫码加入QQ频道(频道名: GPT机器人 | 频道号: x42d56aki2)
+<img src="https://socialify.git.ci/Soulter/QQChannelChatGPT/image?description=1&forks=1&issues=1&language=1&name=1&owner=1&pattern=Circuit%20Board&stargazers=1&theme=Light" alt="QQChannelChatGPT" width="600" height="300" />
 
-<img src="https://user-images.githubusercontent.com/37870767/227197121-4f1e02a4-92fd-4497-8768-9d6977a291b7.jpg" width="200"></img>
+[![Language](https://img.shields.io/badge/language-python-green.svg?style=plastic)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-AGPL3-orange.svg?style=plastic)](https://github.com/Soulter/QQChannelChatGPT/blob/master/LICENSE)
+![Python](https://img.shields.io/badge/python-3.9+-blue)
+ 
+_✨在QQ和QQ频道上使用ChatGPT、NewBing等语言模型，稳定，一次部署，同时使用✨_
 
-**Windows用户推荐Windows一键安装，请前往Release下载最新版本**
+_✨教程：https://github.com/Soulter/QQChannelChatGPT/wiki ✨_
+ 
+_✨插件开发教程：https://github.com/Soulter/QQChannelChatGPT/wiki/%E5%9B%9B%E3%80%81%E5%BC%80%E5%8F%91%E6%8F%92%E4%BB%B6 ✨_
 
-详细部署教程链接：https://soulter.top/posts/qpdg.html
+_✨欢迎体验😊（频道名: GPT机器人 | 频道号: x42d56aki2) | QQ群号：322154837）✨_
 
-有网络问题报错的请先看issue，解决不了再加频道反馈
+<!-- <img src="https://user-images.githubusercontent.com/37870767/230417115-9dd3c9d5-6b6b-4928-8fe3-82f559208aab.JPG" width="300"></img> -->
+
+</div>
 
 ## ⭐功能：
 
+近期新功能：
+- 支持插件！https://github.com/Soulter/QQChannelChatGPT/wiki/%E5%9B%9B%E3%80%81%E5%BC%80%E5%8F%91%E6%8F%92%E4%BB%B6
+- 支持一键切换语言模型（使用/bing /revgpt /gpt分别可以切换newbing、逆向ChatGPT、官方ChatGPT模型）
+- 热更新
+- 接入QQ，支持在QQ上和QQ频道上同时聊天！https://github.com/Soulter/QQChannelChatGPT/issues/82
+- 更强大的Windows启动器，环境配置自动搞定。链接：https://github.com/Soulter/QQChatGPTLauncher/releases/latest
+
+支持的AI语言模型（请在`configs/config.yaml`下配置）：
 - 逆向ChatGPT库
 - 官方ChatGPT AI
-- 文心一言（即将支持，链接https://github.com/Soulter/ERNIEBot 欢迎Star）
+- 文心一言（即将支持）
 - NewBing
 - Bard （即将支持）
 
+部署此项目的教程链接：https://github.com/Soulter/QQChannelChatGPT/wiki
+
 ### 基本功能
 <details> 
  <summary>✅ 回复符合上下文</summary>
@@ -75,8 +93,22 @@
 </details>
 
 > 关于token：token就相当于是AI中的单词数（但是不等于单词数），`text-davinci-003`模型中最大可以支持`4097`个token。在发送信息时，这个机器人会将用户的历史聊天记录打包发送给ChatGPT，因此，`token`也会相应的累加，为了保证聊天的上下文的逻辑性，就有了缓存token。
+
+### 🛠️ 插件支持
+
+本项目支持接入插件。
+
+插件开发教程：https://github.com/Soulter/QQChannelChatGPT/wiki/%E5%9B%9B%E3%80%81%E5%BC%80%E5%8F%91%E6%8F%92%E4%BB%B6
+
+部分好用的插件：
+
+`HuggingChat`: https://github.com/Soulter/HuggingChatForQQBot
+
+
 ### 指令功能
-需要先`@`机器人之后再输入指令
+
+#### OpenAI官方API
+在频道内需要先`@`机器人之后再输入指令；在QQ中暂时需要在消息前加上`ai `，不需要@
 - `/reset`重置prompt
 - `/his`查看历史记录（每个用户都有独立的会话）
 - `/his [页码数]`查看不同页码的历史记录。例如`/his 2`查看第2页
@@ -86,33 +118,194 @@
 - `/help` 查看帮助
 - `/key` 动态添加key
 - `/set` 人格设置面板
+- `/keyword nihao 你好` 设置关键词回复。nihao->你好
+- `/bing` 切换为bing
+- `/revgpt` 切换为ChatGPT逆向库
+- `/画` 画画
+
+#### Bing语言模型
+- `/reset`重置prompt
+- `/gpt` 切换为OpenAI官方API
+- `/revgpt` 切换为ChatGPT逆向库
+
+#### 逆向ChatGPT库语言模型
+- `/gpt` 切换为OpenAI官方API
+- `/bing` 切换为bing
+
+* 切换模型指令支持临时回复。如`/bing 你好`将会临时使用一次bing模型
 
 ## 📰使用方法：
 
 **详细部署教程链接**https://soulter.top/posts/qpdg.html
 
-### 安装第三方库
+**Windows用户推荐Windows一键安装，请前往Release下载最新版本（Beta）**
+有报错请先看issue，解决不了再在频道内反馈。
 
-使用Python的pip工具安装
-- `qq-botpy` （QQ频道官方Python SDK）
-- `openai` (OpenAI Python SDK)
+### 安装第三方库
 
 ```shell
 pip install -r requirements.txt
 ```
-> ⚠注意，由于qq-botpy库需要运行在`Python 3.8+`的版本上，因此本项目也需要在此之上运行
+> ⚠Python版本应>=3.9
+
 
 ### 配置
 
-- 获得 OpenAI的key [OpenAI](https://beta.openai.com/)
-- 获得 QQ开放平台下QQ频道机器人的token和appid [QQ开放平台](https://q.qq.com/)，一个QQ频道机器人（很容易创建~）
-- 在configs/config.yaml下进行配置
+**详细部署教程链接**https://github.com/Soulter/QQChannelChatGPT/wiki
 
 ### 启动
 - 启动main.py
 
 
-## DEMO
-![1.jpg](screenshots/1.jpg)
-![3.jpg](screenshots/3.jpg)
-![2.jpg](screenshots/2.jpg)
+## 感谢
+本项目使用了一下项目:
+
+[ChatGPT by acheong08](https://github.com/acheong08/ChatGPT)
+
+[EdgeGPT by acheong08](https://github.com/acheong08/EdgeGPT)
+
+[go-cqhttp by Mrs4s](https://github.com/Mrs4s/go-cqhttp)
+
+[nakuru-project by Lxns-Network](https://github.com/Lxns-Network/nakuru-project)
+
+
+## ⚙配置文件说明：
+```yaml
+# 如果你不知道怎么部署，请查看https://github.com/Soulter/QQChannelChatGPT/wiki
+# 不一定需要key了，如果你没有key但有openAI账号或者必应账号，可以考虑使用下面的逆向库
+
+
+###############平台设置#################
+
+# QQ频道机器人
+# QQ开放平台的appid和令牌
+# q.qq.com
+# enable为true则启用，false则不启用
+qqbot:
+  enable: true
+  appid: 
+  token: 
+
+# QQ机器人
+# enable为true则启用，false则不启用
+# 需要安装GO-CQHTTP配合使用。
+# 文档：https://docs.go-cqhttp.org/
+# 请将go-cqhttp的配置文件的sever部分粘贴为以下内容，否则无法使用
+# 请先启动go-cqhttp再启动本程序
+# 
+# servers:
+#   - http:
+#       host: 127.0.0.1
+#       version: 0
+#       port: 5700
+#       timeout: 5
+#   - ws:
+#       address: 127.0.0.1:6700
+#       middlewares:
+#         <<: *default
+gocqbot:
+  enable: false
+
+# 设置是否一个人一个会话
+uniqueSessionMode: false
+# QChannelBot 的版本，请勿修改此字段，否则可能产生一些bug
+version: 3.0
+# [Beta] 转储历史记录时间间隔(分钟)
+dump_history_interval: 10
+# 一个用户只能在time秒内发送count条消息
+limit:
+  time: 60
+  count: 5
+# 公告
+notice: "此机器人由Github项目QQChannelChatGPT驱动。"
+# 是否打开私信功能
+# 设置为true则频道成员可以私聊机器人。
+# 设置为false则频道成员不能私聊机器人。
+direct_message_mode: true
+
+# 系统代理
+# http_proxy: http://localhost:7890
+# https_proxy: http://localhost:7890
+
+# 自定义回复前缀，如[Rev]或其他，务必加引号以防止不必要的bug。
+reply_prefix:
+  openai_official: "[GPT]"
+  rev_chatgpt: "[Rev]"
+  rev_edgegpt: "[RevBing]"
+
+# 百度内容审核服务
+# 新用户免费5万次调用。https://cloud.baidu.com/doc/ANTIPORN/index.html
+baidu_aip:
+  enable: false
+  app_id: 
+  api_key: 
+  secret_key: 
+
+
+
+
+###############语言模型设置#################
+
+
+# OpenAI官方API
+# 注意：已支持多key自动切换，方法：
+# key:
+#   - sk-xxxxxx
+#   - sk-xxxxxx
+# 在下方非注释的地方使用以上格式
+# 关于api_base：可以使用一些云函数（如腾讯、阿里）来避免国内被墙的问题。
+# 详见：
+# https://github.com/Ice-Hazymoon/openai-scf-proxy
+# https://github.com/Soulter/QQChannelChatGPT/issues/42
+# 设置为none则表示使用官方默认api地址
+openai:
+  key: 
+    - 
+  api_base: none
+  # 这里是GPT配置，语言模型默认使用gpt-3.5-turbo
+  chatGPTConfigs:
+    model: gpt-3.5-turbo
+    max_tokens: 3000
+    temperature: 0.9
+    top_p: 1
+    frequency_penalty: 0
+    presence_penalty: 0
+    
+  total_tokens_limit: 5000
+
+# 逆向文心一言【暂时不可用，请勿使用】
+rev_ernie:
+  enable: false
+
+# 逆向New Bing
+# 需要在项目根目录下创建cookies.json并粘贴cookies进去。
+# 详见：https://soulter.top/posts/qpdg.html
+rev_edgegpt:
+  enable: false
+
+# 逆向ChatGPT库
+# https://github.com/acheong08/ChatGPT
+# 优点：免费（无免费额度限制）；
+# 缺点：速度相对慢。OpenAI 速率限制：免费帐户每小时 50 个请求。您可以通过多帐户循环来绕过它
+# enable设置为true后，将会停止使用上面正常的官方API调用而使用本逆向项目
+#
+# 多账户可以保证每个请求都能得到及时的回复。
+# 关于account的格式
+# account:
+#   - email: 第1个账户
+#     password: 第1个账户密码
+#   - email: 第2个账户
+#     password: 第2个账户密码
+#   - ....
+# 支持使用access_token登录
+# 例：
+# - session_token: xxxxx
+# - access_token: xxxx
+# 请严格按照上面这个格式填写。
+# 逆向ChatGPT库的email-password登录方式不工作，建议使用access_token登录
+# 获取access_token的方法，详见：https://soulter.top/posts/qpdg.html
+rev_ChatGPT:
+  enable: false
+  account:
+    - access_token: 
+```

addons/plugins/helloworld/README.md

@@ -0,0 +1,5 @@
+# helloworld
+
+QQChannelChatGPT项目的测试插件
+
+A test plugin for QQChannelChatGPT plugin feature

addons/plugins/helloworld/helloworld.py

@@ -0,0 +1,65 @@
+from nakuru.entities.components import *
+from nakuru import (
+    GroupMessage,
+    FriendMessage
+)
+from botpy.message import Message, DirectMessage
+
+class HelloWorldPlugin:
+    """
+    初始化函数, 可以选择直接pass
+    """
+    def __init__(self) -> None:
+        print("这是HelloWorld测试插件, 发送 helloworld 即可触发此插件。")
+
+    """
+    入口函数，机器人会调用此函数。
+    参数规范: message: 消息文本; role: 身份; platform: 消息平台; message_obj: 消息对象
+    参数详情: role为admin或者member; platform为qqchan或者gocq; message_obj为nakuru的GroupMessage对象或者FriendMessage对象或者频道的Message, DirectMessage对象。
+    返回规范: bool: 是否hit到此插件(所有的消息均会调用每一个载入的插件, 如果没有hit到, 则应返回False)
+             Tuple: None或者长度为3的元组。当没有hit到时, 返回None. hit到时, 第1个参数为指令是否调用成功, 第2个参数为返回的消息文本或者gocq的消息链列表, 第3个参数为指令名称
+    例子：做一个名为"yuanshen"的插件；当接收到消息为“原神 可莉”, 如果不想要处理此消息，则返回False, None；如果想要处理，但是执行失败了，返回True, tuple([False, "请求失败啦~", "yuanshen"])
+          ；执行成功了，返回True, tuple([True, "结果文本", "yuanshen"])
+    """
+    def run(self, message: str, role: str, platform: str, message_obj):
+
+        if platform == "gocq":
+            """
+            QQ平台指令处理逻辑
+            """
+            img_url = "https://gchat.qpic.cn/gchatpic_new/905617992/720871955-2246763964-C6EE1A52CC668EC982453065C4FA8747/0?term=2&is_origin=0"
+            if message == "helloworld":
+                return True, tuple([True, [Plain("Hello World!!"), Image.fromURL(url=img_url)], "helloworld"])
+            else:
+                return False, None
+        elif platform == "qqchan":
+            """
+            频道处理逻辑(频道暂时只支持回复字符串类型的信息，返回的信息都会被转成字符串，如果不想处理某一个平台的信息，直接返回False, None就行)
+            """
+            if message == "helloworld":
+                return True, tuple([True, "Hello World!!", "helloworld"])
+            else:
+                return False, None
+    """
+    帮助函数，当用户输入 plugin v 插件名称 时，会调用此函数，返回帮助信息
+    返回参数要求(必填)：dict{
+        "name": str, # 插件名称
+        "desc": str, # 插件简短描述
+        "help": str, # 插件帮助信息
+        "version": str, # 插件版本
+        "author": str, # 插件作者
+    }
+    """        
+    def info(self):
+        return {
+            "name": "helloworld",
+            "desc": "测试插件",
+            "help": "测试插件, 回复helloworld即可触发",
+            "version": "v1.0.1 beta",
+            "author": "Soulter"
+        }
+
+
+        # 热知识：检测消息开头指令，使用以下方法
+        # if message.startswith("原神"):
+        #     pass

addons/revChatGPT/revchatgpt.py

@@ -1,45 +0,0 @@
-from revChatGPT.V1 import Chatbot
-
-class revChatGPT:
-    def __init__(self, config):
-        
-        if 'password' in config:
-            config['password'] = str(config['password'])
-        self.chatbot = Chatbot(config=config)
-
-    def chat(self, prompt):
-        resp = ''
-
-        """
-        Base class for exceptions in this module.
-        Error codes:
-        -1: User error
-        0: Unknown error
-        1: Server error
-        2: Rate limit error
-        3: Invalid request error
-        4: Expired access token error
-        5: Invalid access token error
-        6: Prohibited concurrent query error
-        """
-
-
-        err_count = 0
-        retry_count = 5
-
-        while err_count < retry_count:
-            try:
-                for data in self.chatbot.ask(prompt):
-                    resp = data["message"]
-                break
-            except BaseException as e:
-                try:
-                    print("[RevChatGPT] 请求出现了一些问题, 正在重试。次数"+str(err_count))
-                    err_count += 1
-                    if err_count >= retry_count:
-                        raise e
-                except BaseException:
-                    err_count += 1
-        
-        print("[RevChatGPT] "+str(resp))
-        return resp

addons/revEdgeGPT/revedgegpt.py

@@ -1,47 +0,0 @@
-import asyncio
-from EdgeGPT import Chatbot, ConversationStyle
-import json
-
-class revEdgeGPT:
-    def __init__(self):
-        self.busy = False
-        self.wait_stack = []
-        with open('./cookies.json', 'r') as f:
-            cookies = json.load(f)
-        self.bot = Chatbot(cookies=cookies)
-
-    def is_busy(self):
-         return self.busy
-    
-    async def reset(self):
-        try:
-            await self.bot.reset()
-            return False
-        except BaseException:
-            return True
-
-    async def chat(self, prompt):
-        if self.busy:
-             return
-        self.busy = True
-        resp = 'err'
-        err_count = 0
-        retry_count = 5
-        
-        while err_count < retry_count:
-            try:
-                resp = await self.bot.ask(prompt=prompt, conversation_style=ConversationStyle.creative)
-                resp = resp['item']['messages'][len(resp['item']['messages'])-1]['text']
-                if resp == prompt:
-                    resp += '\n\n如果你没有让我复述你的话，那代表我可能不想和你继续这个话题了，请输入/reset重置会话😶'
-                break
-            except BaseException as e:
-                print(e.with_traceback)
-                err_count += 1
-                if err_count >= retry_count:
-                        raise e
-                print("[RevEdgeGPT] 请求出现了一些问题, 正在重试。次数"+str(err_count))
-        self.busy = False
-        
-        print("[RevEdgeGPT] "+str(resp))
-        return resp

configs/config.yaml

@@ -1,43 +1,42 @@
-# 如果你不知道怎么部署，请务必查看https://soulter.top/posts/qpdg.html
+# 如果你不知道怎么部署，请查看https://soulter.top/posts/qpdg.html
+# 不一定需要key了，如果你没有key但有openAI账号或者必应账号，可以考虑使用下面的逆向库
 
-# 不一定需要key了，如果你没有key但有openAI账号或者必应账号，也可以使用下面的逆向库
 
-# 注意：已支持多key自动切换，方法：
-# key:
-#   - sk-xxxxxx
-#   - sk-xxxxxx
-# 在下方非注释的地方使用以上格式
-
-# 关于api_base：可以使用一些云函数（如腾讯、阿里）来避免国内被墙的问题。
-# 详见：
-# https://github.com/Ice-Hazymoon/openai-scf-proxy
-# https://github.com/Soulter/QQChannelChatGPT/issues/42
-# 设置为none则表示使用官方默认api地址
-openai:
-  key: 
-    - 
-  api_base: none
-  # 这里是GPT配置，语言模型默认使用gpt-3.5-turbo
-  chatGPTConfigs:
-    model: gpt-3.5-turbo
-    max_tokens: 3000
-    temperature: 0.9
-    top_p: 1
-    frequency_penalty: 0
-    presence_penalty: 0
-    
-  total_tokens_limit: 5000
+###############平台设置#################
 
+# QQ频道机器人
 # QQ开放平台的appid和令牌
 # q.qq.com
+# enable为true则启用，false则不启用
 qqbot:
+  enable: true
   appid: 
   token: 
 
+# QQ机器人
+# enable为true则启用，false则不启用
+# 需要安装GO-CQHTTP配合使用。
+# 文档：https://docs.go-cqhttp.org/
+# 请将go-cqhttp的配置文件的sever部分粘贴为以下内容，否则无法使用
+# 请先启动go-cqhttp再启动本程序
+# 
+# servers:
+#   - http:
+#       host: 127.0.0.1
+#       version: 0
+#       port: 5700
+#       timeout: 5
+#   - ws:
+#       address: 127.0.0.1:6700
+#       middlewares:
+#         <<: *default
+gocqbot:
+  enable: false
+
 # 设置是否一个人一个会话
 uniqueSessionMode: false
 # QChannelBot 的版本，请勿修改此字段，否则可能产生一些bug
-version: 2.8
+version: 3.0
 # [Beta] 转储历史记录时间间隔(分钟)
 dump_history_interval: 10
 # 一个用户只能在time秒内发送count条消息
@@ -61,9 +60,6 @@ reply_prefix:
   rev_chatgpt: "[Rev]"
   rev_edgegpt: "[RevBing]"
 
-
-################外带程序（插件）################
-
 # 百度内容审核服务
 # 新用户免费5万次调用。https://cloud.baidu.com/doc/ANTIPORN/index.html
 baidu_aip:
@@ -72,10 +68,45 @@ baidu_aip:
   api_key: 
   secret_key: 
 
+
+
+
+###############语言模型设置#################
+
+
+# OpenAI官方API
+# 注意：已支持多key自动切换，方法：
+# key:
+#   - sk-xxxxxx
+#   - sk-xxxxxx
+# 在下方非注释的地方使用以上格式
+# 关于api_base：可以使用一些云函数（如腾讯、阿里）来避免国内被墙的问题。
+# 详见：
+# https://github.com/Ice-Hazymoon/openai-scf-proxy
+# https://github.com/Soulter/QQChannelChatGPT/issues/42
+# 设置为none则表示使用官方默认api地址
+openai:
+  key: 
+    - 
+  api_base: none
+  # 这里是GPT配置，语言模型默认使用gpt-3.5-turbo
+  chatGPTConfigs:
+    model: gpt-3.5-turbo
+    max_tokens: 3000
+    temperature: 0.9
+    top_p: 1
+    frequency_penalty: 0
+    presence_penalty: 0
+    
+  total_tokens_limit: 5000
+
 # 逆向文心一言【暂时不可用，请勿使用】
 rev_ernie:
   enable: false
 
+# 逆向New Bing
+# 需要在项目根目录下创建cookies.json并粘贴cookies进去。
+# 详见：https://soulter.top/posts/qpdg.html
 rev_edgegpt:
   enable: false
 
@@ -93,14 +124,14 @@ rev_edgegpt:
 #   - email: 第2个账户
 #     password: 第2个账户密码
 #   - ....
-# 支持使用session_token\access_token登录
+# 支持使用access_token登录
 # 例：
 # - session_token: xxxxx
 # - access_token: xxxx
 # 请严格按照上面这个格式填写。
-
+# 逆向ChatGPT库的email-password登录方式不工作，建议使用access_token登录
+# 获取access_token的方法，详见：https://soulter.top/posts/qpdg.html
 rev_ChatGPT:
   enable: false
   account:
-    - email: 
-      password: 
+    - access_token: 

cores/openai/core.py

@@ -1,191 +0,0 @@
-import openai
-import yaml
-from util.errors.errors import PromptExceededError
-import json
-import time
-import os
-import sys
-
-inst = None
-# 适配pyinstaller
-abs_path = os.path.dirname(os.path.realpath(sys.argv[0])) + '/'
-key_record_path = abs_path+'chatgpt_key_record'
-
-class ChatGPT:
-    def __init__(self, cfg):
-        self.key_list = []
-        if 'api_base' in cfg and cfg['api_base'] != 'none' and cfg['api_base'] != '':
-            openai.api_base = cfg['api_base']
-        if cfg['key'] != '' and cfg['key'] != None:
-            print("[System] 读取ChatGPT Key成功")
-            self.key_list = cfg['key']
-            # openai.api_key = cfg['key']
-        else:
-            input("[System] 请先去完善ChatGPT的Key。详情请前往https://beta.openai.com/account/api-keys")
-        
-        # init key record
-        self.init_key_record()
-
-        chatGPT_configs = cfg['chatGPTConfigs']
-        print(f'[System] 加载ChatGPTConfigs: {chatGPT_configs}')
-        self.chatGPT_configs = chatGPT_configs
-        self.openai_configs = cfg
-    
-    def chat(self, req, image_mode = False, img_num = 1, img_size = "1024x1024"):
-        # ChatGPT API 2023/3/2
-        # messages = [{"role": "user", "content": prompt}]
-        if not image_mode:
-            try:
-                response = openai.ChatCompletion.create(
-                    messages=req,
-                    **self.chatGPT_configs
-                )
-            except Exception as e:
-                print(e)
-                if 'You exceeded' in str(e) or 'Billing hard limit has been reached' in str(e) or 'No API key provided' in str(e) or 'Incorrect API key provided' in str(e):
-                    print("[System] 当前Key已超额或者不正常,正在切换")
-                    self.key_stat[openai.api_key]['exceed'] = True
-                    self.save_key_record()
-
-                    response, is_switched = self.handle_switch_key(req)
-                    if not is_switched:
-                        # 所有Key都超额或不正常
-                        raise e
-                else:
-                    response = openai.ChatCompletion.create(
-                        messages=req,
-                        **self.chatGPT_configs
-                    )
-            self.key_stat[openai.api_key]['used'] += response['usage']['total_tokens']
-            self.save_key_record()
-            print("[ChatGPT] "+str(response["choices"][0]["message"]["content"]))
-            return str(response["choices"][0]["message"]["content"]).strip(), response['usage']['total_tokens']
-        else:
-            try:
-                # print("test1")
-                response = openai.Image.create(
-                    prompt=req[0]['content'],
-                    n=img_num,
-                    size=img_size
-                )
-                # print("test2")
-                image_url = []
-                for i in range(img_num):
-                    image_url.append(response['data'][i]['url'])
-                print(image_url)
-            except Exception as e:
-                print(e)
-                if 'You exceeded' in str(e) or 'Billing hard limit has been reached' in str(
-                        e) or 'No API key provided' in str(e) or 'Incorrect API key provided' in str(e):
-                    print("[System] 当前Key已超额或者不正常,正在切换")
-                    self.key_stat[openai.api_key]['exceed'] = True
-                    self.save_key_record()
-
-                    response, is_switched = self.handle_switch_key(req)
-                    if not is_switched:
-                        # 所有Key都超额或不正常
-                        raise e
-                else:
-                    response = openai.Image.create(
-                        prompt=req[0]['content'],
-                        n=img_num,
-                        size=img_size
-                    )
-                    image_url = []
-                    for i in range(img_num):
-                        image_url.append(response['data'][i]['url'])
-            return image_url
-    def handle_switch_key(self, req):
-        # messages = [{"role": "user", "content": prompt}]
-        while True:
-            is_all_exceed = True
-            for key in self.key_stat:
-                if not self.key_stat[key]['exceed']:
-                    is_all_exceed = False
-                    openai.api_key = key
-                    print(f"[System] 切换到Key: {key}, 已使用token: {self.key_stat[key]['used']}")
-                    if len(req) > 0:
-                        try:
-                            response = openai.ChatCompletion.create(
-                                messages=req,
-                                **self.chatGPT_configs
-                            )
-                            return response, True
-                        except Exception as e:
-                            print(e)
-                            if 'You exceeded' in str(e):
-                                print("[System] 当前Key已超额,正在切换")
-                                self.key_stat[openai.api_key]['exceed'] = True
-                                self.save_key_record()
-                                time.sleep(1)
-                                continue
-                    else:
-                        return True
-            if is_all_exceed:
-                print("[System] 所有Key已超额")
-                return None, False
-                
-    def getConfigs(self):
-        return self.openai_configs
-    
-    def save_key_record(self):
-        with open(key_record_path, 'w', encoding='utf-8') as f:
-            json.dump(self.key_stat, f)
-
-    def get_key_stat(self):
-        return self.key_stat
-    def get_key_list(self):
-        return self.key_list
-    
-    # 添加key
-    def append_key(self, key, sponsor):
-        self.key_list.append(key)
-        self.key_stat[key] = {'exceed': False, 'used': 0, 'sponsor': sponsor}
-        self.save_key_record()
-        self.init_key_record()
-    # 检查key是否可用
-    def check_key(self, key):
-        pre_key = openai.api_key
-        openai.api_key = key
-        messages = [{"role": "user", "content": "1"}]
-        try:
-            response = openai.ChatCompletion.create(
-                messages=messages,
-                **self.chatGPT_configs
-            )
-            openai.api_key = pre_key
-            return True
-        except Exception as e:
-            pass
-        openai.api_key = pre_key
-        return False
-
-    #将key_list的key转储到key_record中，并记录相关数据
-    def init_key_record(self):
-        if not os.path.exists(key_record_path):
-            with open(key_record_path, 'w', encoding='utf-8') as f:
-                json.dump({}, f)
-        with open(key_record_path, 'r', encoding='utf-8') as keyfile:
-            try:
-                self.key_stat = json.load(keyfile)
-            except Exception as e:
-                print(e)
-                self.key_stat = {}
-            finally:
-                for key in self.key_list:
-                    if key not in self.key_stat:
-                        self.key_stat[key] = {'exceed': False, 'used': 0}
-                        # if openai.api_key is None:
-                        #     openai.api_key = key
-                    else:
-                        # if self.key_stat[key]['exceed']:
-                        #     print(f"Key: {key} 已超额")
-                        #     continue
-                        # else:
-                        #     if openai.api_key is None:
-                        #         openai.api_key = key
-                        #         print(f"使用Key: {key}, 已使用token: {self.key_stat[key]['used']}")
-                        pass
-                if openai.api_key == None:
-                    self.handle_switch_key("")
-            self.save_key_record()

cores/qqbot/core.py

@@ -1,13 +1,7 @@
-import io
-
 import botpy
-from PIL import Image
-from botpy.message import Message
+from botpy.message import Message, DirectMessage
 from botpy.types.message import Reference
-import yaml
 import re
-from util.errors.errors import PromptExceededError
-from botpy.message import DirectMessage
 import json
 import threading
 import asyncio
@@ -18,7 +12,16 @@ import os
 import sys
 from cores.qqbot.personality import personalities
 from addons.baidu_aip_judge import BaiduJudge
-
+from model.platform.qqchan import QQChan
+from model.platform.qq import QQ
+from nakuru import (
+    CQHTTP,
+    GroupMessage,
+    GroupMemberIncrease,
+    FriendMessage
+)
+from nakuru.entities.components import Plain,At
+from model.command.command import Command
 
 # QQBotClient实例
 client = ''
@@ -59,48 +62,68 @@ direct_message_mode = True
 abs_path = os.path.dirname(os.path.realpath(sys.argv[0])) + '/'
 
 # 版本
-version = '2.9'
+version = '3.0.2'
 
-# 语言模型提供商
+# 语言模型
 REV_CHATGPT = 'rev_chatgpt'
 OPENAI_OFFICIAL = 'openai_official'
 REV_ERNIE = 'rev_ernie'
 REV_EDGEGPT = 'rev_edgegpt'
-provider = ''
-
-# 逆向库对象及负载均衡
-rev_chatgpt = []
+provider = None
+chosen_provider = None
 
+# 逆向库对象
+rev_chatgpt = None
 # gpt配置信息
 gpt_config = {}
-
 # 百度内容审核实例
 baidu_judge = None
-
 # 回复前缀
-reply_prefix = ''
+reply_prefix = {}
+# 关键词回复
+keywords = {}
+
+# QQ频道机器人
+qqchannel_bot = None
+PLATFORM_QQCHAN = 'qqchan'
+qqchan_loop = None
+
+# QQ机器人
+gocq_bot = None
+PLATFORM_GOCQ = 'gocq'
+gocq_app = None
+admin_qq = "123456"
+
+gocq_loop = None
+nick_qq = "ai"
+
+bing_cache_loop = None
+
+# 插件
+cached_plugins = {}
+
+
+def gocq_runner():
+    global gocq_app
+    ok = False
+    while not ok:
+        try:
+            gocq_app = CQHTTP(
+                host="127.0.0.1",
+                port=6700,
+                http_port=5700,
+            )
+            ok = True
+        except BaseException as e:
+            print("[System-err] 连接到go-cqhttp异常, 5秒后重试。"+str(e))
+
+threading.Thread(target=gocq_runner, daemon=True).start()
 
 
 def new_sub_thread(func, args=()):
     thread = threading.Thread(target=func, args=args, daemon=True)
-    thread.start() 
+    thread.start()
 
-class botClient(botpy.Client):
-    # 收到At消息
-    async def on_at_message_create(self, message: Message):
-        toggle_count(at=True, message=message)
-        message_reference = Reference(message_id=message.id, ignore_get_message_error=False)
-        # executor.submit(oper_msg, message, True)
-        new_sub_thread(oper_msg, (message, True, message_reference))
-        # await oper_msg(message=message, at=True)
-
-    # 收到私聊消息
-    async def on_direct_message_create(self, message: DirectMessage):
-        if direct_message_mode:
-            toggle_count(at=False, message=message)
-            # executor.submit(oper_msg, message, True)
-            # await oper_msg(message=message, at=False)
-            new_sub_thread(oper_msg, (message, False))
 
 # 写入统计信息
 def toggle_count(at: bool, message):
@@ -162,55 +185,61 @@ def upload():
 初始化机器人
 '''
 def initBot(cfg, prov):
-    global chatgpt, provider, rev_chatgpt, baidu_judge, rev_ernie, rev_edgegpt
-    global reply_prefix, now_personality, gpt_config, config, uniqueSession, frequency_count, frequency_time,announcement, direct_message_mode, version
-    global command_openai_official, command_rev_chatgpt, command_rev_edgegpt
-
+    global chatgpt, provider, rev_chatgpt, baidu_judge, rev_edgegpt, chosen_provider
+    global reply_prefix, gpt_config, config, uniqueSession, frequency_count, frequency_time,announcement, direct_message_mode, version
+    global command_openai_official, command_rev_chatgpt, command_rev_edgegpt,reply_prefix, keywords, cached_plugins
     provider = prov
     config = cfg
-    reply_prefix_config = None
     if 'reply_prefix' in cfg:
-        reply_prefix_config = cfg['reply_prefix']
+        reply_prefix = cfg['reply_prefix']
 
     # 语言模型提供商
-    if prov == REV_CHATGPT:
-        if 'account' in cfg['rev_ChatGPT']:
-            from model.provider.provider_rev_chatgpt import ProviderRevChatGPT
-            from model.command.command_rev_chatgpt import CommandRevChatGPT
-            for i in range(0, len(cfg['rev_ChatGPT']['account'])):
-                try:
-                    print(f"[System] 创建rev_ChatGPT负载{str(i)}: " + str(cfg['rev_ChatGPT']['account'][i]))
-                    revstat = {
-                        'obj': ProviderRevChatGPT(cfg['rev_ChatGPT']['account'][i]),
-                        'busy': False
-                    }
-                    rev_chatgpt.append(revstat)
-                except:
-                    print("[System] 创建rev_ChatGPT负载失败")
-            command_rev_chatgpt = CommandRevChatGPT(rev_chatgpt)
-
-            if REV_CHATGPT in reply_prefix_config:
-                reply_prefix = reply_prefix_config[REV_CHATGPT]
+    print("--------------------加载语言模型--------------------")
+    if REV_CHATGPT in prov:
+        print("- 逆向ChatGPT库 -")
+        if cfg['rev_ChatGPT']['enable']:
+            if 'account' in cfg['rev_ChatGPT']:
+                from model.provider.provider_rev_chatgpt import ProviderRevChatGPT
+                from model.command.command_rev_chatgpt import CommandRevChatGPT
+                rev_chatgpt = ProviderRevChatGPT(cfg['rev_ChatGPT'])
+                command_rev_chatgpt = CommandRevChatGPT(cfg['rev_ChatGPT'])
+                chosen_provider = REV_CHATGPT
+            else:
+                input("[System-err] 请退出本程序, 然后在配置文件中填写rev_ChatGPT相关配置")
+        
+    if REV_EDGEGPT in prov:
+        print("- New Bing -")
+        if not os.path.exists('./cookies.json'):
+            input("[System-err] 导入Bing模型时发生错误, 没有找到cookies文件或者cookies文件放置位置错误。windows启动器启动的用户请把cookies.json文件放到和启动器相同的目录下。\n如何获取请看https://github.com/Soulter/QQChannelChatGPT仓库介绍。")
         else:
-            input("[System-err] 请退出本程序, 然后在配置文件中填写rev_ChatGPT相关配置")
-    elif prov == OPENAI_OFFICIAL:
-        from model.provider.provider_openai_official import ProviderOpenAIOfficial
-        from model.command.command_openai_official import CommandOpenAIOfficial
-        chatgpt = ProviderOpenAIOfficial(cfg['openai'])
-        command_openai_official = CommandOpenAIOfficial(chatgpt)
-        if OPENAI_OFFICIAL in reply_prefix_config:
-            reply_prefix = reply_prefix_config[OPENAI_OFFICIAL]
-    # elif prov == REV_ERNIE:
-    #     from addons.revERNIE import revernie
-    #     rev_ernie = revernie.wx
-    elif prov == REV_EDGEGPT:
-        from model.provider.provider_rev_edgegpt import ProviderRevEdgeGPT
-        from model.command.command_rev_edgegpt import CommandRevEdgeGPT
-        rev_edgegpt = ProviderRevEdgeGPT()
-        command_rev_edgegpt = CommandRevEdgeGPT(rev_edgegpt)
-        if REV_EDGEGPT in reply_prefix_config:
-            reply_prefix = reply_prefix_config[REV_EDGEGPT]
+            if cfg['rev_edgegpt']['enable']:
+                from model.provider.provider_rev_edgegpt import ProviderRevEdgeGPT
+                from model.command.command_rev_edgegpt import CommandRevEdgeGPT
+                rev_edgegpt = ProviderRevEdgeGPT()
+                command_rev_edgegpt = CommandRevEdgeGPT(rev_edgegpt)
+                chosen_provider = REV_EDGEGPT
+    if OPENAI_OFFICIAL in prov:
+        print("- OpenAI ChatGPT官方API -")
+        if cfg['openai']['key'] is not None:
+            from model.provider.provider_openai_official import ProviderOpenAIOfficial
+            from model.command.command_openai_official import CommandOpenAIOfficial
+            chatgpt = ProviderOpenAIOfficial(cfg['openai'])
+            command_openai_official = CommandOpenAIOfficial(chatgpt)
+            chosen_provider = OPENAI_OFFICIAL
 
+    print("--------------------加载个性化配置--------------------")
+    # 得到关键词
+    if os.path.exists("keyword.json"):
+        with open("keyword.json", 'r', encoding='utf-8') as f:
+            keywords = json.load(f)
+
+    # 检查provider设置偏好
+    if os.path.exists("provider_preference.txt"):
+        with open("provider_preference.txt", 'r', encoding='utf-8') as f:
+            res = f.read()
+            if res in prov:
+                chosen_provider = res
+        
     # 百度内容审核
     if 'baidu_aip' in cfg and 'enable' in cfg['baidu_aip'] and cfg['baidu_aip']['enable']:
         try: 
@@ -238,16 +267,6 @@ def initBot(cfg, prov):
         direct_message_mode = cfg['direct_message_mode']
         print("[System] 私聊功能: "+str(direct_message_mode))
 
-    # 得到版本
-    if 'version' in cfg:
-        try:
-            f = open(abs_path+"version.txt", 'r', encoding='utf-8')
-            version = f.read()
-        except:
-            print('[System-Err] 读取更新记录文件失败')
-        # version = 'Unknown'
-        # print("[System] QQChannelChatGPT版本: "+str(version))
-
     # 得到发言频率配置
     if 'limit' in cfg:
         print('[System] 发言频率配置: '+str(cfg['limit']))
@@ -256,7 +275,6 @@ def initBot(cfg, prov):
         if 'time' in cfg['limit']:
             frequency_time = cfg['limit']['time']
     
-    announcement += '[QQChannelChatGPT项目，觉得好用的话欢迎前往Github给Star]\n所有回答与腾讯公司无关。出现问题请前往[GPT机器人]官方频道\n\n'
     # 得到公告配置
     if 'notice' in cfg:
         print('[System] 公告配置: '+cfg['notice'])
@@ -270,95 +288,95 @@ def initBot(cfg, prov):
         if 'dump_history_interval' in cfg:
             print("[System] 历史记录转储时间周期: " + cfg['dump_history_interval'] + "分钟")
     except BaseException:
-        print("[System-Error] 读取uniqueSessionMode/version/dump_history_interval配置文件失败, 使用默认值。")
+        pass
 
     print(f"[System] QQ开放平台AppID: {cfg['qqbot']['appid']} 令牌: {cfg['qqbot']['token']}")
 
-    print("\n[System] 如果有任何问题，请在https://github.com/Soulter/QQChannelChatGPT上提交issue说明问题！或者添加QQ：905617992")
-    print("[System] 请给https://github.com/Soulter/QQChannelChatGPT点个star!")
-    print("[System] 请给https://github.com/Soulter/QQChannelChatGPT点个star!")
-    # input("\n仔细阅读完以上信息后，输入任意信息并回车以继续")
-    try:
-        run_bot(cfg['qqbot']['appid'], cfg['qqbot']['token'])
-    except BaseException as e:
-        input(f"\n[System-Error] 启动QQ机器人时出现错误，原因如下：{e}\n可能是没有填写QQBOT appid和token？请在config中完善你的appid和token\n配置教程：https://soulter.top/posts/qpdg.html\n")
+    print("\n[System] 如果有任何问题, 请在 https://github.com/Soulter/QQChannelChatGPT 上提交issue说明问题！或者添加QQ：905617992")
+    print("[System] 请给 https://github.com/Soulter/QQChannelChatGPT 点个star!")
 
-        
-'''
-启动机器人
-'''
-def run_bot(appid, token):
+    if chosen_provider is None:
+        print("[System-Warning] 检测到没有启动任何一个语言模型。请至少在配置文件中启用一个语言模型。")
+
+    # 得到指令设置(cmd_config.json)
+    if os.path.exists("cmd_config.json"):
+        with open("cmd_config.json", 'r', encoding='utf-8') as f:
+            cmd_config = json.load(f)
+            # QQ机器人昵称
+            if 'nick_qq' in cmd_config:
+                global nick_qq
+                nick_qq = cmd_config['nick_qq']
+
+
+    thread_inst = None
+
+    print("--------------------加载插件--------------------")
+    # 加载插件
+    _command = Command(None)
+    ok, err = _command.plugin_reload(cached_plugins)
+    if ok:
+        print("加载插件完成")
+    else:
+        print(err)
+
+    print("--------------------加载平台--------------------")
+    # GOCQ
+    if 'gocqbot' in cfg and cfg['gocqbot']['enable']:
+        print("- 启用QQ机器人 -")
+        if os.path.exists("cmd_config.json"):
+            with open("cmd_config.json", 'r', encoding='utf-8') as f:
+                cmd_config = json.load(f)
+                global admin_qq
+                if "admin_qq" in cmd_config:
+                    admin_qq = cmd_config['admin_qq']
+                    print("[System] 管理者QQ号: " + admin_qq)
+                else:
+                    admin_qq = input("[System] 请输入管理者QQ号(管理者QQ号才能使用update/plugin等指令): ")
+                    print("[System] 管理者QQ号设置为: " + admin_qq)
+                    cmd_config['admin_qq'] = admin_qq
+                    with open("cmd_config.json", 'w', encoding='utf-8') as f:
+                        json.dump(cmd_config, f, indent=4)
+                        f.flush()
+        global gocq_app, gocq_bot, gocq_loop
+        gocq_bot = QQ()
+        gocq_loop = asyncio.new_event_loop()
+        thread_inst = threading.Thread(target=run_gocq_bot, args=(gocq_loop, gocq_bot, gocq_app), daemon=False)
+        thread_inst.start()
+
+    # QQ频道
+    if 'qqbot' in cfg and cfg['qqbot']['enable']:
+        print("- 启用QQ频道机器人 -")
+        global qqchannel_bot, qqchan_loop
+        qqchannel_bot = QQChan()
+        qqchan_loop = asyncio.new_event_loop()
+        thread_inst = threading.Thread(target=run_qqchan_bot, args=(cfg, qqchan_loop, qqchannel_bot), daemon=False)
+        thread_inst.start()
+        # thread.join()
+
+    if thread_inst == None:
+        input("[System-Error] 没有启用任何机器人，程序退出")
+        exit()
+
+    thread_inst.join()
+
+def run_qqchan_bot(cfg, loop, qqchannel_bot):
+    asyncio.set_event_loop(loop)
     intents = botpy.Intents(public_guild_messages=True, direct_message=True) 
     global client
     client = botClient(intents=intents)
-    client.run(appid=appid, token=token)
-
-'''
-负载均衡，得到逆向ChatGPT回复
-'''
-def get_rev_ChatGPT_response(prompts_str):
-    res = ''
-    print("[Debug] "+str(rev_chatgpt))
-    for revstat in rev_chatgpt:
-        if not revstat['busy']:
-            try:
-                revstat['busy'] = True
-                print("[Debug] 使用逆向ChatGPT回复ing", end='', flush=True)
-                res = revstat['obj'].text_chat(prompts_str)
-                print("OK")
-                revstat['busy'] = False
-                # 处理结果文本
-                chatgpt_res = res.strip()
-                return res
-            except Exception as e:
-                print("[System-Error] 逆向ChatGPT回复失败" + str(e))
-                try:
-                    if e.code == 2:
-                        print("[System-Error] 频率限制，正在切换账号。"+ str(e))
-                        continue
-                    else:
-                        res = '所有的非忙碌OpenAI账号经过测试都暂时出现问题，请稍后再试或者联系管理员~'
-                        return res
-                except BaseException:
-                    continue
-    res = '所有的OpenAI账号都有负载, 请稍后再试~'
-    return res
-
-
-'''
-回复QQ消息
-'''
-def send_qq_msg(message, res, image_mode=False, msg_ref = None):
-    if not image_mode:
-        try:
-            if msg_ref is not None:
-                reply_res = asyncio.run_coroutine_threadsafe(message.reply(content=res, message_reference = msg_ref), client.loop)
-            else:
-                reply_res = asyncio.run_coroutine_threadsafe(message.reply(content=res), client.loop)
-            reply_res.result()
-        except BaseException as e:
-            if "msg over length" in str(e):
-                split_res = []
-                split_res.append(res[:len(res)//2])      
-                split_res.append(res[len(res)//2:])
-                for i in split_res:
-                    if msg_ref is not None:
-                        reply_res = asyncio.run_coroutine_threadsafe(message.reply(content=i, message_reference = msg_ref), client.loop)
-                    else:
-                        reply_res = asyncio.run_coroutine_threadsafe(message.reply(content=i), client.loop)
-                    reply_res.result()
-            else:
-                print("[System-Error] 回复QQ消息失败")
-                raise e
-    else:
-        pic_res = requests.get(str(res), stream=True)
-        if pic_res.status_code == 200:
-            # 将二进制数据转换成图片对象
-            image = Image.open(io.BytesIO(pic_res.content))
-            # 保存图片到本地
-            image.save('tmp_image.jpg')
-        asyncio.run_coroutine_threadsafe(message.reply(file_image='tmp_image.jpg', content=""), client.loop)
+    try:
+        qqchannel_bot.run_bot(client, cfg['qqbot']['appid'], cfg['qqbot']['token'])
+    except BaseException as e:
+        input(f"\n[System-Error] 启动QQ频道机器人时出现错误，原因如下：{e}\n可能是没有填写QQBOT appid和token？请在config中完善你的appid和token\n配置教程：https://soulter.top/posts/qpdg.html\n")
 
+def run_gocq_bot(loop, gocq_bot, gocq_app):
+    asyncio.set_event_loop(loop)
+    global gocq_client
+    gocq_client = gocqClient()
+    try:
+        gocq_bot.run_bot(gocq_app)
+    except BaseException as e:
+        input("启动QQ机器人出现错误"+str(e))
 
 '''
 检查发言频率
@@ -381,180 +399,280 @@ def check_frequency(id) -> bool:
         user_frequency[id] = t
         return True
 
+def save_provider_preference(chosen_provider):
+    with open('provider_preference.txt', 'w') as f:
+        f.write(chosen_provider)
+
+
 '''
-处理消息
+通用回复方法
 '''
-def oper_msg(message, at=False, msg_ref = None):
+def send_message(platform, message, res, msg_ref = None, image = None, gocq_loop = None, qqchannel_bot = None, gocq_bot = None):
+    if platform == PLATFORM_QQCHAN:
+        if image != None:
+            qqchannel_bot.send_qq_msg(message, str(res), image_mode=True, msg_ref=msg_ref)
+        else:
+            qqchannel_bot.send_qq_msg(message, str(res), msg_ref=msg_ref)
+    if platform == PLATFORM_GOCQ: 
+        if image != None:
+            asyncio.run_coroutine_threadsafe(gocq_bot.send_qq_msg(message, image, image_mode=True), gocq_loop).result()
+        else:
+            asyncio.run_coroutine_threadsafe(gocq_bot.send_qq_msg(message, res, False, ), gocq_loop).result()
+
+
+def oper_msg(message, 
+             group: bool=False, 
+             msg_ref: Reference = None, 
+             platform: str = None):
+    """
+    处理消息。
+    group: 群聊模式,
+    message: 频道是频道的消息对象, QQ是nakuru-gocq的消息对象
+    """
     global session_dict, provider
-    print("[QQBOT] 接收到消息："+ str(message.content))
     qq_msg = ''
     session_id = ''
-    name = ''
-    user_id = message.author.id
-    user_name = message.author.username
+    user_id = ''
+    user_name = ''
+    global chosen_provider, reply_prefix, keywords, qqchannel_bot, gocq_bot, gocq_loop, bing_cache_loop
+    role = "member" # 角色
+    hit = False # 是否命中指令
+    command_result = () # 调用指令返回的结果
+    global admin_qq, cached_plugins
+
+    if platform == PLATFORM_QQCHAN:
+        print("[QQCHAN-BOT] 接收到消息："+ str(message.content))
+        user_id = message.author.id
+        user_name = message.author.username
+        global qqchan_loop
+    if platform == PLATFORM_GOCQ:
+        if isinstance(message.message[0], Plain):
+            print("[GOCQ-BOT] 接收到消息："+ str(message.message[0].text))
+        elif isinstance(message.message[0], At):
+            print("[GOCQ-BOT] 接收到消息："+ str(message.message[1].text))
+            
+        user_id = message.user_id
+        user_name = message.user_id
+        global gocq_loop
+    
+    if chosen_provider is None:
+        send_message(platform, message,  f"没有启动任何一个语言模型。请至少在配置文件中启用一个语言模型。", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
     
     # 检查发言频率
     if not check_frequency(user_id):
-        send_qq_msg(message, f'{user_name}的发言超过频率限制(╯▔皿▔)╯。\n{frequency_time}秒内只能提问{frequency_count}次。')
+        send_message(platform, message, f'你的发言超过频率限制(╯▔皿▔)╯。\n管理员设置{frequency_time}秒内只能提问{frequency_count}次。', msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
         return
 
-    logf.write("[QQBOT] "+ str(message.content)+'\n')
+    if platform == PLATFORM_QQCHAN:
+        if group:
+            # 频道内
+            # 过滤@
+            qq_msg = message.content
+            lines = qq_msg.splitlines()
+            for i in range(len(lines)):
+                lines[i] = re.sub(r"<@!\d+>", "", lines[i])
+            qq_msg = "\n".join(lines).lstrip().strip()
+            if uniqueSession:
+                session_id = user_id
+            else:
+                session_id = message.channel_id
+            # 得到身份
+            if "2" in message.member.roles or "4" in message.member.roles or "5" in message.member.roles:
+                print("[QQCHAN-BOT] 检测到管理员身份")
+                role = "admin"
+            else:
+                role = "member"
+        else:
+            # 私信
+            qq_msg = message.content
+            session_id = user_id
+
+    if platform == PLATFORM_GOCQ:
+        if group:
+            if isinstance(message.message[0], Plain):
+                qq_msg = str(message.message[0].text).strip()
+            elif isinstance(message.message[0], At):
+                qq_msg = str(message.message[1].text).strip()
+            else:
+                return
+            session_id = message.group_id
+        else:
+            qq_msg = message.message[0].text
+            session_id = message.user_id
+        role = "member"
+        if str(message.sender.user_id) == admin_qq:
+            print("[GOCQ-BOT] 检测到管理员身份")
+            role = "admin"
+
+    if qq_msg == "":
+        send_message(platform, message,  f"Hi~", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+        return
+
+    logf.write("[QQBOT] "+ qq_msg+'\n')
     logf.flush()
 
-    if at:
-        qq_msg = message.content
-        lines = qq_msg.splitlines()
-        for i in range(len(lines)):
-            lines[i] = re.sub(r"<@!\d+>", "", lines[i])
-        qq_msg = "\n".join(lines).lstrip().strip()
+    # 关键词回复
+    for k in keywords:
+        if qq_msg == k:
+            send_message(platform, message, keywords[k], msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+            return
 
-        if uniqueSession:
-            session_id = user_id
-        else:
-            session_id = message.channel_id
-    else:
-        qq_msg = message.content
-        session_id = user_id
-        
-    if uniqueSession:
-        name = user_name
-    else:
-        name = "频道"
-
-    # 这里是预设
-    if qq_msg.strip() == 'hello' or qq_msg.strip() == '你好' or qq_msg.strip() == '':
-        send_qq_msg(message, f"你好呀🥰，输入/help查看指令噢", msg_ref=msg_ref)
-        return
-    
     # 关键词拦截器
     for i in uw.unfit_words_q:
         matches = re.match(i, qq_msg.strip(), re.I | re.M)
         if matches:
-            send_qq_msg(message, f"你的提问得到的回复未通过【自有关键词拦截】服务，不予回复。", msg_ref=msg_ref)
+            send_message(platform, message,  f"你的提问得到的回复未通过【自有关键词拦截】服务, 不予回复。", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
             return
     if baidu_judge != None:
         check, msg = baidu_judge.judge(qq_msg)
         if not check:
-            send_qq_msg(message, f"你的提问得到的回复未通过【百度AI内容审核】服务，不予回复。\n\n{msg}", msg_ref=msg_ref)
+            send_message(platform, message,  f"你的提问得到的回复未通过【百度AI内容审核】服务, 不予回复。\n\n{msg}", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
             return
-        
+    
+    # 检查是否是更换语言模型的请求
+    temp_switch = ""
+    if qq_msg.startswith('/bing') or qq_msg.startswith('/gpt') or qq_msg.startswith('/revgpt'):
+        target = chosen_provider
+        if qq_msg.startswith('/bing'):
+            target = REV_EDGEGPT
+        elif qq_msg.startswith('/gpt'):
+            target = OPENAI_OFFICIAL
+        elif qq_msg.startswith('/revgpt'):
+            target = REV_CHATGPT
+        l = qq_msg.split(' ')
+        if len(l) > 1 and l[1] != "":
+            # 临时对话模式，先记录下之前的语言模型，回答完毕后再切回
+            temp_switch = chosen_provider
+            chosen_provider = target
+            qq_msg = l[1]
+        else:
+            # if role != "admin":
+            #     send_message(platform, message, "你没有权限更换语言模型。", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+            #     return
+            chosen_provider = target
+            save_provider_preference(chosen_provider)
+            send_message(platform, message, f"已切换至【{chosen_provider}】", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+            return
+
     chatgpt_res = ""
 
-    if provider == OPENAI_OFFICIAL:
-        # 检查指令
-        hit, command_result = command_openai_official.check_command(qq_msg, session_id, user_name)
-        print(f"{hit} {command_result}")
-        # hit: 是否触发指令
-        if hit:
-            if command_result != None and command_result[0]:
-                # 是否是画图模式
-                if len(command_result) == 3 and command_result[2] == 'image':
+    if chosen_provider == OPENAI_OFFICIAL: 
+        hit, command_result = command_openai_official.check_command(qq_msg, session_id, user_name, role, platform=platform, message_obj=message, cached_plugins=cached_plugins)
+        # hit: 是否触发了指令
+        if not hit:
+            # 请求ChatGPT获得结果
+            try:
+                chatgpt_res = chatgpt.text_chat(qq_msg, session_id)
+                if OPENAI_OFFICIAL in reply_prefix:
+                    chatgpt_res = reply_prefix[OPENAI_OFFICIAL] + chatgpt_res
+            except (BaseException) as e:
+                print("[System-Err] OpenAI API请求错误, 原因: "+str(e))
+                send_message(platform, message, f"OpenAI API错误, 原因: {str(e)}", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+
+    elif chosen_provider == REV_CHATGPT:
+        hit, command_result = command_rev_chatgpt.check_command(qq_msg, role, platform=platform, message=message, cached_plugins=cached_plugins)
+        if not hit:
+            try:
+                chatgpt_res = str(rev_chatgpt.text_chat(qq_msg))
+                if REV_CHATGPT in reply_prefix:
+                    chatgpt_res = reply_prefix[REV_CHATGPT] + chatgpt_res
+            except BaseException as e:
+                print("[System-Err] RevChatGPT请求错误, 原因: "+str(e))
+                send_message(platform, message, f"RevChatGPT错误, 原因: \n{str(e)}", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+
+    elif chosen_provider == REV_EDGEGPT:
+        if bing_cache_loop == None:
+            if platform == PLATFORM_GOCQ:
+                bing_cache_loop = gocq_loop
+            elif platform == PLATFORM_QQCHAN:
+                bing_cache_loop = qqchan_loop
+        hit, command_result = command_rev_edgegpt.check_command(qq_msg, bing_cache_loop, role, platform=platform, message_obj=message, cached_plugins=cached_plugins)
+        if not hit:
+            try:
+                while rev_edgegpt.is_busy():
+                    time.sleep(1)
+
+                res, res_code = asyncio.run_coroutine_threadsafe(rev_edgegpt.text_chat(qq_msg, platform), bing_cache_loop).result()
+                if res_code == 0: # bing不想继续话题，重置会话后重试。
+                    send_message(platform, message, "Bing不想继续话题了, 正在自动重置会话并重试。", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+                    asyncio.run_coroutine_threadsafe(rev_edgegpt.forget(), bing_cache_loop).result()
+                    res, res_code = asyncio.run_coroutine_threadsafe(rev_edgegpt.text_chat(qq_msg, platform), bing_cache_loop).result()
+                    if res_code == 0: # bing还是不想继续话题，大概率说明提问有问题。
+                        asyncio.run_coroutine_threadsafe(rev_edgegpt.forget(), bing_cache_loop).result()
+                        send_message(platform, message, "Bing仍然不想继续话题, 会话已重置, 请检查您的提问后重试。", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+                        res = ""
+                chatgpt_res = str(res)
+                if REV_EDGEGPT in reply_prefix:
+                    chatgpt_res = reply_prefix[REV_EDGEGPT] + chatgpt_res
+            except BaseException as e:
+                print("[System-Err] Rev NewBing API错误。原因如下:\n"+str(e))
+                send_message(platform, message, f"Rev NewBing API错误。原因如下：\n{str(e)} \n前往官方频道反馈~", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+
+    # 切换回原来的语言模型
+    if temp_switch != "":
+        chosen_provider = temp_switch
+        
+    # 指令回复
+    if hit:
+        # 检查指令. command_result是一个元组：(指令调用是否成功, 指令返回的文本结果, 指令类型)
+        if command_result != None:
+            command = command_result[2]
+            if command == "keyword":
+                if os.path.exists("keyword.json"):
+                    with open("keyword.json", "r", encoding="utf-8") as f:
+                        keywords = json.load(f)
+
+            # QQ昵称
+            if command == "nick":
+                with open("cmd_config.json", "r", encoding="utf-8") as f:
+                    global nick_qq
+                    nick_qq = json.load(f)["nick_qq"]
+
+            if command_result[0]:
+                # 是否是画图指令
+                if isinstance(command_result, list) and len(command_result) == 3 and command_result[2] == 'draw':
                     for i in command_result[1]:
-                        send_qq_msg(message, i, image_mode=True, msg_ref=command_result[2])
-                else: send_qq_msg(message, command_result[1], msg_ref=msg_ref)
+                        send_message(platform, message, i, msg_ref=msg_ref, image=i, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+                else:
+                    try:
+                        send_message(platform, message, command_result[1], msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+                    except BaseException as e:
+                        send_message(platform, message, f"回复消息出错: {str(e)}", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+
             else:
-                send_qq_msg(message, f"指令调用错误: \n{command_result[1]}", msg_ref=msg_ref)
-            return
-        # 请求chatGPT获得结果
-        try:
-            chatgpt_res = reply_prefix + chatgpt.text_chat(qq_msg, session_id)
-        except (BaseException) as e:
-            print("[System-Err] OpenAI API错误。原因如下:\n"+str(e))
-            if 'exceeded' in str(e):
-                send_qq_msg(message, f"OpenAI API错误。原因：\n{str(e)} \n超额了。可自己搭建一个机器人(Github仓库：QQChannelChatGPT)")
-                return
-            else:
-                f_res = re.sub(r'(https|http)?:\/\/(\w|\.|\/|\?|\=|\&|\%)*\b', '[被隐藏的链接]', str(e), flags=re.MULTILINE)
-                f_res = f_res.replace(".", "·")
-                send_qq_msg(message, f"OpenAI API错误。原因如下：\n{f_res} \n前往官方频道反馈~")
-                return
-        
-    elif provider == REV_CHATGPT:
-        hit, command_result = command_rev_chatgpt.check_command(qq_msg)
-        if hit:
-            if command_result != None and command_result[0]:
-                send_qq_msg(message, command_result[1], msg_ref=msg_ref)
-            else:
-                send_qq_msg(message, f"指令调用错误: \n{command_result[1]}", msg_ref=msg_ref)
-            return
-        try:
-            chatgpt_res = reply_prefix+str(get_rev_ChatGPT_response(qq_msg))
-        except BaseException as e:
-            print("[System-Err] Rev ChatGPT API错误。原因如下:\n"+str(e))
-            send_qq_msg(message, f"Rev ChatGPT API错误。原因如下：\n{str(e)} \n前往官方频道反馈~")
-            return
-    # elif provider == REV_ERNIE:
-    #     try:
-    #         chatgpt_res = reply_prefix+str(rev_ernie.chatViaSelenium(qq_msg))
-    #     except BaseException as e:
-    #         print("[System-Err] Rev ERNIE API错误。原因如下:\n"+str(e))
-    #         send_qq_msg(message, f"Rev ERNIE API错误。原因如下：\n{str(e)} \n前往官方频道反馈~")
-    #         return
-    elif provider == REV_EDGEGPT:
-        hit, command_result = command_rev_edgegpt.check_command(qq_msg, client.loop)
-        if hit:
-            if command_result != None and command_result[0]:
-                try:
-                    send_qq_msg(message, command_result[1], msg_ref=msg_ref)
-                except BaseException as e:
-                    t = command_result[1].replace(".", " . ")
-                    send_qq_msg(message, t, msg_ref=msg_ref)
-            else:
-                send_qq_msg(message, f"指令调用错误: \n{command_result[1]}", msg_ref=msg_ref)
-            return
-        try:
-            if rev_edgegpt.is_busy():
-                send_qq_msg(message, f"[RevBing] 正忙，请稍后再试",msg_ref=msg_ref)
-                return
-            else:
-                chatgpt_res = reply_prefix
-                chatgpt_res += str(asyncio.run_coroutine_threadsafe(rev_edgegpt.text_chat(qq_msg), client.loop).result())
-        except BaseException as e:
-            print("[System-Err] Rev NewBing API错误。原因如下:\n"+str(e))
-            send_qq_msg(message, f"Rev NewBing API错误。原因如下：\n{str(e)} \n前往官方频道反馈~")
-            return
-        
+                send_message(platform, message, f"指令调用错误: \n{str(command_result[1])}", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
+
+        return
+    
+    if chatgpt_res == "":
+        return
+
     # 记录日志
     logf.write(f"{reply_prefix} {str(chatgpt_res)}\n")
     logf.flush()
 
     # 敏感过滤
     # 过滤不合适的词
-    judged_res = chatgpt_res
     for i in uw.unfit_words:
-        judged_res = re.sub(i, "***", judged_res)
+        chatgpt_res = re.sub(i, "***", chatgpt_res)
     # 百度内容审核服务二次审核
     if baidu_judge != None:
-        check, msg = baidu_judge.judge(judged_res)
+        check, msg = baidu_judge.judge(chatgpt_res)
         if not check:
-            send_qq_msg(message, f"你的提问得到的回复【百度内容审核】未通过，不予回复。\n\n{msg}", msg_ref=msg_ref)
+            send_message(platform, message, f"你的提问得到的回复【百度内容审核】未通过，不予回复。\n\n{msg}", msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
             return
+        
     # 发送qq信息
     try:
-        # 防止被qq频道过滤消息
-        gap_chatgpt_res = judged_res.replace(".", " . ")
-        send_qq_msg(message, ''+gap_chatgpt_res, msg_ref=msg_ref)
-        # 发送信息
+        send_message(platform, message, chatgpt_res, msg_ref=msg_ref, gocq_loop=gocq_loop, qqchannel_bot=qqchannel_bot, gocq_bot=gocq_bot)
     except BaseException as e:
-        print("QQ频道API错误: \n"+str(e))
-        f_res = ""
-        for t in chatgpt_res:
-            f_res += t + ' '
-        try:
-            send_qq_msg(message, ''+f_res, msg_ref=msg_ref)
-            # send(message, f"QQ频道API错误：{str(e)}\n下面是格式化后的回答：\n{f_res}")
-        except BaseException as e:
-            # 如果还是不行则过滤url
-            f_res = re.sub(r'(https|http)?:\/\/(\w|\.|\/|\?|\=|\&|\%)*\b', '[被隐藏的链接]', str(e), flags=re.MULTILINE)
-            f_res = f_res.replace(".", "·")
-            send_qq_msg(message, ''+f_res, msg_ref=msg_ref)
-            # send(message, f"QQ频道API错误：{str(e)}\n下面是格式化后的回答：\n{f_res}")
+        print("回复消息错误: \n"+str(e))
 
-        
 '''
 获取统计信息
 '''
 def get_stat(self):
+
     try:
         f = open(abs_path+"configs/stat", "r", encoding="utf-8")
         fjson = json.loads(f.read())
@@ -577,4 +695,60 @@ def get_stat(self):
             session_count += 1
         return guild_count, guild_msg_count, guild_direct_msg_count, session_count
     except:
-        return -1, -1, -1, -1
+        return -1, -1, -1, -1
+    
+
+# QQ频道机器人
+class botClient(botpy.Client):
+    # 收到频道消息
+    async def on_at_message_create(self, message: Message):
+        toggle_count(at=True, message=message)
+        message_reference = Reference(message_id=message.id, ignore_get_message_error=False)
+        new_sub_thread(oper_msg, (message, True, message_reference, PLATFORM_QQCHAN))
+
+    # 收到私聊消息
+    async def on_direct_message_create(self, message: DirectMessage):
+        if direct_message_mode:
+            toggle_count(at=False, message=message)
+            new_sub_thread(oper_msg, (message, False, None, PLATFORM_QQCHAN))
+# QQ机器人
+class gocqClient():
+    # 收到群聊消息
+    @gocq_app.receiver("GroupMessage")
+    async def _(app: CQHTTP, source: GroupMessage):
+        global nick_qq
+        # 将nick_qq转换为元组
+        if nick_qq == None:
+            nick_qq = ("ai",)
+        if isinstance(nick_qq, str):
+            nick_qq = (nick_qq,)
+        if isinstance(nick_qq, list):
+            nick_qq = tuple(nick_qq)
+
+        if isinstance(source.message[0], Plain):
+            if source.message[0].text.startswith(nick_qq):
+                _len = 0
+                for i in nick_qq:
+                    if source.message[0].text.startswith(i):
+                        _len = len(i)
+                source.message[0].text = source.message[0].text[_len:].strip()
+                new_sub_thread(oper_msg, (source, True, None, PLATFORM_GOCQ))
+        if isinstance(source.message[0], At):
+            if source.message[0].qq == source.self_id:
+                new_sub_thread(oper_msg, (source, True, None, PLATFORM_GOCQ))
+        else:
+            return
+        
+    @gocq_app.receiver("FriendMessage")
+    async def _(app: CQHTTP, source: FriendMessage):
+        if isinstance(source.message[0], Plain):
+            new_sub_thread(oper_msg, (source, False, None, PLATFORM_GOCQ))
+        else:
+            return
+        
+    @gocq_app.receiver("GroupMemberIncrease")
+    async def _(app: CQHTTP, source: GroupMemberIncrease):
+        global nick_qq
+        await app.sendGroupMessage(source.group_id, [
+            Plain(text=f"欢迎加入本群！\n欢迎给https://github.com/Soulter/QQChannelChatGPT项目一个Star😊~\n@我输入help查看帮助~\n我叫{nick_qq}, 你也可以以【{nick_qq}+问题】的格式来提醒我并问我问题哦~\n")
+        ])

launcher.py

@@ -1,69 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from git.repo import Repo
-import os
-# import zipfile
-
-if __name__ == "__main__":
-    # 检测文件夹
-    if not os.path.exists('QQChannelChatGPT'):
-        os.mkdir('QQChannelChatGPT')
-    # if not os.path.exists('pythonemb'):
-    #     os.mkdir('pythonemb')
-
-    # python_path = os.path.join('pythonemb', 'python.zip')
-    # 检测Python环境
-    # if not os.path.exists('pythonemb/python.exe'):
-    #     print("正在从https://www.python.org/ftp/python/3.10.10/python-3.10.10-embed-amd64.zip安装Python环境...")
-    #     os.system('curl -o pythonemb/python.zip https://www.python.org/ftp/python/3.10.10/python-3.10.10-embed-amd64.zip')
-    #     print("解压中...")
-    #     file=zipfile.ZipFile(python_path)
-    #     for name in file.namelist():
-    #         file.extract(name, path='pythonemb')
-    #     print("解压完毕, 创建pip...")
-    #     os.system('curl https://bootstrap.pypa.io/get-pip.py -o pythonemb\get-pip.py')
-    #     os.system('pythonemb\python.exe pythonemb\get-pip.py')
-    #     print("pip创建完毕")
-    #     print("Python环境安装完成")
-
-
-    project_path = os.path.join('QQChannelChatGPT')
-    try:
-        repo = Repo(project_path)
-        # 检查当前commit的hash值
-        commit_hash = repo.head.object.hexsha
-        print("当前commit的hash值为: " + commit_hash)
-
-        # 得到远程仓库的origin的commit的列表
-        origin = repo.remotes.origin
-        try:
-            origin.fetch()
-        except:
-            pass
-        # 得到远程仓库的commit的hash值
-        remote_commit_hash = origin.refs.master.commit.hexsha
-        print("https://github.com/Soulter/QQChannelChatGPT的commit的hash值为: " + remote_commit_hash)
-        # 比较两个commit的hash值
-        if commit_hash != remote_commit_hash:
-            res = input("检测到项目有更新, 是否更新? (y/n): ")
-            if res == 'y':
-                repo.remotes.origin.pull()
-                print("项目更新完毕")
-            if res == 'n':
-                print("已取消更新")
-    except:
-        print("正在从https://github.com/Soulter/QQChannelChatGPT.git拉取项目...")
-        Repo.clone_from('https://github.com/Soulter/QQChannelChatGPT.git',to_path=project_path,branch='61-enhancement-重构代码增强稳定性')
-        print("项目拉取完毕")
-        print("【重要提醒】如果你没有Python环境, 请先安装Python环境! 否则接下来的操作会造成闪退。")
-        print("【重要提醒】Python3.9淘宝下载地址: https://npm.taobao.org/mirrors/python/3.9.7/python-3.9.7-amd64.exe ")
-        print("【重要提醒】安装时, 请务必勾选“Add Python 3.9 to PATH”选项。")
-        print("【重要提醒】QQ: 905617992")
-        input("已确保安装了Python3.9+的版本，按下回车继续...")
-        print("正在安装依赖库...")
-        os.system('python -m pip install -r QQChannelChatGPT\\requirements.txt')
-        print("依赖库安装完毕")
-        input("初次启动, 请先在QQChannelChatGPT/configs/config.yaml填写相关配置! 按任意键继续...")
-    finally:
-        print("正在启动项目...")
-        os.system('python QQChannelChatGPT\main.py')

main.py

@@ -1,20 +1,20 @@
 import threading
-import time
 import asyncio
 import os, sys
-import signal
-import requests,json
-
+from pip._internal import main as pipmain
 
 abs_path = os.path.dirname(os.path.realpath(sys.argv[0])) + '/'
 
-
 def main(loop, event):
-    import cores.qqbot.core as qqBot
-    import yaml
-
-    ymlfile =  open(abs_path+"configs/config.yaml", 'r', encoding='utf-8')
-    cfg = yaml.safe_load(ymlfile)
+    try:
+        import cores.qqbot.core as qqBot
+        import yaml
+        ymlfile =  open(abs_path+"configs/config.yaml", 'r', encoding='utf-8')
+        cfg = yaml.safe_load(ymlfile)
+    except BaseException as e:
+        print(e)
+        input("yaml库未导入或者配置文件格式错误，请退出程序重试。")
+        exit()
 
     if 'http_proxy' in cfg:
         os.environ['HTTP_PROXY'] = cfg['http_proxy']
@@ -22,142 +22,73 @@ def main(loop, event):
         os.environ['HTTPS_PROXY'] = cfg['https_proxy']
 
     provider = privider_chooser(cfg)
-    print('[System] 当前语言模型提供商: ' + provider)
+    print('[System] 当前语言模型提供商: ' + str(provider))
     # 执行Bot
     qqBot.initBot(cfg, provider)
 
 # 语言模型提供商选择器
 # 目前有：OpenAI官方API、逆向库
 def privider_chooser(cfg):
+    l = []
     if 'rev_ChatGPT' in cfg and cfg['rev_ChatGPT']['enable']:
-        return 'rev_chatgpt'
-    elif 'rev_ernie' in cfg and cfg['rev_ernie']['enable']:
-        return 'rev_ernie'
-    elif 'rev_edgegpt' in cfg and cfg['rev_edgegpt']['enable']:
-        return 'rev_edgegpt'
-    else:
-        return 'openai_official'
-
-# 仅支持linux
-def hot_update():
-    target = 'target.tar'
-    time.sleep(5)
-    while(True):
-        if os.path.exists('version.txt'):
-            version_file = open('version.txt', 'r', encoding='utf-8')
-            vs = version_file.read()
-            version = float(vs)
-        else:
-            version = 0
-        if not os.path.exists(target):
-            version = 0
-        try:
-            res = requests.get("https://soulter.top/channelbot/update.json")
-            res_obj = json.loads(res.text)
-            ol_version = float(res_obj['version'])
-            if ol_version > version:
-                print('发现新版本: ' + str(ol_version))
-                res = requests.get(res_obj['linux-url'], stream=True)
-                filesize = res.headers["Content-Length"]
-                print('文件大小: ' + str(int(filesize) / 1024 / 1024) + 'MB')
-                print('正在更新文件...')
-                chunk_size = 1024
-                times = int(filesize) // chunk_size
-                show = 1 / times
-                show2 = 1 / times
-                start = 1
-                with open(target, "wb") as pyFile:
-                    for chunk in res.iter_content(chunk_size=chunk_size):
-                        if chunk:
-                            pyFile.write(chunk)
-                        if start <= times:
-                            print(f"\r下载进度: {show:.2%}",end="",flush=True)
-                            start += 1
-                            show += show2
-                        else:
-                            sys.stdout.write(f"下载进度: 100%\n")
-                print('更新完成')
-                print('解压覆盖')
-                os.system(f"tar -zxvf {target}")
-                version = ol_version
-                version_file = open('version.txt', 'w+', encoding='utf-8')
-                version_file.write(str(res_obj['version']))
-                version_file.flush()
-                version_file.close()
-
-                try:
-                    update_version(version)
-                except BaseException as e:
-                    print(e)
-                
-                print('自启动')
-                py = sys.executable
-                os.execl(py, py, *sys.argv)
-            time.sleep(60*60*3)
-        except BaseException as e:
-            print(e)
-            print("upd出现异常, 请联系QQ905617992")
-            time.sleep(60*60*3)
-
-def update_version(ver):
-    if not os.path.exists('update_record'):
-        object_id = ''
-    else:
-        object_id = open("update_record", 'r', encoding='utf-8').read()
-    addr = 'unknown'
-    try:
-        addr = requests.get('http://myip.ipip.net', timeout=5).text
-    except BaseException:
-        pass
-    try:
-        ts = str(time.time())
-        # md = hashlib.md5((ts+'QAZ1rQLY1ZufHrZlpuUiNff7').encode())
-        headers = {
-            'X-LC-Id': 'UqfXTWW15nB7iMT0OHvYrDFb-gzGzoHsz',
-            'X-LC-Key': 'QAZ1rQLY1ZufHrZlpuUiNff7',
-            'Content-Type': 'application/json'
-        }
-        d = {"data": {'version':'win-hot-update'+str(ver), 'addr': addr}}
-        d = json.dumps(d).encode("utf-8")
-        res = requests.put(f'https://uqfxtww1.lc-cn-n1-shared.com/1.1/classes/version_record/{object_id}', headers = headers, data = d)
-        if json.loads(res.text)['code'] == 1:
-            res = requests.post(f'https://uqfxtww1.lc-cn-n1-shared.com/1.1/classes/version_record', headers = headers, data = d)
-            object_id = json.loads(res.text)['objectId']
-            object_id_file = open("update_record", 'w+', encoding='utf-8')
-            object_id_file.write(str(object_id))
-            object_id_file.flush()
-            object_id_file.close()
-    except BaseException as e:
-        print(e)
+        l.append('rev_chatgpt')
+    if 'rev_ernie' in cfg and cfg['rev_ernie']['enable']:
+        l.append('rev_ernie')
+    if 'rev_edgegpt' in cfg and cfg['rev_edgegpt']['enable']:
+        l.append('rev_edgegpt')
+    if 'openai' in cfg and cfg['openai']['key'] != None and len(cfg['openai']['key'])>0:
+        l.append('openai_official')
+    return l
 
 def check_env():
     if not (sys.version_info.major == 3 and sys.version_info.minor >= 8):
         print("请使用Python3.8运行本项目")
         input("按任意键退出...")
         exit()
+
+    # 检查pip
+    # pip_tag = "pip"
+    # mm = os.system("pip -V")
+    # if mm != 0:
+    #     mm1 = os.system("pip3 -V")
+    #     if mm1 != 0:
+    #         print("未检测到pip, 请安装Python(版本应>=3.9)")
+    #         input("按任意键退出...")
+    #         exit()
+    #     else:
+    #         pip_tag = "pip3"
+    
+    if os.path.exists('requirements.txt'):
+        pth = 'requirements.txt'
+    else:
+        pth = 'QQChannelChatGPT'+ os.sep +'requirements.txt'
+    print("正在更新三方依赖库...")
     try:
-        import openai
-        import botpy
-        import yaml
-    except Exception as e:
-        # print(e)
-        try:
-            print("安装依赖库中...")
-            os.system("pip3 install openai")
-            os.system("pip3 install qq-botpy")
-            os.system("pip3 install pyyaml")
-            print("安装依赖库完毕...")
-        except BaseException:
-            print("\n安装第三方库异常.请自行安装或者联系QQ905617992.")
-        
-    # 检查key
-    with open(abs_path+"configs/config.yaml", 'r', encoding='utf-8') as ymlfile:
-        import yaml
-        cfg = yaml.safe_load(ymlfile)
-        if cfg['openai']['key'] == '' or cfg['openai']['key'] == None:
-            print("请先在configs/config.yaml下添加一个可用的OpenAI Key。详情请前往https://beta.openai.com/account/api-keys")
-        if cfg['qqbot']['appid'] == '' or cfg['qqbot']['token'] == '' or cfg['qqbot']['appid'] == None or cfg['qqbot']['token'] == None: 
-            print("请先在configs/config.yaml下完善appid和token令牌(在https://q.qq.com/上注册一个QQ机器人即可获得)")
+        pipmain(['install', '-r', pth])
+        print("依赖库安装完毕。")
+    except BaseException as e:
+        print(e)
+        while True:
+            res = input("依赖库可能安装失败了。\n如果是报错ValueError: check_hostname requires server_hostname，请尝试先关闭代理后重试。\n输入y回车重试\n输入c回车使用国内镜像源下载\n输入其他按键回车继续往下执行。")
+            if res == "y":
+                try:
+                    pipmain(['install', '-r', pth])
+                    print("依赖库安装完毕。")
+                    break
+                except BaseException as e:
+                    print(e)
+                    continue
+
+            elif res == "c":
+                try:
+                    pipmain(['install', '-r', pth, '-i', 'https://mirrors.aliyun.com/pypi/simple/'])
+                    print("依赖库安装完毕。")
+                    break
+                except BaseException as e:
+                    print(e)
+                    continue
+            else:
+                break
 
 def get_platform():
     import platform
@@ -172,15 +103,20 @@ def get_platform():
         print("other")
 
 if __name__ == "__main__":
-    global pid
-    pid = os.getpid()
-    global ma_type
-    print("程序PID:"+str(pid))
     check_env()
+
+    # 获取参数
+    args = sys.argv
+    if len(args) > 1:
+        if args[1] == '-replit':
+            print("[System] 启动Replit Web保活服务...")
+            try:
+                from webapp_replit import keep_alive
+                keep_alive()
+            except BaseException as e:
+                print(e)
+                print(f"[System-err] Replit Web保活服务启动失败:{str(e)}")
+
     bot_event = threading.Event()
     loop = asyncio.get_event_loop()
-    # ma_type = get_platform()
-    # if ma_type == 'linux':
-    #     threading.Thread(target=hot_update).start()
-        
     main(loop, bot_event)

model/command/command.py

@@ -1,53 +1,351 @@
-import abc
 import json
+import git.exc
 from git.repo import Repo
 import os
 import sys
-
-
 import requests
 from model.provider.provider import Provider
+import json
+import util.plugin_util as putil
+import shutil
+import importlib
 
+PLATFORM_QQCHAN = 'qqchan'
+PLATFORM_GOCQ = 'gocq'
+
+# 指令功能的基类，通用的（不区分语言模型）的指令就在这实现
 class Command:
     def __init__(self, provider: Provider):
         self.provider = Provider
 
-    @abc.abstractmethod
-    def check_command(self, message):
-        if message.startswith("help") or message.startswith("帮助"):
-            return True, self.help()
+    def get_plugin_modules(self):
+        plugins = []
+        try:
+            if os.path.exists("addons/plugins"):
+                plugins = putil.get_modules("addons/plugins")
+                return plugins
+            elif os.path.exists("QQChannelChatGPT/addons/plugins"):
+                plugins = putil.get_modules("QQChannelChatGPT/addons/plugins")
+                return plugins
+            else:
+                return None
+        except BaseException as e:
+            raise e
+
+    def check_command(self, message, role, platform, message_obj, cached_plugins: dict):
+        # 插件
+
+        for k, v in cached_plugins.items():
+            try:
+                hit, res = v["clsobj"].run(message, role, platform, message_obj)
+                if hit:
+                    return True, res
+            except BaseException as e:
+                print(f"[Debug] {k}插件加载出现问题，原因: {str(e)}\n已安装插件: {cached_plugins.keys}\n如果你没有相关装插件的想法, 请直接忽略此报错, 不影响其他功能的运行。")
+
+        if self.command_start_with(message, "nick"):
+            return True, self.set_nick(message, platform)
+        
+        if self.command_start_with(message, "plugin"):
+            return True, self.plugin_oper(message, role, cached_plugins)
+        
         return False, None
     
-    def update(self, message: str):
+    def plugin_reload(self, cached_plugins: dict, target: str = None, all: bool = False):
+        plugins = self.get_plugin_modules()
+        fail_rec = ""
+        if plugins != None:
+            for p in plugins:
+                try:
+                    if p not in cached_plugins or p == target or all:
+                        module = __import__("addons.plugins." + p + "." + p, fromlist=[p])
+                        if p in cached_plugins:
+                            module = importlib.reload(module)
+                        cls = putil.get_classes(p, module)
+                        obj = getattr(module, cls[0])()
+                        try:
+                            info = obj.info()
+                            if 'name' not in info or 'desc' not in info or 'version' not in info or 'author' not in info:
+                                fail_rec += f"载入插件{p}失败，原因: 插件信息不完整\n"
+                                continue
+                            if isinstance(info, dict) == False:
+                                fail_rec += f"载入插件{p}失败，原因: 插件信息格式不正确\n"
+                                continue
+                        except BaseException as e:
+                            fail_rec += f"调用插件{p} info失败, 原因: {str(e)}\n"
+                            continue
+                        cached_plugins[p] = {
+                            "module": module,
+                            "clsobj": obj,
+                            "info": info
+                        }  
+                except BaseException as e:
+                    fail_rec += f"加载{p}插件出现问题，原因{str(e)}\n"
+            if fail_rec == "":
+                return True, None
+            else:
+                return False, fail_rec
+        else:
+            return False, "未找到任何插件模块"
+    
+    '''
+    插件指令
+    '''
+    def plugin_oper(self, message: str, role: str, cached_plugins: dict):
+        l = message.split(" ")
+        if len(l) < 2:
+            return True, "\n=====插件指令面板=====\n安装插件: \nplugin i 插件Github地址\n卸载插件: \nplugin i 插件名 \n重载插件: \nplugin reload\n查看插件列表：\nplugin l\n更新插件: plugin u 插件名\n===============", "plugin"
+        else:
+            ppath = ""
+            if os.path.exists("addons/plugins"):
+                ppath = "addons/plugins"
+            elif os.path.exists("QQChannelChatGPT/addons/plugins"):
+                ppath = "QQChannelChatGPT/addons/plugins"
+            else:
+                return False, "未找到插件目录", "plugin"
+            if l[1] == "i":
+                if role != "admin":
+                    return False, f"你的身份组{role}没有权限安装插件", "plugin"
+                try:
+                    # 得到url的最后一段
+                    d = l[2].split("/")[-1]
+                    # 创建文件夹
+                    plugin_path = os.path.join(ppath, d)
+                    if os.path.exists(plugin_path):
+                        shutil.rmtree(plugin_path)
+                    os.mkdir(plugin_path)
+                    Repo.clone_from(l[2],to_path=plugin_path,branch='master')
+
+                    # 读取插件的requirements.txt
+                    if os.path.exists(os.path.join(plugin_path, "requirements.txt")):
+                        with open(os.path.join(plugin_path, "requirements.txt"), "r", encoding="utf-8") as f:
+                            for line in f.readlines():
+                                mm = os.system(f"pip3 install {line.strip()}")
+                                if mm != 0:
+                                    return False, "插件依赖安装失败，需要您手动pip安装对应插件的依赖。", "plugin"
+                    # 加载没缓存的插件
+                    ok, err = self.plugin_reload(cached_plugins, target=d)
+                    if ok:
+                        return True, "插件拉取并载入成功~", "plugin"
+                    else:
+                        # if os.path.exists(plugin_path):
+                        #     shutil.rmtree(plugin_path)
+                        return False, f"插件拉取载入失败。\n跟踪: \n{err}", "plugin"
+                except BaseException as e:
+                    return False, f"拉取插件失败，原因: {str(e)}", "plugin"
+            elif l[1] == "d":
+                if role != "admin":
+                    return False, f"你的身份组{role}没有权限删除插件", "plugin"
+                try:
+                    # 删除文件夹
+                    shutil.rmtree(os.path.join(ppath, l[2]))
+                    if l[2] in cached_plugins:
+                        del cached_plugins[l[2]]
+                    return True, "插件卸载成功~", "plugin"
+                except BaseException as e:
+                    return False, f"卸载插件失败，原因: {str(e)}", "plugin"
+            elif l[1] == "u":
+                plugin_path = os.path.join(ppath, l[2])
+                try:
+                    repo = Repo(path = plugin_path)
+                    repo.remotes.origin.pull()
+                    ok, err = self.plugin_reload(cached_plugins, target=l[2])
+                    if ok:
+                        return True, "\n更新插件成功!!", "plugin"
+                    else:
+                        return False, "更新插件成功，但是重载插件失败。\n问题跟踪: \n"+err, "plugin"
+                except BaseException as e:
+                    return False, "更新插件失败, 请使用plugin i指令覆盖安装", "plugin"
+
+            elif l[1] == "l":
+                try:
+                    plugin_list_info = "\n".join([f"{k}: \n名称: {v['info']['name']}\n简介: {v['info']['desc']}\n版本: {v['info']['version']}\n作者: {v['info']['author']}\n" for k, v in cached_plugins.items()])
+                    return True, "\n=====已激活插件列表=====\n" + plugin_list_info + "\n使用plugin v 插件名 查看插件帮助\n=================", "plugin"
+                except BaseException as e:
+                    return False, f"获取插件列表失败，原因: {str(e)}", "plugin"
+            elif l[1] == "v":
+                try:
+                    if l[2] in cached_plugins:
+                        info = cached_plugins[l[2]]["info"]
+                        res = f"\n=====插件信息=====\n名称: {info['name']}\n{info['desc']}\n版本: {info['version']}作者: {info['author']}\n\n帮助:\n{info['help']}"
+                        return True, res, "plugin"
+                    else:
+                        return False, "未找到该插件", "plugin"
+                except BaseException as e:
+                    return False, f"获取插件信息失败，原因: {str(e)}", "plugin"
+            elif l[1] == "reload":
+                if role != "admin":
+                    return False, f"你的身份组{role}没有权限重载插件", "plugin"
+                try:
+                    ok, err = self.plugin_reload(cached_plugins, all = True)
+                    if ok:
+                        return True, "\n重载插件成功~", "plugin"
+                    else:
+                        # if os.path.exists(plugin_path):
+                        #     shutil.rmtree(plugin_path)
+                        return False, f"插件重载失败。\n跟踪: \n{err}", "plugin"
+                except BaseException as e:
+                    return False, f"插件重载失败，原因: {str(e)}", "plugin"
+                
+            elif l[1] == "dev":
+                if role != "admin":
+                    return False, f"你的身份组{role}没有权限开发者模式", "plugin"
+                return True, "cached_plugins: \n" + str(cached_plugins), "plugin"
+
+
+    '''
+    nick: 存储机器人的昵称
+    '''
+    def set_nick(self, message: str, platform: str):
+        if platform == PLATFORM_GOCQ:
+            l = message.split(" ")
+            if len(l) == 1:
+                return True, "【设置机器人昵称】示例：\n支持多昵称\nnick 昵称1 昵称2 昵称3", "nick"
+            nick = l[1:]
+            self.general_command_storer("nick_qq", nick)
+            return True, f"设置成功！现在你可以叫我这些昵称来提问我啦~", "nick"
+        elif platform == PLATFORM_QQCHAN:
+            nick = message.split(" ")[2]
+            return False, "QQ频道平台不支持为机器人设置昵称。", "nick"
+    
+    """
+    存储指令结果到cmd_config.json
+    """
+    def general_command_storer(self, key, value):
+        if not os.path.exists("cmd_config.json"):
+            config = {}
+        else:
+            with open("cmd_config.json", "r", encoding="utf-8") as f:
+                config = json.load(f)
+        config[key] = value
+        with open("cmd_config.json", "w", encoding="utf-8") as f:
+            json.dump(config, f, indent=4, ensure_ascii=False)
+            f.flush()
+
+    
+    def general_commands(self):
+        return {
+            "help": "帮助",
+            "keyword": "设置关键词/关键指令回复",
+            "update": "更新面板",
+            "update latest": "更新到最新版本",
+            "update r": "重启机器人",
+            "reset": "重置会话",
+            "nick": "设置机器人昵称",
+            "/bing": "切换到bing模型",
+            "/gpt": "切换到OpenAI ChatGPT API",
+            "/revgpt": "切换到网页版ChatGPT",
+            "/bing 问题": "临时使用一次bing模型进行会话",
+            "/gpt 问题": "临时使用一次OpenAI ChatGPT API进行会话",
+            "/revgpt 问题": "临时使用一次网页版ChatGPT进行会话",
+            "plugin": "插件安装、卸载和重载"
+        }
+    
+    def help_messager(self, commands: dict):
+        try:
+            resp = requests.get("https://soulter.top/channelbot/notice.json").text
+            notice = json.loads(resp)["notice"]
+        except BaseException as e:
+            notice = ""
+        msg = "Github项目名QQChannelChatGPT, 有问题提交issue, 欢迎Star\n【指令列表】\n"
+        for key, value in commands.items():
+            msg += key + ": " + value + "\n"
+        msg += notice
+        return msg
+    
+    # 接受可变参数
+    def command_start_with(self, message: str, *args):
+        for arg in args:
+            if message.startswith(arg) or message.startswith('/'+arg):
+                return True
+        return False
+    
+    # keyword: 关键字
+    def keyword(self, message: str, role: str):
+        if role != "admin":
+            return True, "你没有权限使用该指令", "keyword"
+
+        l = message.split(" ")
+
+        if len(l) < 3:
+            return True, "【设置关键词回复】示例：\nkeyword hi 你好\n当发送hi的时候会回复你好\nkeyword /hi 你好\n当发送/hi时会回复你好\n删除关键词: keyword d hi\n删除hi关键词的回复", "keyword"
+        
+        del_mode = False
+        if l[1] == "d":
+            print("删除关键词: "+l[2])
+            del_mode = True    
+
+        try:
+            if os.path.exists("keyword.json"):
+                with open("keyword.json", "r", encoding="utf-8") as f:
+                    keyword = json.load(f)
+                    if del_mode:
+                        # 删除关键词
+                        if l[2] not in keyword:
+                            return False, "该关键词不存在", "keyword"
+                        else: del keyword[l[2]]
+                    else:
+                        keyword[l[1]] = l[2]
+            else:
+                if del_mode:
+                    return False, "该关键词不存在", "keyword"
+                keyword = {l[1]: l[2]}
+            with open("keyword.json", "w", encoding="utf-8") as f:
+                print("设置指令: "+l[1]+" -> "+l[2])
+                json.dump(keyword, f, ensure_ascii=False, indent=4)
+                f.flush()
+            if del_mode:
+                return True, "删除成功: "+l[2], "keyword"
+            return True, "设置成功: "+l[1]+" -> "+l[2], "keyword"
+        except BaseException as e:
+            return False, "设置失败: "+str(e), "keyword"
+    
+    def update(self, message: str, role: str):
+        if role != "admin":
+            return True, "你没有权限使用该指令", "keyword"
         l = message.split(" ")
         if len(l) == 1:
             # 得到本地版本号和最新版本号
-            repo = Repo()
+            try:
+                repo = Repo()
+            except git.exc.InvalidGitRepositoryError:
+                repo = Repo(path="QQChannelChatGPT")
             now_commit = repo.head.commit
 
-            # 得到最新的5条commit列表, 包含commit信息
+            # 得到远程3条commit列表, 包含commit信息
             origin = repo.remotes.origin
             origin.fetch()
-            commits = list(repo.iter_commits('master', max_count=5))
+            commits = list(repo.iter_commits('master', max_count=3))
             commits_log = ''
             index = 1
             for commit in commits:
-                commits_log += f"[{index}] {commit.message}\n-----------\n"
+                if commit.message.endswith("\n"):
+                    commits_log += f"[{index}] {commit.message}-----------\n"
+                else:
+                    commits_log += f"[{index}] {commit.message}\n-----------\n"
                 index+=1
             remote_commit_hash = origin.refs.master.commit.hexsha[:6]
 
-            return True, f"当前版本: {now_commit.hexsha[:6]}\n最新版本: {remote_commit_hash}\n\n最新5条commit:\n{str(commits_log)}\n使用update latest更新至最新版本\n"
+            return True, f"当前版本: {now_commit.hexsha[:6]}\n最新版本: {remote_commit_hash}\n\n3条commit(非最新):\n{str(commits_log)}\n使用update latest更新至最新版本\n", "update"
         else:
             if l[1] == "latest":
+                pash_tag = ""
                 try:
-                    repo = Repo()
+                    try:
+                        repo = Repo()
+                    except git.exc.InvalidGitRepositoryError:
+                        repo = Repo(path="QQChannelChatGPT")
+                        pash_tag = "QQChannelChatGPT"+os.sep
                     repo.remotes.origin.pull()
-                    py = sys.executable
-                    os.execl(py, py, *sys.argv)
-                    return True, "更新成功"
+
+                    return True, "更新成功~是否重启？输入update r重启（重启指令不返回任何确认信息）。", "update"
                     
                 except BaseException as e:
-                    return False, "更新失败: "+str(e)
+                    return False, "更新失败: "+str(e), "update"
+            if l[1] == "r":
+                py = sys.executable
+                os.execl(py, py, *sys.argv)
+
 
     def reset(self):
         return False
@@ -62,15 +360,7 @@ class Command:
         return False
     
     def help(self):
-        # ol_version = 'Unknown'
-        # try:
-        #     res = requests.get("https://soulter.top/channelbot/update.json")
-        #     res_obj = json.loads(res.text)
-        #     ol_version = res_obj['version']
-        # except BaseException:
-        #     pass
-        return True, f"[Github项目名: QQChannelChatGPT，有问题请前往提交issue，欢迎Star此项目~]\n\n指令面板：\nstatus 查看机器人key状态\ncount 查看机器人统计信息\nreset 重置会话\nhis 查看历史记录\ntoken 查看会话token数\nhelp 查看帮助\nset 人格指令菜单\nkey 动态添加key"
-    
+        return False
     
     def status(self):
         return False

model/command/command_openai_official.py

@@ -5,38 +5,65 @@ from cores.qqbot.personality import personalities
 class CommandOpenAIOfficial(Command):
     def __init__(self, provider: ProviderOpenAIOfficial):
         self.provider = provider
+        self.cached_plugins = {}
         
-    def check_command(self, message: str, session_id: str, user_name: str):
-        if message.startswith("reset") or message.startswith("重置"):
+    def check_command(self, 
+                      message: str, 
+                      session_id: str, 
+                      user_name: str, 
+                      role: str, 
+                      platform: str,
+                      message_obj,
+                      cached_plugins: dict):
+        hit, res = super().check_command(message, role, platform, message_obj=message_obj, cached_plugins=cached_plugins)
+        if hit:
+            return True, res
+        if self.command_start_with(message, "reset", "重置"):
             return True, self.reset(session_id)
-        elif message.startswith("his") or message.startswith("历史"):
+        elif self.command_start_with(message, "his", "历史"):
             return True, self.his(message, session_id, user_name)
-        elif message.startswith("token"):
+        elif self.command_start_with(message, "token"):
             return True, self.token(session_id)
-        elif message.startswith("gpt"):
+        elif self.command_start_with(message, "gpt"):
             return True, self.gpt()
-        elif message.startswith("status") or message.startswith("状态"):
+        elif self.command_start_with(message, "status"):
             return True, self.status()
-        elif message.startswith("count") or message.startswith("统计"):
+        elif self.command_start_with(message, "count"):
             return True, self.count()
-        elif message.startswith("help") or message.startswith("帮助"):
+        elif self.command_start_with(message, "help", "帮助"):
             return True, self.help()
-        elif message.startswith("key") or message.startswith("动态添加key"):
-            return True, self.key(message, user_name)
-        elif message.startswith("unset"):
+        elif self.command_start_with(message, "unset"):
             return True, self.unset(session_id)
-        elif message.startswith("set"):
+        elif self.command_start_with(message, "set"):
             return True, self.set(message, session_id)
-        elif message.startswith("画"):
+        elif self.command_start_with(message, "update"):
+            return True, self.update(message, role)
+        elif self.command_start_with(message, "画"):
             return True, self.draw(message)
-        elif message.startswith("update"):
-            return True, self.update(message)
+        elif self.command_start_with(message, "keyword"):
+            return True, self.keyword(message, role)
+        elif self.command_start_with(message, "key"):
+            return True, self.key(message, user_name)
+        
+        if self.command_start_with(message, "/"):
+            return True, (False, "未知指令", "unknown_command")
         
         return False, None
     
+    def help(self):
+        commands = super().general_commands()
+        commands['画'] = '画画'
+        commands['key'] = '添加OpenAI key'
+        commands['set'] = '人格设置面板'
+        commands['gpt'] = '查看gpt配置信息'
+        commands['status'] = '查看key使用状态'
+        commands['token'] = '查看本轮会话token'
+        return True, super().help_messager(commands), "help"
+
+    
     def reset(self, session_id: str):
         self.provider.forget(session_id)
-        return True, "重置成功"
+        return True, "重置成功", "reset"
     
     def his(self, message: str, session_id: str, name: str):
         #分页，每页5条
@@ -48,17 +75,17 @@ class CommandOpenAIOfficial(Command):
         # 检查是否有过历史记录
         if session_id not in self.provider.session_dict:
             msg = f"历史记录为空"
-            return True, msg
+            return True, msg, "his"
         l = self.provider.session_dict[session_id]
         max_page = len(l)//size_per_page + 1 if len(l)%size_per_page != 0 else len(l)//size_per_page
         p = self.provider.get_prompts_by_cache_list(self.provider.session_dict[session_id], divide=True, paging=True, size=size_per_page, page=page)
-        return True, f"历史记录如下：\n{p}\n第{page}页 | 共{max_page}页\n*输入/his 2跳转到第2页"
+        return True, f"历史记录如下：\n{p}\n第{page}页 | 共{max_page}页\n*输入/his 2跳转到第2页", "his"
     
     def token(self, session_id: str):
-        return True, f"会话的token数: {self.provider.get_user_usage_tokens(self.provider.session_dict[session_id])}\n系统最大缓存token数: {self.provider.max_tokens}"
+        return True, f"会话的token数: {self.provider.get_user_usage_tokens(self.provider.session_dict[session_id])}\n系统最大缓存token数: {self.provider.max_tokens}", "token"
 
     def gpt(self):
-        return True, f"OpenAI GPT配置:\n {self.provider.chatGPT_configs}"
+        return True, f"OpenAI GPT配置:\n {self.provider.chatGPT_configs}", "gpt"
     
     def status(self):
         chatgpt_cfg_str = ""
@@ -78,52 +105,52 @@ class CommandOpenAIOfficial(Command):
                 sponsor = key_stat[key]['sponsor']
             chatgpt_cfg_str += f"  |-{index}: {key_stat[key]['used']}/{max} {sponsor}赞助{tag}\n"
             index += 1
-        return True, f"⭐使用情况({str(gg_count)}个已用):\n{chatgpt_cfg_str}⏰全频道已用{total}tokens"
+        return True, f"⭐使用情况({str(gg_count)}个已用):\n{chatgpt_cfg_str}⏰全频道已用{total}tokens", "status"
 
     def count(self):
         guild_count, guild_msg_count, guild_direct_msg_count, session_count = self.provider.get_stat()
-        return True, f"当前会话数: {len(self.provider.session_dict)}\n共有频道数: {guild_count} \n共有消息数: {guild_msg_count}\n私信数: {guild_direct_msg_count}\n历史会话数: {session_count}"
+        return True, f"当前会话数: {len(self.provider.session_dict)}\n共有频道数: {guild_count} \n共有消息数: {guild_msg_count}\n私信数: {guild_direct_msg_count}\n历史会话数: {session_count}", "count"
 
     def key(self, message: str, user_name: str):
         l = message.split(" ")
         if len(l) == 1:
             msg = "感谢您赞助key，key为官方API使用，请以以下格式赞助:\n/key xxxxx"
-            return True, msg
+            return True, msg, "key"
         key = l[1]
         if self.provider.check_key(key):
             self.provider.append_key(key, user_name)
             return True, f"*★,°*:.☆(￣▽￣)/$:*.°★* 。\n该Key被验证为有效。感谢{user_name}赞助~"
         else:
-            return True, "该Key被验证为无效。也许是输入错误了，或者重试。"
+            return True, "该Key被验证为无效。也许是输入错误了，或者重试。", "key"
 
     def unset(self, session_id: str):
         self.provider.now_personality = {}
         self.provider.forget(session_id)
-        return True, "已清除人格并重置历史记录。"
+        return True, "已清除人格并重置历史记录。", "unset"
 
     def set(self, message: str, session_id: str):
         l = message.split(" ")
         if len(l) == 1:
             return True, f"【由Github项目QQChannelChatGPT支持】\n\n【人格文本由PlexPt开源项目awesome-chatgpt-pr \
         ompts-zh提供】\n\n这个是人格设置指令。\n设置人格: \n/set 人格名。例如/set 编剧\n人格列表: /set list\n人格详细信息: \
-        /set view 人格名\n自定义人格: /set 人格文本\n清除人格: /unset\n【当前人格】: {str(self.provider.now_personality)}"
+        /set view 人格名\n自定义人格: /set 人格文本\n清除人格: /unset\n【当前人格】: {str(self.provider.now_personality)}", "set"
         elif l[1] == "list":
             msg = "人格列表：\n"
             for key in personalities.keys():
                 msg += f"  |-{key}\n"
             msg += '\n\n*输入/set view 人格名查看人格详细信息'
             msg += '\n*不定时更新人格库，请及时更新本项目。'
-            return True, msg
+            return True, msg, "set"
         elif l[1] == "view":
             if len(l) == 2:
-                return True, "请输入/set view 人格名"
+                return True, "请输入/set view 人格名", "set"
             ps = l[2].strip()
             if ps in personalities:
                 msg = f"人格{ps}的详细信息：\n"
                 msg += f"{personalities[ps]}\n"
             else:
                 msg = f"人格{ps}不存在"
-            return True, msg
+            return True, msg, "set"
         else:
             ps = l[1].strip()
             if ps in personalities:
@@ -141,7 +168,7 @@ class CommandOpenAIOfficial(Command):
                     'single-tokens': 0
                 }
                 self.provider.session_dict[session_id].append(new_record)
-                return True, f"人格{ps}已设置."
+                return True, f"人格{ps}已设置.", "set"
             else:
                 self.provider.now_personality = {
                     'name': '自定义人格',
@@ -157,17 +184,17 @@ class CommandOpenAIOfficial(Command):
                 }
                 self.provider.session_dict[session_id] = []
                 self.provider.session_dict[session_id].append(new_record)
-                return True, f"自定义人格已设置。 \n人格信息: {ps}"
+                return True, f"自定义人格已设置。 \n人格信息: {ps}", "set"
             
     def draw(self, message):
         try:
             # 画图模式传回3个参数
             img_url = self.provider.image_chat(message)
-            return True, img_url, "image"
+            return True, img_url, "draw"
         except Exception as e:
             if 'exceeded' in str(e):
                 return f"OpenAI API错误。原因：\n{str(e)} \n超额了。可自己搭建一个机器人(Github仓库：QQChannelChatGPT)"
-            return False, f"图片生成失败: {e}"
+            return False, f"图片生成失败: {e}", "draw"
         
     
 

model/command/command_rev_chatgpt.py

@@ -4,19 +4,32 @@ from model.provider.provider_rev_chatgpt import ProviderRevChatGPT
 class CommandRevChatGPT(Command):
     def __init__(self, provider: ProviderRevChatGPT):
         self.provider = provider
-        
-    def check_command(self, message: str):
-        # hit, res = super().check_command(message)
-        # if hit:
-        #     return res
-        # if message.startswith("reset") or message.startswith("重置"):
-        #     return True, self.reset()
-        if message.startswith("help") or message.startswith("帮助"):
+        self.cached_plugins = {}
+
+    def check_command(self, 
+                      message: str, 
+                      role: str, 
+                      platform: str,
+                      message_obj,
+                      cached_plugins: dict):
+        hit, res = super().check_command(message, role, platform, message_obj=message_obj, cached_plugins=cached_plugins)
+        if hit:
+            return True, res
+        if self.command_start_with(message, "help", "帮助"):
             return True, self.help()
-        elif message.startswith("update"):
-            return True, self.update(message)
+        elif self.command_start_with(message, "reset"):
+            return True, self.reset()
+        elif self.command_start_with(message, "update"):
+            return True, self.update(message, role)
+        elif self.command_start_with(message, "keyword"):
+            return True, self.keyword(message, role)
+        
+        if self.command_start_with(message, "/"):
+            return True, (False, "未知指令", "unknown_command")
         return False, None
     
+    def reset(self):
+        return False, "此功能暂未开放", "reset"
+    
     def help(self):
-        return True, "[Github项目名: QQChannelChatGPT，有问题请前往提交issue，欢迎Star此项目~]\n\nRevChatGPT指令面板：\n当前语言模型RevChatGPT未实现任何指令\n"
-    
+        return True, super().help_messager(super().general_commands()), "help"

model/command/command_rev_edgegpt.py

@@ -4,24 +4,40 @@ import asyncio
 class CommandRevEdgeGPT(Command):
     def __init__(self, provider: ProviderRevEdgeGPT):
         self.provider = provider
+        self.cached_plugins = {}
+
         
-    def check_command(self, message: str, loop):
-        if message.startswith("reset") or message.startswith("重置"):
+    def check_command(self, 
+                      message: str, 
+                      loop, 
+                      role: str, 
+                      platform: str,
+                      message_obj,
+                      cached_plugins: dict):
+        hit, res = super().check_command(message, role, platform, message_obj=message_obj, cached_plugins=cached_plugins)
+        if hit:
+            return True, res
+        if self.command_start_with(message, "reset"):
             return True, self.reset(loop)
-        elif message.startswith("help") or message.startswith("帮助"):
+        elif self.command_start_with(message, "help"):
             return True, self.help()
-        elif message.startswith("update"):
-            return True, self.update(message)
+        elif self.command_start_with(message, "update"):
+            return True, self.update(message, role)
+        elif self.command_start_with(message, "keyword"):
+            return True, self.keyword(message, role)
+        
+        if self.command_start_with(message, "/"):
+            return True, (False, "未知指令", "unknown_command")
         return False, None
     
     def reset(self, loop):
         res = asyncio.run_coroutine_threadsafe(self.provider.forget(), loop).result()
         print(res)
         if res:
-            return res, "重置成功"
+            return res, "重置成功", "reset"
         else:
-            return res, "重置失败"
+            return res, "重置失败", "reset"
     
     def help(self):
-        return True, "[Github项目名: QQChannelChatGPT，有问题请前往提交issue，欢迎Star此项目~]\n\nRevBing指令面板:\nreset: 重置\nhelp: 帮助"
+        return True, super().help_messager(super().general_commands()), "help"
         

model/platform/qq.py

@@ -0,0 +1,44 @@
+from nakuru.entities.components import Plain, At, Image
+
+class QQ:
+    def run_bot(self, gocq):
+        self.client = gocq
+        self.client.run()
+
+    async def send_qq_msg(self, 
+                          source, 
+                          res, 
+                          image_mode: bool = False):
+        """
+         res可以是一个数组，也就是gocq的消息链.
+        """
+
+        # print(res)
+        print("[System-Info] 回复QQ消息中..."+str(res))
+
+        if isinstance(res, list) and len(res) > 0:
+            await self.client.sendGroupMessage(source.group_id, res)
+            return
+        # 通过消息链处理
+        if not image_mode:
+            if source.type == "GroupMessage":
+                await self.client.sendGroupMessage(source.group_id, [
+                    At(qq=source.user_id),
+                    Plain(text=res)
+                ])
+            elif source.type == "FriendMessage":
+                await self.client.sendFriendMessage(source.user_id, [
+                    Plain(text=res)
+                ])
+        else:
+            if source.type == "GroupMessage":
+                await self.client.sendGroupMessage(source.group_id, [
+                    At(qq=source.user_id),
+                    Plain(text="好的，我根据你的需要为你生成了一张图片😊"),
+                    Image.fromURL(url=res)
+                ])
+            elif source.type == "FriendMessage":
+                await self.client.sendFriendMessage(source.user_id, [
+                    Plain(text="好的，我根据你的需要为你生成了一张图片😊"),
+                    Image.fromURL(url=res)
+                ])

model/platform/qqchan.py

@@ -0,0 +1,64 @@
+import io
+import botpy
+from PIL import Image
+from botpy.message import Message, DirectMessage
+import re
+import asyncio
+import requests
+from cores.qqbot.personality import personalities
+
+
+class QQChan():
+
+    def run_bot(self, botclient, appid, token):
+        intents = botpy.Intents(public_guild_messages=True, direct_message=True) 
+        self.client = botclient
+        self.client.run(appid=appid, token=token)
+
+    def send_qq_msg(self, message, res, image_mode=False, msg_ref = None):
+        print("[System-Info] 回复QQ频道消息中..."+str(res))
+        if not image_mode:
+            try:
+                if msg_ref is not None:
+                    reply_res = asyncio.run_coroutine_threadsafe(message.reply(content=str(res), message_reference = msg_ref), self.client.loop)
+                else:
+                    reply_res = asyncio.run_coroutine_threadsafe(message.reply(content=str(res)), self.client.loop)
+                reply_res.result()
+            except BaseException as e:
+                # 分割过长的消息
+                if "msg over length" in str(e):
+                    split_res = []
+                    split_res.append(res[:len(res)//2])      
+                    split_res.append(res[len(res)//2:])
+                    for i in split_res:
+                        if msg_ref is not None:
+                            reply_res = asyncio.run_coroutine_threadsafe(message.reply(content=i, message_reference = msg_ref), self.client.loop)
+                        else:
+                            reply_res = asyncio.run_coroutine_threadsafe(message.reply(content=i), self.client.loop)
+                        reply_res.result()
+                else:
+                    # 发送qq信息
+                    try:
+                        # 防止被qq频道过滤消息
+                        res = res.replace(".", " . ")
+                        asyncio.run_coroutine_threadsafe(message.reply(content=res), self.client.loop).result()
+                        # 发送信息
+                    except BaseException as e:
+                        print("QQ频道API错误: \n"+str(e))
+                        res = str.join(" ", res)
+                        try:
+                            asyncio.run_coroutine_threadsafe(message.reply(content=res), self.client.loop).result()
+                        except BaseException as e:
+                            # 如果还是不行则报出错误
+                            res = re.sub(r'(https|http)?:\/\/(\w|\.|\/|\?|\=|\&|\%)*\b', '[被隐藏的链接]', str(e), flags=re.MULTILINE)
+                            res = res.replace(".", "·")
+                            asyncio.run_coroutine_threadsafe(message.reply(content=res), self.client.loop).result()
+                            # send(message, f"QQ频道API错误：{str(e)}\n下面是格式化后的回答：\n{f_res}")
+        else:
+            pic_res = requests.get(str(res), stream=True)
+            if pic_res.status_code == 200:
+                # 将二进制数据转换成图片对象
+                image = Image.open(io.BytesIO(pic_res.content))
+                # 保存图片到本地
+                image.save('tmp_image.jpg')
+            asyncio.run_coroutine_threadsafe(message.reply(file_image='tmp_image.jpg', content=""), self.client.loop)

model/provider/provider_openai_official.py

@@ -1,6 +1,4 @@
 import openai
-import yaml
-from util.errors.errors import PromptExceededError
 import json
 import time
 import os
@@ -302,6 +300,8 @@ class ProviderOpenAIOfficial(Provider):
         while True:
             is_all_exceed = True
             for key in self.key_stat:
+                if key == None:
+                    continue
                 if not self.key_stat[key]['exceed']:
                     is_all_exceed = False
                     openai.api_key = key
@@ -326,6 +326,9 @@ class ProviderOpenAIOfficial(Provider):
             if is_all_exceed:
                 print("[System] 所有Key已超额")
                 return None, False
+            else:
+                print("[System] 在切换key时程序异常。")
+                return None, False
                 
     def getConfigs(self):
         return self.openai_configs

model/provider/provider_rev_chatgpt.py

@@ -1,34 +1,80 @@
 from revChatGPT.V1 import Chatbot
+from revChatGPT import typings
 from model.provider.provider import Provider
 
 class ProviderRevChatGPT(Provider):
     def __init__(self, config):
-        if 'password' in config:
-            config['password'] = str(config['password'])
-        self.bot = Chatbot(config=config)
+        self.rev_chatgpt = []
+        for i in range(0, len(config['account'])):
+            try:
+                print(f"[System] 创建rev_ChatGPT负载{str(i)}中...")
+                if 'password' in config['account'][i]:
+                    config['account'][i]['password'] = str(config['account'][i]['password'])
+                revstat = {
+                    'obj': Chatbot(config=config['account'][i]),
+                    'busy': False
+                }
+                self.rev_chatgpt.append(revstat)
+            except BaseException as e:
+                print(f"[System] 创建rev_ChatGPT负载失败: {str(e)}")
 
     def forget(self) -> bool:
-        self.bot.reset_chat()
-        return True
-
-    def text_chat(self, prompt):
+        return False
+    
+    def request_text(self, prompt: str, bot) -> str:
         resp = ''
         err_count = 0
         retry_count = 5
 
         while err_count < retry_count:
             try:
-                for data in self.bot.ask(prompt):
+                for data in bot.ask(prompt):
                     resp = data["message"]
                 break
+            except typings.Error as e:
+                if e.code == typings.ErrorType.RATE_LIMIT_ERROR:
+                    raise e
+                if e.code == typings.ErrorType.INVALID_ACCESS_TOKEN_ERROR:
+                    raise e
+                if e.code == typings.ErrorType.EXPIRED_ACCESS_TOKEN_ERROR:
+                    raise e
+                if e.code == typings.ErrorType.PROHIBITED_CONCURRENT_QUERY_ERROR:
+                    raise e
+                
+                err_count += 1
+                print(f"[RevChatGPT] 请求出现问题: {str(e)} | 正在重试: {str(err_count)}")
+                if err_count >= retry_count:
+                    raise e
             except BaseException as e:
-                try:
-                    print("[RevChatGPT] 请求出现了一些问题, 正在重试。次数"+str(err_count))
-                    err_count += 1
-                    if err_count >= retry_count:
-                        raise e
-                except BaseException:
-                    err_count += 1
+                err_count += 1
+                print(f"[RevChatGPT] 请求出现问题: {str(e)} | 正在重试: {str(err_count)}")
+                if err_count >= retry_count:
+                    raise e
         
         print("[RevChatGPT] "+str(resp))
-        return resp
+        return resp
+
+    def text_chat(self, prompt):
+        res = ''
+        print("[Debug] "+str(self.rev_chatgpt))
+        err_msg = ''
+        cursor = 0
+        for revstat in self.rev_chatgpt:
+            cursor += 1
+            if not revstat['busy']:
+                try:
+                    revstat['busy'] = True
+                    res = self.request_text(prompt, revstat['obj'])
+                    revstat['busy'] = False
+                    return res.strip()
+                # todo: 细化错误管理
+                except BaseException as e:
+                    revstat['busy'] = False
+                    print(f"请求出现问题: {str(e)}")
+                    err_msg += f"账号{cursor} - 错误原因: {str(e)}"
+                    continue
+            else:
+                err_msg += f"账号{cursor} - 错误原因: 忙碌"
+                continue
+        res = f'回复失败。错误跟踪：{err_msg}'
+        return res

model/provider/provider_rev_edgegpt.py

@@ -1,7 +1,7 @@
-import asyncio
 from model.provider.provider import Provider
 from EdgeGPT import Chatbot, ConversationStyle
 import json
+import os
 
 class ProviderRevEdgeGPT(Provider):
     def __init__(self):
@@ -21,7 +21,7 @@ class ProviderRevEdgeGPT(Provider):
         except BaseException:
             return False
         
-    async def text_chat(self, prompt):
+    async def text_chat(self, prompt, platform = 'none'):
         if self.busy:
              return
         self.busy = True
@@ -32,18 +32,59 @@ class ProviderRevEdgeGPT(Provider):
         while err_count < retry_count:
             try:
                 resp = await self.bot.ask(prompt=prompt, conversation_style=ConversationStyle.creative)
-                resp = resp['item']['messages'][len(resp['item']['messages'])-1]['text']
-                if resp == prompt:
-                    resp += '\n\n如果你没有让我复述你的话，那代表我可能不想和你继续这个话题了，请输入reset重置会话😶'
+                # print("[RevEdgeGPT] "+str(resp))
+                if 'messages' not in resp['item']:
+                    await self.bot.reset()
+                msj_obj = resp['item']['messages'][len(resp['item']['messages'])-1]
+                reply_msg = msj_obj['text']
+                if 'sourceAttributions' in msj_obj:
+                    reply_source = msj_obj['sourceAttributions']
+                else:
+                    reply_source = []
+                if 'throttling' in resp['item']:
+                    throttling = resp['item']['throttling']
+                    # print(throttling)
+                else:
+                    throttling = None
+                if 'I\'m sorry but I prefer not to continue this conversation. I\'m still learning so I appreciate your understanding and patience.' in reply_msg:
+                    self.busy = False
+                    return '', 0
+                if reply_msg == prompt:
+                    # resp += '\n\n如果你没有让我复述你的话，那代表我可能不想和你继续这个话题了，请输入reset重置会话😶'
+                    await self.forget()
+                    err_count += 1
+                    continue
+                if reply_source is None:
+                    # 不想答复
+                    return '', 0
+                else:
+                    if platform != 'qqchan':
+                        index = 1
+                        if len(reply_source) > 0:
+                            reply_msg += "\n\n信息来源:\n"
+                        for i in reply_source:
+                            reply_msg += f"[{str(index)}]: {i['seeMoreUrl']} | {i['providerDisplayName']}\n"
+                            index += 1
+                if throttling is not None:
+                    if throttling['numUserMessagesInConversation'] == throttling['maxNumUserMessagesInConversation']:
+                        # 达到上限，重置会话
+                        await self.forget()
+                    if throttling['numUserMessagesInConversation'] > throttling['maxNumUserMessagesInConversation']:
+                        await self.forget()
+                        err_count += 1
+                        continue
+                    reply_msg += f"\n⌈{throttling['numUserMessagesInConversation']}/{throttling['maxNumUserMessagesInConversation']}⌋"
                 break
             except BaseException as e:
-                print(e.with_traceback)
+                # raise e
+                print(e)
                 err_count += 1
                 if err_count >= retry_count:
+                        self.busy = False
                         raise e
                 print("[RevEdgeGPT] 请求出现了一些问题, 正在重试。次数"+str(err_count))
         self.busy = False
         
-        print("[RevEdgeGPT] "+str(resp))
-        return resp
+        print("[RevEdgeGPT] "+str(reply_msg))
+        return reply_msg, 1
     

requirements.txt

@@ -1,9 +1,10 @@
-requests
-openai
-qq-botpy
-revChatGPT~=4.0.8
-baidu-aip
-EdgeGPT~=0.1.2
-chardet
-Pillow
-GitPython
+requests~=2.28.1
+openai~=0.27.4
+qq-botpy~=1.1.2
+revChatGPT~=5.0.0
+baidu-aip~=4.16.9
+EdgeGPT~=0.1.22.1
+chardet~=5.1.0
+Pillow~=9.4.0
+GitPython~=3.1.31
+nakuru-project-idk~=0.0.2

util/plugin_util.py

@@ -0,0 +1,22 @@
+import os
+import inspect
+
+# 找出模块里所有的类名
+def get_classes(p_name, arg):
+    classes = []
+    clsmembers = inspect.getmembers(arg, inspect.isclass)
+    for (name, _) in clsmembers:
+        # print(name, p_name)
+        if p_name.lower() == name.lower().replace("plugin", ""):
+            classes.append(name)
+            break
+    return classes
+
+# 获取一个文件夹下所有的模块
+def get_modules(path):
+    modules = []
+    for root, dirs, files in os.walk(path):
+        for file in files:
+            if file.endswith(".py") and not file.startswith("__"):
+                modules.append(file[:-3])
+    return modules

webapp_replit.py

@@ -0,0 +1,25 @@
+from flask import Flask
+from threading import Thread
+import datetime
+
+app = Flask(__name__)
+
+
+@app.route('/')
+def main_func():
+  content = "<h1>QQChannelChatGPT Web APP</h1>"
+
+  content += "<p>" + "Online @ " + str(datetime.datetime.now()) + "</p>"
+  content += "<p>欢迎Star本项目！！！</p>"
+  return content
+
+
+def run():
+  app.run(host="0.0.0.0", port=8080)
+  
+
+
+
+def keep_alive():
+  server = Thread(target=run)
+  server.start()