Release v2.5.0

Merge pull request #513 from RockChinQ/feat-function-calling-integration
[Feat] 支持GPT的函数调用功能
2025-11-25 11:29:39 +08:00 · 2023-07-29 18:59:25 +08:00 · 2023-07-29 18:57:29 +08:00 · 2023-07-29 18:55:18 +08:00 · 2023-07-29 18:40:49 +08:00 · 2023-07-29 18:37:03 +08:00
41 changed files with 1288 additions and 429 deletions
--- a/.github/workflows/sync-wiki.yml
+++ b/.github/workflows/sync-wiki.yml
@@ -1,7 +1,14 @@
 name: Update Wiki

 on:
+  pull_request:
+    branches:
+      - master
+    paths:
+      - 'res/wiki/**'
  push:
+    branches:
+      - master
    paths:
      - 'res/wiki/**'

--- a/.github/workflows/update-cmdpriv-template.yml
+++ b/.github/workflows/update-cmdpriv-template.yml
@@ -26,7 +26,7 @@ jobs:
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
-        python -m pip install --upgrade  yiri-mirai openai colorlog func_timeout dulwich Pillow
+        python -m pip install --upgrade  yiri-mirai openai colorlog func_timeout dulwich Pillow CallingGPT

    - name: Copy Scripts
      run: |
--- a/.gitignore
+++ b/.gitignore
@@ -22,4 +22,7 @@ cmdpriv.json
 tips.py
 .venv
 bin/
-.vscode
+.vscode
+test_*
+venv/
+hugchat.json
--- a/README.md
+++ b/README.md
@@ -7,17 +7,23 @@
 [English](README_en.md) | 简体中文

 [![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/QChatGPT?style=flat-square)](https://github.com/RockChinQ/QChatGPT/releases/latest)
+![Wakapi Count](https://wakapi.dev/api/badge/RockChinQ/interval:any/project:QChatGPT)

+
+> 2023/7/29 支持使用GPT的Function Calling功能实现类似ChatGPT Plugin的效果，请见[Wiki中的内容函数节](https://github.com/RockChinQ/QChatGPT/wiki/%E6%8F%92%E4%BB%B6%E5%BC%80%E5%8F%91#%E5%86%85%E5%AE%B9%E5%87%BD%E6%95%B0)  
 > 2023/4/24 支持使用go-cqhttp登录QQ，请查看[此文档](https://github.com/RockChinQ/QChatGPT/wiki/go-cqhttp%E9%85%8D%E7%BD%AE)  
 > 2023/3/18 现已支持GPT-4 API（内测），请查看`config-template.py`中的`completion_api_params`  
 > 2023/3/15 逆向库已支持New Bing，使用方法查看[插件文档](https://github.com/RockChinQ/revLibs)  

+
+**QChatGPT需要Python版本>=3.9**
 - 到[项目Wiki](https://github.com/RockChinQ/QChatGPT/wiki)可了解项目详细信息
 - 官方交流、答疑群: 656285629  
  - **进群提问前请您`确保`已经找遍文档和issue均无法解决**  
- 社区群（内有一键部署包、图形化界面等资源）: 362515018
+- 社区群（内有一键部署包、图形化界面等资源）: 891448839
 - QQ频道机器人见[QQChannelChatGPT](https://github.com/Soulter/QQChannelChatGPT)
 - 欢迎各种形式的贡献，请查看[贡献指引](CONTRIBUTING.md)
+- 购买ChatGPT账号: [此链接](http://fk.kimi.asia)

 ## 🍺模型适配一览

@@ -32,6 +38,7 @@
 - ChatGPT网页版GPT-3.5模型, 由[插件](https://github.com/RockChinQ/revLibs)接入
 - ChatGPT网页版GPT-4模型, 目前需要ChatGPT Plus订阅, 由[插件](https://github.com/RockChinQ/revLibs)接入
 - New Bing逆向库, 由[插件](https://github.com/RockChinQ/revLibs)接入
+- HuggingChat, 由[插件](https://github.com/RockChinQ/revLibs)接入, 仅支持英文

 ### 故事续写

@@ -105,6 +112,7 @@
 <summary>✅支持插件加载🧩</summary>

  - 自行实现插件加载器及相关支持
+  - 支持GPT的Function Calling功能
  - 详细查看[插件使用页](https://github.com/RockChinQ/QChatGPT/wiki/%E6%8F%92%E4%BB%B6%E4%BD%BF%E7%94%A8)
 </details>
 <details>
@@ -159,6 +167,9 @@

 ### - 注册OpenAI账号

+<details>
+<summary>点此查看步骤</summary>
+
 > 若您要直接使用非OpenAI的模型（如New Bing），可跳过此步骤，直接进行之后的部署，完成后按照相关插件的文档进行配置即可

 参考以下文章自行注册
@@ -169,6 +180,8 @@
 注册成功后请前往[个人中心查看](https://beta.openai.com/account/api-keys)api_key  
 完成注册后，使用以下自动化或手动部署步骤

+</details>
+
 ### - 自动化部署

 <details>
@@ -176,6 +189,8 @@

 #### Docker方式

+> docker方式目前仅支持使用mirai登录，若您不**熟悉**docker的操作及相关知识，强烈建议您使用其他方式部署，我们**不会且难以**解决您主机上多个容器的连接问题。
+
 请查看[此文档](res/docs/docker_deploy.md)  
 由[@mikumifa](https://github.com/mikumifa)贡献

@@ -267,6 +282,8 @@ python3 main.py
 详见[Wiki插件使用页](https://github.com/RockChinQ/QChatGPT/wiki/%E6%8F%92%E4%BB%B6%E4%BD%BF%E7%94%A8)  
 开发教程见[Wiki插件开发页](https://github.com/RockChinQ/QChatGPT/wiki/%E6%8F%92%E4%BB%B6%E5%BC%80%E5%8F%91)

+⭐我们已经支持了[GPT的Function Calling能力](https://platform.openai.com/docs/guides/gpt/function-calling)，请查看wiki的插件开发页以查看如何在QChatGPT中使用此功能
+
 <details>
 <summary>查看插件列表</summary>

@@ -280,8 +297,9 @@ python3 main.py

 ### 更多

-欢迎提交新的插件
+[插件列表](https://github.com/stars/RockChinQ/lists/qchatgpt-%E6%8F%92%E4%BB%B6)，欢迎提出issue以提交新的插件

+- [WebwlkrPlugin](https://github.com/RockChinQ/WebwlkrPlugin) - 让机器人能联网！！
 - [revLibs](https://github.com/RockChinQ/revLibs) - 将ChatGPT网页版接入此项目，关于[官方接口和网页版有什么区别](https://github.com/RockChinQ/QChatGPT/wiki/%E5%AE%98%E6%96%B9%E6%8E%A5%E5%8F%A3%E3%80%81ChatGPT%E7%BD%91%E9%A1%B5%E7%89%88%E3%80%81ChatGPT-API%E5%8C%BA%E5%88%AB)
 - [Switcher](https://github.com/RockChinQ/Switcher) - 支持通过指令切换使用的模型
 - [hello_plugin](https://github.com/RockChinQ/hello_plugin) - `hello_plugin` 的储存库形式，插件开发模板
@@ -292,6 +310,7 @@ python3 main.py
 - [chordfish-k/QChartGPT_Emoticon_Plugin](https://github.com/chordfish-k/QChartGPT_Emoticon_Plugin) - 使机器人根据回复内容发送表情包
 - [oliverkirk-sudo/ChatPoeBot](https://github.com/oliverkirk-sudo/ChatPoeBot) - 接入[Poe](https://poe.com/)上的机器人
 - [lieyanqzu/WeatherPlugin](https://github.com/lieyanqzu/WeatherPlugin) - 天气查询插件
+- [SysStatPlugin](https://github.com/RockChinQ/SysStatPlugin) - 查看系统状态
 </details>

 ## 😘致谢
@@ -304,6 +323,6 @@ python3 main.py

 以及所有[贡献者](https://github.com/RockChinQ/QChatGPT/graphs/contributors)和其他为本项目提供支持的朋友们。

-<!-- ## 👍赞赏
+## 👍赞赏

-<img alt="赞赏码" src="res/mm_reward_qrcode_1672840549070.png" width="400" height="400"/> -->
+<img alt="赞赏码" src="res/mm_reward_qrcode_1672840549070.png" width="400" height="400"/>
--- a/README_en.md
+++ b/README_en.md
@@ -7,6 +7,7 @@
 English | [简体中文](README.md)

 [![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/QChatGPT?style=flat-square)](https://github.com/RockChinQ/QChatGPT/releases/latest)
+![Wakapi Count](https://wakapi.dev/api/badge/RockChinQ/interval:any/project:QChatGPT)

 - Refer to [Wiki](https://github.com/RockChinQ/QChatGPT/wiki) to get further information.  
 - Official QQ group: 656285629  
@@ -27,6 +28,7 @@ English | [简体中文](README.md)
 - ChatGPT website edition (GPT-3.5), see [revLibs plugin](https://github.com/RockChinQ/revLibs)
 - ChatGPT website edition (GPT-4), ChatGPT plus subscription required, see [revLibs plugin](https://github.com/RockChinQ/revLibs)
 - New Bing, see [revLibs plugin](https://github.com/RockChinQ/revLibs)
+- HuggingChat, see [revLibs plugin](https://github.com/RockChinQ/revLibs), English only

 ### Story

--- a/config-template.py
+++ b/config-template.py
@@ -195,16 +195,22 @@ encourage_sponsor_at_start = True
 # 注意：较大的prompt_submit_length会导致OpenAI账户额度消耗更快
 prompt_submit_length = 2048

+# 是否在token超限报错时自动重置会话
+# 可在tips.py中编辑提示语
+auto_reset = True
+
 # OpenAI补全API的参数
 # 请在下方填写模型，程序自动选择接口
 # 现已支持的模型有：
 # 
 #    'gpt-4'
-#    'gpt-4-0314'
+#    'gpt-4-0613'
 #    'gpt-4-32k'
-#    'gpt-4-32k-0314'
+#    'gpt-4-32k-0613'
 #    'gpt-3.5-turbo'
-#    'gpt-3.5-turbo-0301'
+#    'gpt-3.5-turbo-16k'
+#    'gpt-3.5-turbo-0613'
+#    'gpt-3.5-turbo-16k-0613'
 #    'text-davinci-003'
 #    'text-davinci-002'
 #    'code-davinci-002'
@@ -241,6 +247,14 @@ process_message_timeout = 30
 # 回复消息时是否显示[GPT]前缀
 show_prefix = False

+# 回复前的强制延迟时间，降低机器人被腾讯风控概率
+# *此机制对命令和消息、私聊及群聊均生效
+# 每次处理时从以下的范围取一个随机秒数，
+# 当此次消息处理时间低于此秒数时，将会强制延迟至此秒数
+# 例如：[1.5, 3]，则每次处理时会随机取一个1.5-3秒的随机数，若处理时间低于此随机数，则强制延迟至此随机秒数
+# 若您不需要此功能，请将force_delay_range设置为[0, 0]
+force_delay_range = [1.5, 3]
+
 # 应用长消息处理策略的阈值
 # 当回复消息长度超过此值时，将使用长消息处理策略
 blob_message_threshold = 256
--- a/main.py
+++ b/main.py
@@ -47,9 +47,9 @@ def init_db():

 def ensure_dependencies():
    import pkg.utils.pkgmgr as pkgmgr
-    pkgmgr.run_pip(["install", "openai", "Pillow", "nakuru-project-idk", "--upgrade",
-                    "-i", "https://pypi.douban.com/simple/",
-                    "--trusted-host", "pypi.douban.com"])
+    pkgmgr.run_pip(["install", "openai", "Pillow", "nakuru-project-idk", "CallingGPT", "--upgrade",
+                    "-i", "https://pypi.tuna.tsinghua.edu.cn/simple",
+                    "--trusted-host", "pypi.tuna.tsinghua.edu.cn"])


 known_exception_caught = False
@@ -134,127 +134,144 @@ def start(first_time_init=False):

    known_exception_caught = False
    try:
-
-        sh = reset_logging()
-        pkg.utils.context.context['logger_handler'] = sh
-
-        # 检查是否设置了管理员
-        if not (hasattr(config, 'admin_qq') and config.admin_qq != 0):
-            # logging.warning("未设置管理员QQ,管理员权限指令及运行告警将无法使用,如需设置请修改config.py中的admin_qq字段")
-            while True:
-                try:
-                    config.admin_qq = int(input("未设置管理员QQ,管理员权限指令及运行告警将无法使用,请输入管理员QQ号: "))
-                    # 写入到文件
-
-                    # 读取文件
-                    config_file_str = ""
-                    with open("config.py", "r", encoding="utf-8") as f:
-                        config_file_str = f.read()
-                    # 替换
-                    config_file_str = config_file_str.replace("admin_qq = 0", "admin_qq = " + str(config.admin_qq))
-                    # 写入
-                    with open("config.py", "w", encoding="utf-8") as f:
-                        f.write(config_file_str)
-
-                    print("管理员QQ已设置，如需修改请修改config.py中的admin_qq字段")
-                    time.sleep(4)
-                    break
-                except ValueError:
-                    print("请输入数字")
-
-        import pkg.openai.manager
-        import pkg.database.manager
-        import pkg.openai.session
-        import pkg.qqbot.manager
-        import pkg.openai.dprompt
-        import pkg.qqbot.cmds.aamgr
-        
        try:
-            pkg.openai.dprompt.register_all()
-            pkg.qqbot.cmds.aamgr.register_all()
-            pkg.qqbot.cmds.aamgr.apply_privileges()
-        except Exception as e:
-            logging.error(e)
-            traceback.print_exc()

-        # 配置openai api_base
-        if "reverse_proxy" in config.openai_config and config.openai_config["reverse_proxy"] is not None:
+            sh = reset_logging()
+            pkg.utils.context.context['logger_handler'] = sh
+
+            # 检查是否设置了管理员
+            if not (hasattr(config, 'admin_qq') and config.admin_qq != 0):
+                # logging.warning("未设置管理员QQ,管理员权限指令及运行告警将无法使用,如需设置请修改config.py中的admin_qq字段")
+                while True:
+                    try:
+                        config.admin_qq = int(input("未设置管理员QQ,管理员权限指令及运行告警将无法使用,请输入管理员QQ号: "))
+                        # 写入到文件
+
+                        # 读取文件
+                        config_file_str = ""
+                        with open("config.py", "r", encoding="utf-8") as f:
+                            config_file_str = f.read()
+                        # 替换
+                        config_file_str = config_file_str.replace("admin_qq = 0", "admin_qq = " + str(config.admin_qq))
+                        # 写入
+                        with open("config.py", "w", encoding="utf-8") as f:
+                            f.write(config_file_str)
+
+                        print("管理员QQ已设置，如需修改请修改config.py中的admin_qq字段")
+                        time.sleep(4)
+                        break
+                    except ValueError:
+                        print("请输入数字")
+
+            import pkg.openai.manager
+            import pkg.database.manager
+            import pkg.openai.session
+            import pkg.qqbot.manager
+            import pkg.openai.dprompt
+            import pkg.qqbot.cmds.aamgr
+            
+            try:
+                pkg.openai.dprompt.register_all()
+                pkg.qqbot.cmds.aamgr.register_all()
+                pkg.qqbot.cmds.aamgr.apply_privileges()
+            except Exception as e:
+                logging.error(e)
+                traceback.print_exc()
+
+            # 配置OpenAI proxy
            import openai
-            openai.api_base = config.openai_config["reverse_proxy"]
+            openai.proxy = None  # 先重置，因为重载后可能需要清除proxy
+            if "http_proxy" in config.openai_config and config.openai_config["http_proxy"] is not None:
+                openai.proxy = config.openai_config["http_proxy"]

-        # 主启动流程
-        database = pkg.database.manager.DatabaseManager()
+            # 配置openai api_base
+            if "reverse_proxy" in config.openai_config and config.openai_config["reverse_proxy"] is not None:
+                openai.api_base = config.openai_config["reverse_proxy"]

-        database.initialize_database()
+            # 主启动流程
+            database = pkg.database.manager.DatabaseManager()

-        openai_interact = pkg.openai.manager.OpenAIInteract(config.openai_config['api_key'])
+            database.initialize_database()

-        # 加载所有未超时的session
-        pkg.openai.session.load_sessions()
+            openai_interact = pkg.openai.manager.OpenAIInteract(config.openai_config['api_key'])

-        # 初始化qq机器人
-        qqbot = pkg.qqbot.manager.QQBotManager(first_time_init=first_time_init)
+            # 加载所有未超时的session
+            pkg.openai.session.load_sessions()

-        # 加载插件
-        import pkg.plugin.host
-        pkg.plugin.host.load_plugins()
+            # 初始化qq机器人
+            qqbot = pkg.qqbot.manager.QQBotManager(first_time_init=first_time_init)

-        pkg.plugin.host.initialize_plugins()
+            # 加载插件
+            import pkg.plugin.host
+            pkg.plugin.host.load_plugins()

-        if first_time_init:  # 不是热重载之后的启动,则启动新的bot线程
+            pkg.plugin.host.initialize_plugins()

-            import mirai.exceptions
+            if first_time_init:  # 不是热重载之后的启动,则启动新的bot线程

-            def run_bot_wrapper():
-                global known_exception_caught
-                try:
-                    logging.info("使用账号: {}".format(qqbot.bot_account_id))
-                    qqbot.adapter.run_sync()
-                except TypeError as e:
-                    if str(e).__contains__("argument 'debug'"):
-                        logging.error(
-                            "连接bot失败:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/82".format(e))
-                        known_exception_caught = True
-                    elif str(e).__contains__("As of 3.10, the *loop*"):
-                        logging.error(
-                            "Websockets版本过低:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/5".format(e))
-                        known_exception_caught = True
+                import mirai.exceptions

-                except websockets.exceptions.InvalidStatus as e:
-                    logging.error(
-                        "mirai-api-http端口无法使用:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/22".format(
-                            e))
-                    known_exception_caught = True
-                except mirai.exceptions.NetworkError as e:
-                    logging.error("连接mirai-api-http失败:{}, 请检查是否已按照文档启动mirai".format(e))
-                    known_exception_caught = True
-                except Exception as e:
-                    if str(e).__contains__("404"):
+                def run_bot_wrapper():
+                    global known_exception_caught
+                    try:
+                        logging.info("使用账号: {}".format(qqbot.bot_account_id))
+                        qqbot.adapter.run_sync()
+                    except TypeError as e:
+                        if str(e).__contains__("argument 'debug'"):
+                            logging.error(
+                                "连接bot失败:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/82".format(e))
+                            known_exception_caught = True
+                        elif str(e).__contains__("As of 3.10, the *loop*"):
+                            logging.error(
+                                "Websockets版本过低:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/5".format(e))
+                            known_exception_caught = True
+
+                    except websockets.exceptions.InvalidStatus as e:
                        logging.error(
                            "mirai-api-http端口无法使用:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/22".format(
                                e))
                        known_exception_caught = True
-                    elif str(e).__contains__("signal only works in main thread"):
-                        logging.error(
-                            "hypercorn异常:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/86".format(
-                                e))
+                    except mirai.exceptions.NetworkError as e:
+                        logging.error("连接mirai-api-http失败:{}, 请检查是否已按照文档启动mirai".format(e))
                        known_exception_caught = True
-                    elif str(e).__contains__("did not receive a valid HTTP"):
-                        logging.error(
-                            "mirai-api-http端口无法使用:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/22".format(
-                                e))
-                    else:
-                        import traceback
-                        traceback.print_exc()
-                        logging.error(
-                            "捕捉到未知异常:{}, 请前往 https://github.com/RockChinQ/QChatGPT/issues 查找或提issue".format(e))
-                        known_exception_caught = True
-                        raise e
-                finally:
-                    time.sleep(12)
-            threading.Thread(
-                target=run_bot_wrapper
-            ).start()
+                    except Exception as e:
+                        if str(e).__contains__("404"):
+                            logging.error(
+                                "mirai-api-http端口无法使用:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/22".format(
+                                    e))
+                            known_exception_caught = True
+                        elif str(e).__contains__("signal only works in main thread"):
+                            logging.error(
+                                "hypercorn异常:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/86".format(
+                                    e))
+                            known_exception_caught = True
+                        elif str(e).__contains__("did not receive a valid HTTP"):
+                            logging.error(
+                                "mirai-api-http端口无法使用:{}, 解决方案: https://github.com/RockChinQ/QChatGPT/issues/22".format(
+                                    e))
+                        else:
+                            import traceback
+                            traceback.print_exc()
+                            logging.error(
+                                "捕捉到未知异常:{}, 请前往 https://github.com/RockChinQ/QChatGPT/issues 查找或提issue".format(e))
+                            known_exception_caught = True
+                            raise e
+                    finally:
+                        time.sleep(12)
+                threading.Thread(
+                    target=run_bot_wrapper
+                ).start()
+        except Exception as e:
+            traceback.print_exc()
+            if isinstance(e, KeyboardInterrupt):
+                logging.info("程序被用户中止")
+                sys.exit(0)
+            elif isinstance(e, SyntaxError):
+                logging.error("配置文件存在语法错误，请检查配置文件：\n1. 是否存在中文符号\n2. 是否已按照文件中的说明填写正确")
+                sys.exit(1)
+            else:
+                logging.error("初始化失败:{}".format(e))
+                sys.exit(1)
    finally:
        # 判断若是Windows，输出选择模式可能会暂停程序的警告
        if os.name == 'nt':
@@ -268,7 +285,7 @@ def start(first_time_init=False):
                import config
                if config.msg_source_adapter == "yirimirai":
                    logging.info("QQ: {}, MAH: {}".format(config.mirai_http_api_config['qq'], config.mirai_http_api_config['host']+":"+str(config.mirai_http_api_config['port'])))
-                    logging.critical('程序启动完成,如长时间未显示 "成功登录到账号xxxxx" ,并且不回复消息,请查看 '
+                    logging.critical('程序启动完成,如长时间未显示 "成功登录到账号xxxxx" ,并且不回复消息,解决办法(请勿到群里问): '
                                'https://github.com/RockChinQ/QChatGPT/issues/37')
                elif config.msg_source_adapter == 'nakuru':
                    logging.info("host: {}, port: {}, http_port: {}".format(config.nakuru_config['host'], config.nakuru_config['port'], config.nakuru_config['http_port']))
--- a/override-all.json
+++ b/override-all.json
@@ -53,6 +53,7 @@
    "inappropriate_message_tips": "[百度云]请珍惜机器人，当前返回内容不合规",
    "encourage_sponsor_at_start": true,
    "prompt_submit_length": 2048,
+    "auto_reset": true,
    "completion_api_params": {
        "model": "gpt-3.5-turbo",
        "temperature": 0.9,
@@ -67,6 +68,10 @@
    "include_image_description": true,
    "process_message_timeout": 30,
    "show_prefix": false,
+    "force_delay_range": [
+        1.5,
+        3
+    ],
    "blob_message_threshold": 256,
    "blob_message_strategy": "forward",
    "wait_last_done": true,
--- a/pkg/openai/api/init.py
+++ b/pkg/openai/api/init.py
--- a/pkg/openai/api/chat_completion.py
+++ b/pkg/openai/api/chat_completion.py
@@ -0,0 +1,195 @@
+import openai
+import json
+import logging
+
+from .model import RequestBase
+
+from ..funcmgr import get_func_schema_list, execute_function, get_func, get_func_schema, ContentFunctionNotFoundError
+
+
+class ChatCompletionRequest(RequestBase):
+    """调用ChatCompletion接口的请求类。
+    
+    此类保证每一次返回的角色为assistant的信息的finish_reason一定为stop。
+    若有函数调用响应，本类的返回瀑布是：函数调用请求->函数调用结果->...->assistant的信息->stop。
+    """
+    model: str
+    messages: list[dict[str, str]]
+    kwargs: dict
+
+    stopped: bool = False
+
+    pending_func_call: dict = None
+
+    pending_msg: str
+
+    def flush_pending_msg(self):
+        self.append_message(
+            role="assistant",
+            content=self.pending_msg
+        )
+        self.pending_msg = ""
+
+    def append_message(self, role: str, content: str, name: str=None):
+        msg = {
+            "role": role,
+            "content": content
+        }
+
+        if name is not None:
+            msg['name'] = name
+
+        self.messages.append(msg)
+
+    def __init__(
+        self,
+        model: str,
+        messages: list[dict[str, str]],
+        **kwargs
+    ):
+        self.model = model
+        self.messages = messages.copy()
+
+        self.kwargs = kwargs
+
+        self.req_func = openai.ChatCompletion.acreate
+
+        self.pending_func_call = None
+
+        self.stopped = False
+
+        self.pending_msg = ""
+
+    def __iter__(self):
+        return self
+
+    def __next__(self) -> dict:
+        if self.stopped:
+            raise StopIteration()
+
+        if self.pending_func_call is None:  # 没有待处理的函数调用请求
+
+            args = {
+                "model": self.model,
+                "messages": self.messages,
+            }
+
+            funcs = get_func_schema_list()
+
+            if len(funcs) > 0:
+                args['functions'] = funcs
+
+            # 拼接kwargs
+            args = {**args, **self.kwargs}
+
+            resp = self._req(**args)
+
+            choice0 = resp["choices"][0]
+
+            # 如果不是函数调用，且finish_reason为stop，则停止迭代
+            if 'function_call' not in choice0['message'] and choice0["finish_reason"] == "stop":
+                self.stopped = True
+            
+            if 'function_call' in choice0['message']:
+                self.pending_func_call = choice0['message']['function_call']
+
+                self.append_message(
+                    role="assistant",
+                    content="function call: "+json.dumps(self.pending_func_call, ensure_ascii=False)
+                )
+
+                return {
+                    "id": resp["id"],
+                    "choices": [
+                        {
+                            "index": choice0["index"],
+                            "message": {
+                                "role": "assistant",
+                                "type": "function_call",
+                                "content": None,
+                                "function_call": choice0['message']['function_call']
+                            },
+                            "finish_reason": "function_call"
+                        }
+                    ],
+                    "usage": resp["usage"]
+                }
+            else:
+
+                # self.pending_msg += choice0['message']['content']
+                # 普通回复一定处于最后方，故不用再追加进内部messages
+
+                return {
+                    "id": resp["id"],
+                    "choices": [
+                        {
+                            "index": choice0["index"],
+                            "message": {
+                                "role": "assistant",
+                                "type": "text",
+                                "content": choice0['message']['content']
+                            },
+                            "finish_reason": "stop"
+                        }
+                    ],
+                    "usage": resp["usage"]
+                }
+        else:  # 处理函数调用请求
+
+            cp_pending_func_call = self.pending_func_call.copy()
+            
+            self.pending_func_call = None
+
+            func_name = cp_pending_func_call['name']
+            arguments = {}
+
+            try:
+
+                try:
+                    arguments = json.loads(cp_pending_func_call['arguments'])
+                # 若不是json格式的异常处理
+                except json.decoder.JSONDecodeError:
+                    # 获取函数的参数列表
+                    func_schema = get_func_schema(func_name)
+
+                    arguments = {
+                        func_schema['parameters']['required'][0]: cp_pending_func_call['arguments']
+                    }
+                
+                logging.info("执行函数调用: name={}, arguments={}".format(func_name, arguments))
+
+                # 执行函数调用
+                ret = execute_function(func_name, arguments)
+
+                logging.info("函数执行完成。")
+
+                self.append_message(
+                    role="function",
+                    content=json.dumps(ret, ensure_ascii=False),
+                    name=func_name
+                )
+
+                return {
+                    "id": -1,
+                    "choices": [
+                        {
+                            "index": -1,
+                            "message": {
+                                "role": "function",
+                                "type": "function_return",
+                                "function_name": func_name,
+                                "content": json.dumps(ret, ensure_ascii=False)
+                            },
+                            "finish_reason": "function_return"
+                        }
+                    ],
+                    "usage": {
+                        "prompt_tokens": 0,
+                        "completion_tokens": 0,
+                        "total_tokens": 0
+                    }
+                }
+
+            except ContentFunctionNotFoundError:
+                raise Exception("没有找到函数: {}".format(func_name))
+
--- a/pkg/openai/api/completion.py
+++ b/pkg/openai/api/completion.py
@@ -0,0 +1,111 @@
+import openai
+
+from .model import RequestBase
+
+
+class CompletionRequest(RequestBase):
+    """调用Completion接口的请求类。
+    
+    调用方可以一直next completion直到finish_reason为stop。
+    """
+
+    model: str
+    prompt: str
+    kwargs: dict
+
+    stopped: bool = False
+
+    def __init__(
+        self,
+        model: str,
+        messages: list[dict[str, str]],
+        **kwargs
+    ):
+        self.model = model
+        self.prompt = ""
+        
+        for message in messages:
+            self.prompt += message["role"] + ": " + message["content"] + "\n"
+        
+        self.prompt += "assistant: "
+
+        self.kwargs = kwargs
+
+        self.req_func = openai.Completion.acreate
+
+    def __iter__(self):
+        return self
+
+    def __next__(self) -> dict:
+        """调用Completion接口，返回生成的文本
+        
+        {
+            "id": "id",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "type": "text",
+                        "content": "message"
+                    },
+                    "finish_reason": "reason"
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 10,
+                "completion_tokens": 20,
+                "total_tokens": 30
+            }
+        }
+        """
+
+        if self.stopped:
+            raise StopIteration()
+
+        resp = self._req(
+            model=self.model,
+            prompt=self.prompt,
+            **self.kwargs
+        )
+
+        if resp["choices"][0]["finish_reason"] == "stop":
+            self.stopped = True
+
+        choice0 = resp["choices"][0]
+
+        self.prompt += choice0["text"]
+
+        return {
+            "id": resp["id"],
+            "choices": [
+                {
+                    "index": choice0["index"],
+                    "message": {
+                        "role": "assistant",
+                        "type": "text",
+                        "content": choice0["text"]
+                    },
+                    "finish_reason": choice0["finish_reason"]
+                }
+            ],
+            "usage": resp["usage"]
+        }
+        
+if __name__ == "__main__":
+    import os
+
+    openai.api_key = os.environ["OPENAI_API_KEY"]
+
+    for resp in CompletionRequest(
+        model="text-davinci-003",
+        messages=[
+            {
+                "role": "user",
+                "content": "Hello, who are you?"
+            }
+        ]
+    ):
+        print(resp)
+        if resp["choices"][0]["finish_reason"] == "stop":
+            break
--- a/pkg/openai/api/model.py
+++ b/pkg/openai/api/model.py
@@ -0,0 +1,49 @@
+# 定义不同接口请求的模型
+import threading
+import asyncio
+
+import openai
+
+
+class RequestBase:
+
+    req_func: callable
+
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError
+
+    def _req(self, **kwargs):
+        """处理代理问题"""
+
+        ret: dict = {}
+        exception: Exception = None
+
+        async def awrapper(**kwargs):
+            nonlocal ret, exception
+
+            try:
+                ret = await self.req_func(**kwargs)
+                return ret
+            except Exception as e:
+                exception = e
+            
+        loop = asyncio.new_event_loop()
+
+        thr = threading.Thread(
+            target=loop.run_until_complete,
+            args=(awrapper(**kwargs),)
+        )
+
+        thr.start()
+        thr.join()
+
+        if exception is not None:
+            raise exception
+
+        return ret
+
+    def __iter__(self):
+        raise self
+
+    def __next__(self):
+        raise NotImplementedError
--- a/pkg/openai/funcmgr.py
+++ b/pkg/openai/funcmgr.py
@@ -0,0 +1,47 @@
+# 封装了function calling的一些支持函数
+import logging
+
+
+from pkg.plugin import host
+
+
+class ContentFunctionNotFoundError(Exception):
+    pass
+
+
+def get_func_schema_list() -> list:
+    """从plugin包中的函数结构中获取并处理成受GPT支持的格式"""
+    if not host.__enable_content_functions__:
+        return []
+
+    schemas = []
+
+    for func in host.__callable_functions__:
+        if func['enabled']:
+            fun_cp = func.copy()
+
+            del fun_cp['enabled']
+
+            schemas.append(fun_cp)
+
+    return schemas
+
+def get_func(name: str) -> callable:
+    if name not in host.__function_inst_map__:
+        raise ContentFunctionNotFoundError("没有找到内容函数: {}".format(name))
+
+    return host.__function_inst_map__[name]
+
+def get_func_schema(name: str) -> dict:
+    for func in host.__callable_functions__:
+        if func['name'] == name:
+            return func
+    raise ContentFunctionNotFoundError("没有找到内容函数: {}".format(name))
+
+def execute_function(name: str, kwargs: dict) -> any:
+    """执行函数调用"""
+
+    logging.debug("executing function: name='{}', kwargs={}".format(name, kwargs))
+
+    func = get_func(name)
+    return func(**kwargs)
--- a/pkg/openai/manager.py
+++ b/pkg/openai/manager.py
@@ -5,7 +5,9 @@ import openai
 import pkg.openai.keymgr
 import pkg.utils.context
 import pkg.audit.gatherer
-from pkg.openai.modelmgr import ModelRequest, create_openai_model_request
+from pkg.openai.modelmgr import select_request_cls
+
+from pkg.openai.api.model import RequestBase


 class OpenAIInteract:
@@ -33,45 +35,24 @@ class OpenAIInteract:

        pkg.utils.context.set_openai_manager(self)

-    # 请求OpenAI Completion
-    def request_completion(self, prompts) -> tuple[str, int]:
-        """请求补全接口回复
-
-        Parameters:
-            prompts (str): 提示语
-
-        Returns:
-            str: 回复
+    def request_completion(self, messages: list):
+        """请求补全接口回复=
        """
-
+        # 选择接口请求类
        config = pkg.utils.context.get_config()

-        # 根据模型选择使用的接口
-        ai: ModelRequest = create_openai_model_request(
-            config.completion_api_params['model'],
-            'user',
-            config.openai_config["http_proxy"] if "http_proxy" in config.openai_config else None
-        )
-        ai.request(
-            prompts,
-            **config.completion_api_params
-        )
-        response = ai.get_response()
+        request: RequestBase

-        logging.debug("OpenAI response: %s", response)
+        model: str = config.completion_api_params['model']

-        # 记录使用量
-        current_round_token = 0
-        if 'model' in config.completion_api_params:
-            self.audit_mgr.report_text_model_usage(config.completion_api_params['model'],
-                                                   ai.get_total_tokens())
-            current_round_token = ai.get_total_tokens()
-        elif 'engine' in config.completion_api_params:
-            self.audit_mgr.report_text_model_usage(config.completion_api_params['engine'],
-                                                   response['usage']['total_tokens'])
-            current_round_token = response['usage']['total_tokens']
+        cp_parmas = config.completion_api_params.copy()
+        del cp_parmas['model']

-        return ai.get_message(), current_round_token
+        request = select_request_cls(model, messages, cp_parmas)
+
+        # 请求接口
+        for resp in request:
+            yield resp

    def request_image(self, prompt) -> dict:
        """请求图片接口回复
--- a/pkg/openai/modelmgr.py
+++ b/pkg/openai/modelmgr.py
@@ -8,6 +8,10 @@ Completion - text-davinci-003 等模型
 import openai, logging, threading, asyncio
 import openai.error as aiE

+from pkg.openai.api.model import RequestBase
+from pkg.openai.api.completion import CompletionRequest
+from pkg.openai.api.chat_completion import ChatCompletionRequest
+
 COMPLETION_MODELS = {
    'text-davinci-003',
    'text-davinci-002',
@@ -20,11 +24,14 @@ COMPLETION_MODELS = {

 CHAT_COMPLETION_MODELS = {
    'gpt-3.5-turbo',
-    'gpt-3.5-turbo-0301',
+    'gpt-3.5-turbo-16k',
+    'gpt-3.5-turbo-0613',
+    'gpt-3.5-turbo-16k-0613',
+    # 'gpt-3.5-turbo-0301',
    'gpt-4',
-    'gpt-4-0314',
+    'gpt-4-0613',
    'gpt-4-32k',
-    'gpt-4-32k-0314'
+    'gpt-4-32k-0613'
 }

 EDIT_MODELS = {
@@ -36,153 +43,9 @@ IMAGE_MODELS = {
 }


-class ModelRequest:
-    """模型接口请求父类"""
-
-    can_chat = False
-    runtime: threading.Thread = None
-    ret = {}
-    proxy: str = None
-    request_ready = True
-    error_info: str = "若在没有任何错误的情况下看到这句话，请带着配置文件上报Issues"
-
-    def __init__(self, model_name, user_name, request_fun, http_proxy:str = None, time_out = None):
-        self.model_name = model_name
-        self.user_name = user_name
-        self.request_fun = request_fun
-        self.time_out = time_out
-        if http_proxy != None:
-            self.proxy = http_proxy
-            openai.proxy = self.proxy
-            self.request_ready = False
-
-    async def __a_request__(self, **kwargs):
-        """异步请求"""
-
-        try:
-            self.ret: dict = await self.request_fun(**kwargs)
-            self.request_ready = True
-        except aiE.APIConnectionError as e:
-            self.error_info = "{}\n请检查网络连接或代理是否正常".format(e)
-            raise ConnectionError(self.error_info)
-        except ValueError as e:
-            self.error_info = "{}\n该错误可能是由于http_proxy格式设置错误引起的"
-        except Exception as e:
-            self.error_info = "{}\n由于请求异常产生的未知错误，请查看日志".format(e)
-            raise type(e)(self.error_info)
-
-    def request(self, **kwargs):
-        """向接口发起请求"""
-
-        if self.proxy != None: #异步请求
-            self.request_ready = False
-            loop = asyncio.new_event_loop()
-            self.runtime = threading.Thread(
-                target=loop.run_until_complete,
-                args=(self.__a_request__(**kwargs),)
-            )
-            self.runtime.start()
-        else: #同步请求
-            self.ret = self.request_fun(**kwargs)
-
-    def __msg_handle__(self, msg):
-        """将prompt dict转换成接口需要的格式"""
-        return msg
-    
-    def ret_handle(self):
-        '''
-        API消息返回处理函数
-        若重写该方法，应检查异步线程状态，或在需要检查处super该方法
-        '''
-        if self.runtime != None and isinstance(self.runtime, threading.Thread):
-            self.runtime.join(self.time_out)
-        if self.request_ready:
-            return
-        raise Exception(self.error_info)
-
-    def get_total_tokens(self):
-        try:
-            return self.ret['usage']['total_tokens']
-        except:
-            return 0
-
-    def get_message(self):
-        return self.message
-
-    def get_response(self):
-        return self.ret
-
-
-class ChatCompletionModel(ModelRequest):
-    """ChatCompletion接口的请求实现"""
-
-    Chat_role = ['system', 'user', 'assistant']
-    def __init__(self, model_name, user_name, http_proxy:str = None, **kwargs):
-        if http_proxy == None:
-            request_fun = openai.ChatCompletion.create
-        else:
-            request_fun = openai.ChatCompletion.acreate
-        self.can_chat = True
-        super().__init__(model_name, user_name, request_fun, http_proxy, **kwargs)
-
-    def request(self, prompts, **kwargs):
-        prompts = self.__msg_handle__(prompts)
-        kwargs['messages'] = prompts
-        super().request(**kwargs)
-        self.ret_handle()
-
-    def __msg_handle__(self, msgs):
-        temp_msgs = []
-        # 把msgs拷贝进temp_msgs
-        for msg in msgs:
-            temp_msgs.append(msg.copy())
-        return temp_msgs
-
-    def get_message(self):
-        return self.ret["choices"][0]["message"]['content'] #需要时直接加载加快请求速度，降低内存消耗
-
-
-class CompletionModel(ModelRequest):
-    """Completion接口的请求实现"""
-
-    def __init__(self, model_name, user_name, http_proxy:str = None, **kwargs):
-        if http_proxy == None:
-            request_fun = openai.Completion.create
-        else:
-            request_fun = openai.Completion.acreate
-        super().__init__(model_name, user_name, request_fun, http_proxy, **kwargs)
-
-    def request(self, prompts, **kwargs):
-        prompts = self.__msg_handle__(prompts)
-        kwargs['prompt'] = prompts
-        super().request(**kwargs)
-        self.ret_handle()
-
-    def __msg_handle__(self, msgs):
-        prompt = ''
-        for msg in msgs:
-            prompt = prompt + "{}: {}\n".format(msg['role'], msg['content'])
-        # for msg in msgs:
-        #     if msg['role'] == 'assistant':
-        #         prompt = prompt + "{}\n".format(msg['content'])
-        #     else:
-        #         prompt = prompt + "{}:{}\n".format(msg['role'] , msg['content'])
-        prompt = prompt + "assistant: "
-        return prompt
-
-    def get_message(self):
-        return self.ret["choices"][0]["text"]
-
-
-def create_openai_model_request(model_name: str, user_name: str = 'user', http_proxy:str = None) -> ModelRequest:
-    """使用给定的模型名称创建模型请求对象"""
+def select_request_cls(model_name: str, messages: list, args: dict) -> RequestBase:
    if model_name in CHAT_COMPLETION_MODELS:
-        model = ChatCompletionModel(model_name, user_name, http_proxy)
+        return ChatCompletionRequest(model_name, messages, **args)
    elif model_name in COMPLETION_MODELS:
-        model = CompletionModel(model_name, user_name, http_proxy)
-    else :
-        log = "找不到模型[{}]，请检查配置文件".format(model_name)
-        logging.error(log)
-        raise IndexError(log)
-    logging.debug("使用接口[{}]创建模型请求[{}]".format(model.__class__.__name__, model_name))
-    return model
+        return CompletionRequest(model_name, messages, **args)
+    raise ValueError("不支持模型[{}]，请检查配置文件".format(model_name))
--- a/pkg/openai/sess.py
+++ b/pkg/openai/sess.py
@@ -0,0 +1,79 @@
+import time
+import threading
+import logging
+
+
+sessions = {}
+
+
+class SessionOfflineStatus:
+    ON_GOING = "on_going"
+    EXPLICITLY_CLOSED = "explicitly_closed"
+
+
+def reset_session_prompt(session_name, prompt):
+    pass
+
+
+def load_sessions():
+    pass
+
+
+def get_session(session_name: str) -> 'Session':
+    pass
+
+
+def dump_session(session_name: str):
+    pass
+
+
+class Session:
+    name: str = ''
+
+    default_prompt: list = []
+    """会话系统提示语"""
+
+    messages: list = []
+    """保存消息历史记录"""
+
+    token_counts: list = []
+    """记录每回合的token数量"""
+
+    create_ts: int = 0
+    """会话创建时间戳"""
+
+    last_active_ts: int = 0
+    """会话最后活跃时间戳"""
+
+    just_switched_to_exist_session: bool = False
+
+    response_lock = None
+
+    def __init__(self, name: str):
+        self.name = name
+        self.default_prompt = self.get_runtime_default_prompt()
+        logging.debug("prompt is: {}".format(self.default_prompt))
+        self.messages = []
+        self.token_counts = []
+        self.create_ts = int(time.time())
+        self.last_active_ts = int(time.time())
+
+        self.response_lock = threading.Lock()
+
+        self.schedule()
+        
+    def get_runtime_default_prompt(self, use_default: str = None) -> list:
+        """从提示词管理器中获取所需提示词"""
+        import pkg.openai.dprompt as dprompt
+
+        if use_default is None:
+            use_default = dprompt.mode_inst().get_using_name()
+
+        current_default_prompt, _ = dprompt.mode_inst().get_prompt(use_default)
+        return current_default_prompt
+
+    def schedule(self):
+        """定时会话过期检查任务"""
+
+    def expire_check_timer_loop(self):
+        """会话过期检查任务"""
--- a/pkg/openai/session.py
+++ b/pkg/openai/session.py
@@ -83,7 +83,7 @@ def load_sessions():


 # 获取指定名称的session，如果不存在则创建一个新的
-def get_session(session_name: str):
+def get_session(session_name: str) -> 'Session':
    global sessions
    if session_name not in sessions:
        sessions[session_name] = Session(session_name)
@@ -222,22 +222,67 @@ class Session:
        for token_count in counts:
            total_token_before_query += token_count

+        res_text = ""
+
+        pending_msgs = []
+
+        total_tokens = 0
+
+        for resp in pkg.utils.context.get_openai_manager().request_completion(prompts):
+            if resp['choices'][0]['message']['type'] == 'text':  # 普通回复
+                res_text += resp['choices'][0]['message']['content']
+
+                total_tokens += resp['usage']['total_tokens']
+
+                pending_msgs.append(
+                    {
+                        "role": "assistant",
+                        "content": resp['choices'][0]['message']['content']
+                    }
+                )
+
+            elif resp['choices'][0]['message']['type'] == 'function_call':
+                # self.prompt.append(
+                #     {
+                #         "role": "assistant",
+                #         "content": "function call: "+json.dumps(resp['choices'][0]['message']['function_call'])
+                #     }
+                # )
+
+                total_tokens += resp['usage']['total_tokens']
+            elif resp['choices'][0]['message']['type'] == 'function_return':
+                # self.prompt.append(
+                #     {
+                #         "role": "function",
+                #         "name": resp['choices'][0]['message']['function_name'],
+                #         "content": json.dumps(resp['choices'][0]['message']['content'])
+                #     }
+                # )
+
+                # total_tokens += resp['usage']['total_tokens']
+                pass
+
+
+
        # 向API请求补全
-        message, total_token = pkg.utils.context.get_openai_manager().request_completion(
-            prompts,
-        )
+        # message, total_token = pkg.utils.context.get_openai_manager().request_completion(
+        #     prompts,
+        # )

        # 成功获取，处理回复
-        res_test = message
-        res_ans = res_test.strip()
+        # res_test = message
+        res_ans = res_text.strip()

        # 将此次对话的双方内容加入到prompt中
+        # self.prompt.append({'role': 'user', 'content': text})
+        # self.prompt.append({'role': 'assistant', 'content': res_ans})
        self.prompt.append({'role': 'user', 'content': text})
-        self.prompt.append({'role': 'assistant', 'content': res_ans})
+        # 添加pending_msgs
+        self.prompt += pending_msgs

        # 向token_counts中添加本回合的token数量
-        self.token_counts.append(total_token-total_token_before_query)
-        logging.debug("本回合使用token: {}, session counts: {}".format(total_token-total_token_before_query, self.token_counts))
+        self.token_counts.append(total_tokens-total_token_before_query)
+        logging.debug("本回合使用token: {}, session counts: {}".format(total_tokens-total_token_before_query, self.token_counts))

        if self.just_switched_to_exist_session:
            self.just_switched_to_exist_session = False
@@ -327,7 +372,7 @@ class Session:
                                    json.dumps(self.prompt), json.dumps(self.default_prompt), json.dumps(self.token_counts))

    # 重置session
-    def reset(self, explicit: bool = False, expired: bool = False, schedule_new: bool = True, use_prompt: str = None):
+    def reset(self, explicit: bool = False, expired: bool = False, schedule_new: bool = True, use_prompt: str = None, persist: bool = False):
        if self.prompt:
            self.persistence()
            if explicit:
@@ -345,7 +390,8 @@ class Session:
            if expired:
                pkg.utils.context.get_database_manager().set_session_expired(self.name, self.create_timestamp)

-        self.default_prompt = self.get_default_prompt(use_prompt)
+        if not persist:  # 不要求保持default prompt
+            self.default_prompt = self.get_default_prompt(use_prompt)
        self.prompt = []
        self.token_counts = []
        self.create_timestamp = int(time.time())
--- a/pkg/plugin/host.py
+++ b/pkg/plugin/host.py
@@ -8,6 +8,7 @@ import sys
 import shutil
 import traceback

+import pkg.utils.updater as updater
 import pkg.utils.context as context
 import pkg.plugin.switch as switch
 import pkg.plugin.settings as settings
@@ -15,6 +16,8 @@ import pkg.qqbot.adapter as msadapter

 from mirai import Mirai

+from CallingGPT.session.session import Session
+
 __plugins__ = {}
 """插件列表

@@ -41,6 +44,15 @@ __plugins__ = {}
 __plugins_order__ = []
 """插件顺序"""

+__enable_content_functions__ = True
+"""是否启用内容函数"""
+
+__callable_functions__ = []
+"""供GPT调用的函数结构"""
+
+__function_inst_map__: dict[str, callable] = {}
+"""函数名:实例 映射"""
+

 def generate_plugin_order():
    """根据__plugin__生成插件初始顺序，无视是否启用"""
@@ -79,7 +91,7 @@ def walk_plugin_path(module, prefix='', path_prefix=''):
                __current_module_path__ = "plugins/"+path_prefix + item.name + '.py'

                importlib.import_module(module.__name__ + '.' + item.name)
-                logging.info('加载模块: plugins/{} 成功'.format(path_prefix + item.name + '.py'))
+                logging.debug('加载模块: plugins/{} 成功'.format(path_prefix + item.name + '.py'))
            except:
                logging.error('加载模块: plugins/{} 失败: {}'.format(path_prefix + item.name + '.py', sys.exc_info()))
                traceback.print_exc()
@@ -101,6 +113,10 @@ def load_plugins():
    # 加载插件顺序
    settings.load_settings()

+    # 输出已注册的内容函数列表
+    logging.debug("registered content functions: {}".format(__callable_functions__))
+    logging.debug("function instance map: {}".format(__function_inst_map__))
+

 def initialize_plugins():
    """初始化插件"""
@@ -177,6 +193,43 @@ def uninstall_plugin(plugin_name: str) -> str:
    return "plugins/"+plugin_path


+def update_plugin(plugin_name: str):
+    """更新插件"""
+    # 检查是否有远程地址记录
+    target_plugin_dir = "plugins/" + __plugins__[plugin_name]['path'].replace("\\", "/").split("plugins/")[1].split("/")[0]
+
+    remote_url = updater.get_remote_url(target_plugin_dir)
+    if remote_url == "https://github.com/RockChinQ/QChatGPT" or remote_url == "https://gitee.com/RockChin/QChatGPT" \
+        or remote_url == "" or remote_url is None or remote_url == "http://github.com/RockChinQ/QChatGPT" or remote_url == "http://gitee.com/RockChin/QChatGPT":
+        raise Exception("插件没有远程地址记录，无法更新")
+    
+    # 把远程clone到temp/plugins/update/插件名
+    logging.info("克隆插件储存库: {}".format(remote_url))
+
+    from dulwich import porcelain
+    clone_target_dir = "temp/plugins/update/"+target_plugin_dir.split("/")[-1]+"/"
+
+    if os.path.exists(clone_target_dir):
+        shutil.rmtree(clone_target_dir)
+
+    if not os.path.exists(clone_target_dir):
+        os.makedirs(clone_target_dir)
+    repo = porcelain.clone(remote_url, clone_target_dir, checkout=True)
+
+    # 检查此目录是否包含requirements.txt
+    if os.path.exists(clone_target_dir+"requirements.txt"):
+        logging.info("检测到requirements.txt，正在安装依赖")
+        import pkg.utils.pkgmgr
+        pkg.utils.pkgmgr.install_requirements(clone_target_dir+"requirements.txt")
+
+        import pkg.utils.log as log
+        log.reset_logging()
+
+    # 将temp/plugins/update/插件名 覆盖到 plugins/插件名
+    shutil.rmtree(target_plugin_dir)
+
+    shutil.copytree(clone_target_dir, target_plugin_dir)
+
 class EventContext:
    """事件上下文"""
    eid = 0
@@ -262,7 +315,9 @@ class PluginHost:
    """插件宿主"""

    def __init__(self):
+        """初始化插件宿主"""
        context.set_plugin_host(self)
+        self.calling_gpt_session = Session([])

    def get_runtime_context(self) -> context:
        """获取运行时上下文（pkg.utils.context模块的对象）
@@ -344,3 +399,6 @@ class PluginHost:
                                                                event_context.__return_value__))

        return event_context
+
+if __name__ == "__main__":
+    pass
--- a/pkg/plugin/models.py
+++ b/pkg/plugin/models.py
@@ -133,12 +133,18 @@ KeySwitched = "key_switched"
 """


-def on(event: str):
+def on(*args, **kwargs):
    """注册事件监听器
-    :param
-        event: str 事件名称
    """
-    return Plugin.on(event)
+    return Plugin.on(*args, **kwargs)
+
+def func(*args, **kwargs):
+    """注册内容函数，声明此函数为一个内容函数，在对话中将发送此函数给GPT以供其调用
+    此函数可以具有任意的参数，但必须按照[此文档](https://github.com/RockChinQ/CallingGPT/wiki/1.-Function-Format#function-format)
+    所述的格式编写函数的docstring。
+    此功能仅支持在使用gpt-3.5或gpt-4系列模型时使用。
+    """
+    return Plugin.func(*args, **kwargs)


 __current_registering_plugin__ = ""
@@ -176,6 +182,34 @@ class Plugin:

        return wrapper

+    @classmethod
+    def func(cls, name: str=None):
+        """内容函数装饰器
+        """
+        global __current_registering_plugin__
+        from CallingGPT.entities.namespace import get_func_schema
+
+        def wrapper(func):
+
+            function_schema = get_func_schema(func)
+            function_schema['name'] = __current_registering_plugin__ + '-' + (func.__name__ if name is None else name)
+
+            function_schema['enabled'] = True
+
+            host.__function_inst_map__[function_schema['name']] = function_schema['function']
+
+            del function_schema['function']
+
+            # logging.debug("registering content function: p='{}', f='{}', s={}".format(__current_registering_plugin__, func, function_schema))
+
+            host.__callable_functions__.append(
+                function_schema
+            )
+
+            return func
+
+        return wrapper
+

 def register(name: str, description: str, version: str, author: str):
    """注册插件, 此函数作为装饰器使用
--- a/pkg/plugin/settings.py
+++ b/pkg/plugin/settings.py
@@ -8,7 +8,10 @@ import logging
 def wrapper_dict_from_runtime_context() -> dict:
    """从变量中包装settings.json的数据字典"""
    settings = {
-        "order": []
+        "order": [],
+        "functions": {
+            "enabled": host.__enable_content_functions__
+        }
    }

    for plugin_name in host.__plugins_order__:
@@ -22,6 +25,11 @@ def apply_settings(settings: dict):
    if "order" in settings:
        host.__plugins_order__ = settings["order"]

+    if "functions" in settings:
+        if "enabled" in settings["functions"]:
+            host.__enable_content_functions__ = settings["functions"]["enabled"]
+            # logging.debug("set content function enabled: {}".format(host.__enable_content_functions__))
+

 def dump_settings():
    """保存settings.json数据"""
@@ -78,6 +86,17 @@ def load_settings():
            settings["order"].append(plugin_name)
            settings_modified = True

+    if "functions" not in settings:
+        settings["functions"] = {
+            "enabled": host.__enable_content_functions__
+        }
+        settings_modified = True
+    elif "enabled" not in settings["functions"]:
+        settings["functions"]["enabled"] = host.__enable_content_functions__
+        settings_modified = True
+
+    logging.info("已全局{}内容函数。".format("启用" if settings["functions"]["enabled"] else "禁用"))
+
    apply_settings(settings)

    if settings_modified:
--- a/pkg/plugin/switch.py
+++ b/pkg/plugin/switch.py
@@ -28,6 +28,11 @@ def apply_switch(switch: dict):
    for plugin_name in switch:
        host.__plugins__[plugin_name]["enabled"] = switch[plugin_name]["enabled"]

+        # 查找此插件的所有内容函数
+        for func in host.__callable_functions__:
+            if func['name'].startswith(plugin_name + '-'):
+                func['enabled'] = switch[plugin_name]["enabled"]
+

 def dump_switch():
    """保存开关数据"""
--- a/pkg/qqbot/cmds/aamgr.py
+++ b/pkg/qqbot/cmds/aamgr.py
@@ -260,8 +260,8 @@ def execute(context: Context) -> list:

    while True:
        try:
-            logging.debug('执行指令: {}'.format(path))
            node = __command_list__[path]
+            logging.debug('执行指令: {}'.format(path))

            # 检查权限
            if ctx.privilege < node['privilege']:
--- a/pkg/qqbot/cmds/funcs/func.py
+++ b/pkg/qqbot/cmds/funcs/func.py
@@ -0,0 +1,28 @@
+from ..aamgr import AbstractCommandNode, Context
+import logging
+
+
+@AbstractCommandNode.register(
+    parent=None,
+    name="func",
+    description="管理内容函数",
+    usage="!func",
+    aliases=[],
+    privilege=1
+)
+class FuncCommand(AbstractCommandNode):
+    @classmethod
+    def process(cls, ctx: Context) -> tuple[bool, list]:
+        from pkg.plugin.models import host
+
+        reply = []
+
+        reply_str = "当前已加载的内容函数：\n\n"
+
+        index = 1
+        for func in host.__callable_functions__:
+            reply_str += "{}. {}{}:\n{}\n\n".format(index, ("(已禁用) " if not func['enabled'] else ""), func['name'], func['description'])
+
+        reply = [reply_str]
+
+        return True, reply
--- a/pkg/qqbot/cmds/plugin/plugin.py
+++ b/pkg/qqbot/cmds/plugin/plugin.py
@@ -97,37 +97,34 @@ class PluginUpdateCommand(AbstractCommandNode):
        plugin_list = plugin_host.__plugins__

        reply = []
-        def closure():
-            try:
-                import pkg.utils.context
-                updated = []
-                for key in plugin_list:
-                    plugin = plugin_list[key]
-                    if updater.is_repo("/".join(plugin['path'].split('/')[:-1])):
-                        success = updater.pull_latest("/".join(plugin['path'].split('/')[:-1]))
-                        if success:
-                            updated.append(plugin['name'])

-                # 检查是否有requirements.txt
-                pkg.utils.context.get_qqbot_manager().notify_admin("正在安装依赖...")
-                for key in plugin_list:
-                    plugin = plugin_list[key]
-                    if os.path.exists("/".join(plugin['path'].split('/')[:-1])+"/requirements.txt"):
-                        logging.info("{}检测到requirements.txt，安装依赖".format(plugin['name']))
-                        import pkg.utils.pkgmgr
-                        pkg.utils.pkgmgr.install_requirements("/".join(plugin['path'].split('/')[:-1])+"/requirements.txt")
+        if len(ctx.crt_params) > 0:
+            def closure():
+                try:
+                    import pkg.utils.context
+                    
+                    updated = []

-                        import pkg.utils.log as log
-                        log.reset_logging()
+                    if ctx.crt_params[0] == 'all':
+                        for key in plugin_list:
+                            plugin_host.update_plugin(key)
+                            updated.append(key)
+                    else:
+                        if ctx.crt_params[0] in plugin_list:
+                            plugin_host.update_plugin(ctx.crt_params[0])
+                            updated.append(ctx.crt_params[0])
+                        else:
+                            raise Exception("未找到插件: {}".format(ctx.crt_params[0]))

-                pkg.utils.context.get_qqbot_manager().notify_admin("已更新插件: {}".format(", ".join(updated)))
-            except Exception as e:
-                logging.error("插件更新失败:{}".format(e))
-                pkg.utils.context.get_qqbot_manager().notify_admin("插件更新失败:{} 请尝试手动更新插件".format(e))
+                    pkg.utils.context.get_qqbot_manager().notify_admin("已更新插件: {}, 请发送 !reload 重载插件".format(", ".join(updated)))
+                except Exception as e:
+                    logging.error("插件更新失败:{}".format(e))
+                    pkg.utils.context.get_qqbot_manager().notify_admin("插件更新失败:{} 请尝试手动更新插件".format(e))

-
-        threading.Thread(target=closure).start()
-        reply = ["[bot]正在更新所有插件，请勿重复发起..."]
+            reply = ["[bot]正在更新插件，请勿重复发起..."]
+            threading.Thread(target=closure).start()
+        else:
+            reply = ["[bot]请指定要更新的插件, 或使用 !plugin update all 更新所有插件"]
        return True, reply


--- a/pkg/qqbot/cmds/system/cconfig.py
+++ b/pkg/qqbot/cmds/system/cconfig.py
@@ -8,7 +8,7 @@ def config_operation(cmd, params):
    config = pkg.utils.context.get_config()
    reply_str = ""
    if len(params) == 0:
-        reply = ["[bot]err:请输入配置项"]
+        reply = ["[bot]err:请输入!cmd cfg查看使用方法"]
    else:
        cfg_name = params[0]
        if cfg_name == 'all':
@@ -26,45 +26,61 @@ def config_operation(cmd, params):
                    else:
                        reply_str += "{}: {}\n".format(cfg, getattr(config, cfg))
            reply = [reply_str]
-        elif cfg_name in dir(config):
-            if len(params) == 1:
-                # 按照配置项类型进行格式化
-                if isinstance(getattr(config, cfg_name), str):
-                    reply_str = "[bot]配置项{}: \"{}\"\n".format(cfg_name, getattr(config, cfg_name))
-                elif isinstance(getattr(config, cfg_name), dict):
-                    reply_str = "[bot]配置项{}: {}\n".format(cfg_name,
-                                                             json.dumps(getattr(config, cfg_name),
-                                                                        ensure_ascii=False, indent=4))
-                else:
-                    reply_str = "[bot]配置项{}: {}\n".format(cfg_name, getattr(config, cfg_name))
-                reply = [reply_str]
-            else:
-                cfg_value = " ".join(params[1:])
-                # 类型转换，如果是json则转换为字典
-                if cfg_value == 'true':
-                    cfg_value = True
-                elif cfg_value == 'false':
-                    cfg_value = False
-                elif cfg_value.isdigit():
-                    cfg_value = int(cfg_value)
-                elif cfg_value.startswith('{') and cfg_value.endswith('}'):
-                    cfg_value = json.loads(cfg_value)
-                else:
-                    try:
-                        cfg_value = float(cfg_value)
-                    except ValueError:
-                        pass
-
-                # 检查类型是否匹配
-                if isinstance(getattr(config, cfg_name), type(cfg_value)):
-                    setattr(config, cfg_name, cfg_value)
-                    pkg.utils.context.set_config(config)
-                    reply = ["[bot]配置项{}修改成功".format(cfg_name)]
-                else:
-                    reply = ["[bot]err:配置项{}类型不匹配".format(cfg_name)]
-
        else:
-            reply = ["[bot]err:未找到配置项 {}".format(cfg_name)]
+            cfg_entry_path = cfg_name.split('.')
+
+            try:
+                if len(params) == 1:
+                    cfg_entry = getattr(config, cfg_entry_path[0])
+                    if len(cfg_entry_path) > 1:
+                        for i in range(1, len(cfg_entry_path)):
+                            cfg_entry = cfg_entry[cfg_entry_path[i]]
+
+                    if isinstance(cfg_entry, str):
+                        reply_str = "[bot]配置项{}: \"{}\"\n".format(cfg_name, cfg_entry)
+                    elif isinstance(cfg_entry, dict):
+                        reply_str = "[bot]配置项{}: {}\n".format(cfg_name,
+                                                                 json.dumps(cfg_entry,
+                                                                            ensure_ascii=False, indent=4))
+                    else:
+                        reply_str = "[bot]配置项{}: {}\n".format(cfg_name, cfg_entry)
+                    reply = [reply_str]
+                else:
+                    cfg_value = " ".join(params[1:])
+                    # 类型转换，如果是json则转换为字典
+                    # if cfg_value == 'true':
+                    #     cfg_value = True
+                    # elif cfg_value == 'false':
+                    #     cfg_value = False
+                    # elif cfg_value.isdigit():
+                    #     cfg_value = int(cfg_value)
+                    # elif cfg_value.startswith('{') and cfg_value.endswith('}'):
+                    #     cfg_value = json.loads(cfg_value)
+                    # else:
+                    #     try:
+                    #         cfg_value = float(cfg_value)
+                    #     except ValueError:
+                    #         pass
+                    cfg_value = eval(cfg_value)
+
+                    cfg_entry = getattr(config, cfg_entry_path[0])
+                    if len(cfg_entry_path) > 1:
+                        for i in range(1, len(cfg_entry_path) - 1):
+                            cfg_entry = cfg_entry[cfg_entry_path[i]]
+                        if isinstance(cfg_entry[cfg_entry_path[-1]], type(cfg_value)):
+                            cfg_entry[cfg_entry_path[-1]] = cfg_value
+                            reply = ["[bot]配置项{}修改成功".format(cfg_name)]
+                        else:
+                            reply = ["[bot]err:配置项{}类型不匹配".format(cfg_name)]
+                    else:
+                        setattr(config, cfg_entry_path[0], cfg_value)
+                        reply = ["[bot]配置项{}修改成功".format(cfg_name)]
+            except AttributeError:
+                reply = ["[bot]err:未找到配置项 {}".format(cfg_name)]
+            except ValueError:
+                reply = ["[bot]err:未找到配置项 {}".format(cfg_name)]
+        # else:
+        #     reply = ["[bot]err:未找到配置项 {}".format(cfg_name)]

    return reply

--- a/pkg/qqbot/manager.py
+++ b/pkg/qqbot/manager.py
@@ -102,6 +102,9 @@ class QQBotManager:

    enable_banlist = False

+    enable_private = True
+    enable_group = True
+
    ban_person = []
    ban_group = []

@@ -128,6 +131,7 @@ class QQBotManager:
                self.bot_account_id = self.adapter.bot_account_id
        else:
            self.adapter = pkg.utils.context.get_qqbot_manager().adapter
+            self.bot_account_id = pkg.utils.context.get_qqbot_manager().bot_account_id

        pkg.utils.context.set_qqbot_manager(self)

@@ -241,6 +245,11 @@ class QQBotManager:
            self.ban_group = banlist.group
            logging.info("加载禁用列表: person: {}, group: {}".format(self.ban_person, self.ban_group))

+            if hasattr(banlist, "enable_private"):
+                self.enable_private = banlist.enable_private
+            if hasattr(banlist, "enable_group"):
+                self.enable_group = banlist.enable_group
+
        config = pkg.utils.context.get_config()
        if os.path.exists("sensitive.json") \
                and config.sensitive_word_filter is not None \
@@ -268,7 +277,9 @@ class QQBotManager:
        import config
        reply = ''

-        if event.sender.id == self.bot_account_id:
+        if not self.enable_private:
+            logging.debug("已在banlist.py中禁用所有私聊")
+        elif event.sender.id == self.bot_account_id:
            pass
        else:
            if Image in event.message_chain:
@@ -341,8 +352,10 @@ class QQBotManager:
                replys = [tips_custom.replys_message]

            return replys
-
-        if Image in event.message_chain:
+        
+        if not self.enable_group:
+            logging.debug("已在banlist.py中禁用所有群聊")
+        elif Image in event.message_chain:
            pass
        else:
            if At(self.bot_account_id) in event.message_chain and response_at(event.group.id):
--- a/pkg/qqbot/message.py
+++ b/pkg/qqbot/message.py
@@ -114,8 +114,12 @@ def process_normal_message(text_message: str, mgr, config, launcher_type: str,
                reply = handle_exception("{}会话调用API失败:{}".format(session_name, e),
                                         "[bot]err:RateLimitError,请重试或联系作者，或等待修复")
        except openai.error.InvalidRequestError as e:
-            reply = handle_exception("{}API调用参数错误:{}\n".format(
-                             session_name, e), "[bot]err:API调用参数错误，请联系管理员，或等待修复")
+            if config.auto_reset and "This model's maximum context length is" in str(e):
+                session.reset(persist=True)
+                reply = [tips_custom.session_auto_reset_message]
+            else:
+                reply = handle_exception("{}API调用参数错误:{}\n".format(
+                                session_name, e), "[bot]err:API调用参数错误，请联系管理员，或等待修复")
        except openai.error.ServiceUnavailableError as e:
            reply = handle_exception("{}API调用服务不可用:{}".format(session_name, e), "[bot]err:API调用服务不可用，请重试或联系管理员，或等待修复")
        except Exception as e:
--- a/pkg/qqbot/process.py
+++ b/pkg/qqbot/process.py
@@ -74,12 +74,16 @@ def process_message(launcher_type: str, launcher_id: int, text_message: str, mes
    import config
    if config.income_msg_check:
        if mgr.reply_filter.is_illegal(text_message):
-            return MessageChain(Plain("[bot] 你的提问中有不合适的内容, 请更换措辞~"))
+            return MessageChain(Plain("[bot] 消息中存在不合适的内容, 请更换措辞"))

    pkg.openai.session.get_session(session_name).acquire_response_lock()

    text_message = text_message.strip()

+
+    # 为强制消息延迟计时
+    start_time = time.time()
+
    # 处理消息
    try:

@@ -168,4 +172,23 @@ def process_message(launcher_type: str, launcher_id: int, text_message: str, mes
    finally:
        pkg.openai.session.get_session(session_name).release_response_lock()

+    # 检查延迟时间
+    if config.force_delay_range[1] == 0:
+        delay_time = 0
+    else:
+        import random
+
+        # 从延迟范围中随机取一个值(浮点)
+        rdm = random.uniform(config.force_delay_range[0], config.force_delay_range[1])
+
+        spent = time.time() - start_time
+
+        # 如果花费时间小于延迟时间，则延迟
+        delay_time = rdm - spent if rdm - spent > 0 else 0
+
+    # 延迟
+    if delay_time > 0:
+        logging.info("[风控] 强制延迟{:.2f}秒(如需关闭，请到config.py修改force_delay_range字段)".format(delay_time))
+        time.sleep(delay_time)
+
    return MessageChain(reply)
--- a/pkg/qqbot/sources/nakuru.py
+++ b/pkg/qqbot/sources/nakuru.py
@@ -23,7 +23,7 @@ class NakuruProjectMessageConverter(MessageConverter):
        elif type(message_chain) is list:
            msg_list = message_chain
        else:
-            raise Exception("Unknown message type: " + str(message_chain) + type(message_chain))
+            raise Exception("Unknown message type: " + str(message_chain) + str(type(message_chain)))
        
        nakuru_msg_list = []
        
@@ -157,7 +157,6 @@ class NakuruProjectEventConverter(EventConverter):
            raise Exception("未支持转换的事件类型: " + str(event))


-
 class NakuruProjectAdapter(MessageSourceAdapter):
    """nakuru-project适配器"""
    bot: nakuru.CQHTTP
@@ -183,6 +182,9 @@ class NakuruProjectAdapter(MessageSourceAdapter):
            },
            timeout=5
        )
+        if resp.status_code == 403:
+            logging.error("go-cqhttp拒绝访问，请检查config.py中nakuru_config的token是否与go-cqhttp设置的access-token匹配")
+            raise Exception("go-cqhttp拒绝访问，请检查config.py中nakuru_config的token是否与go-cqhttp设置的access-token匹配")
        self.bot_account_id = int(resp.json()['data']['user_id'])

    def send_message(
--- a/pkg/utils/constants.py
+++ b/pkg/utils/constants.py
--- a/pkg/utils/updater.py
+++ b/pkg/utils/updater.py
@@ -34,13 +34,18 @@ def pull_latest(repo_path: str) -> bool:
    return True


-def is_newer_ignored_bugfix_ver(new_tag: str, old_tag: str):
-    """判断版本是否更新，忽略第四位版本"""
+def is_newer(new_tag: str, old_tag: str):
+    """判断版本是否更新，忽略第四位版本和第一位版本"""
    if new_tag == old_tag:
        return False

    new_tag = new_tag.split(".")
    old_tag = old_tag.split(".")
+    
+    # 判断主版本是否相同
+    if new_tag[0] != old_tag[0]:
+        return False
+
    if len(new_tag) < 4:
        return True

@@ -97,7 +102,7 @@ def update_all(cli: bool = False) -> bool:
    else:
        print("更新日志: {}".format(rls_notes))

-    if latest_rls == {} and not is_newer_ignored_bugfix_ver(latest_tag_name, current_tag):  # 没有新版本
+    if latest_rls == {} and not is_newer(latest_tag_name, current_tag):  # 没有新版本
        return False

    # 下载最新版本的zip到temp目录
@@ -254,7 +259,7 @@ def is_new_version_available() -> bool:
            latest_tag_name = rls['tag_name']
            break

-    return is_newer_ignored_bugfix_ver(latest_tag_name, current_tag)
+    return is_newer(latest_tag_name, current_tag)


 def get_rls_notes() -> list:
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,10 +1,11 @@
-requests~=2.28.1
-openai~=0.27.4
-dulwich~=0.21.3
+requests~=2.31.0
+openai~=0.27.8
+dulwich~=0.21.5
 colorlog~=6.6.0
-yiri-mirai~=0.2.6.1
+yiri-mirai~=0.2.7
 websockets
 urllib3~=1.26.10
 func_timeout~=4.3.5
 Pillow
-nakuru-project-idk
+nakuru-project-idk
+CallingGPT
--- a/res/announcement.json
+++ b/res/announcement.json
@@ -4,5 +4,11 @@
        "time": "2023-04-24 16:05:20",
        "timestamp": 1682323520,
        "content": "现已支持使用go-cqhttp替换mirai作为QQ登录框架, 请更新并查看 https://github.com/RockChinQ/QChatGPT/wiki/go-cqhttp%E9%85%8D%E7%BD%AE"
+    },
+    {
+        "id": 1,
+        "time": "2023-05-21 17:33:18",
+        "timestamp": 1684661598,
+        "content": "NewBing不再需要鉴权，若您正在使用revLibs逆向库插件，请立即使用!plugin update revLibs命令更新插件到最新版。"
    }
 ]
--- a/res/screenshots/webwlkr_plugin.png
+++ b/res/screenshots/webwlkr_plugin.png
--- a/res/templates/banlist-template.py
+++ b/res/templates/banlist-template.py
@@ -1,3 +1,13 @@
+# 是否处理群聊消息
+# 为False时忽略所有群聊消息
+# 优先级高于下方禁用列表
+enable_group = True
+
+# 是否处理私聊消息
+# 为False时忽略所有私聊消息
+# 优先级高于下方禁用列表
+enable_private = True
+
 # 是否启用禁用列表
 enable = True

--- a/res/templates/cmdpriv-template.json
+++ b/res/templates/cmdpriv-template.json
@@ -1,6 +1,7 @@
 {
    "comment": "以下为命令权限，请设置到cmdpriv.json中。关于此功能的说明，请查看：https://github.com/RockChinQ/QChatGPT/wiki/%E5%8A%9F%E8%83%BD%E4%BD%BF%E7%94%A8#%E5%91%BD%E4%BB%A4%E6%9D%83%E9%99%90%E6%8E%A7%E5%88%B6",
    "draw": 1,
+    "func": 1,
    "plugin": 2,
    "plugin.get": 2,
    "plugin.update": 2,
--- a/res/wiki/go-cqhttp配置.md
+++ b/res/wiki/go-cqhttp配置.md
@@ -5,20 +5,23 @@
 ## 步骤

 1. 从[go-cqhttp的Release](https://github.com/Mrs4s/go-cqhttp/releases/latest)下载最新的go-cqhttp可执行文件（建议直接下载可执行文件压缩包，而不是安装器）
-2. 解压并运行，首次运行会询问需要开放的网络协议，**请填入`02`并回车**
+2. 解压并运行，首次运行会询问需要开放的网络协议，**请填入`02`并回车，必须输入`02`❗❗❗❗❗❗❗**

-    ```
-    C:\Softwares\go-cqhttp.old> .\go-cqhttp.exe
-    未找到配置文件，正在为您生成配置文件中！
-    请选择你需要的通信方式:
-    > 0: HTTP通信
-    > 1: 云函数服务
-    > 2: 正向 Websocket 通信
-    > 3: 反向 Websocket 通信
-    请输入你需要的编号(0-9)，可输入多个，同一编号也可输入多个(如: 233)
-    您的选择是:02
-    ```
-    提示已生成`config.yml`文件，关闭go-cqhttp。
+<h1> 你这里必须得输入`02`，你懂么，`0`必须得输入，看好了，看好下面输入什么了吗？别他妈的搁那就输个`2`完了启动连不上还跑群里问，问一个我踢一个。 </h1>
+
+```
+C:\Softwares\go-cqhttp.old> .\go-cqhttp.exe
+未找到配置文件，正在为您生成配置文件中！
+请选择你需要的通信方式:
+> 0: HTTP通信
+> 1: 云函数服务
+> 2: 正向 Websocket 通信
+> 3: 反向 Websocket 通信
+请输入你需要的编号(0-9)，可输入多个，同一编号也可输入多个(如: 233)
+您的选择是:02
+```
+    
+提示已生成`config.yml`文件，关闭go-cqhttp。

 3. 打开go-cqhttp同目录的`config.yml`

@@ -64,4 +67,4 @@

 4. 配置完成，重新启动go-cqhttp

-> 若启动后登录不成功，请尝试根据[此文档](https://docs.go-cqhttp.org/guide/config.html#%E8%AE%BE%E5%A4%87%E4%BF%A1%E6%81%AF)修改`device.json`的协议编号。
+> 若启动后登录不成功，请尝试根据[此文档](https://docs.go-cqhttp.org/guide/config.html#%E8%AE%BE%E5%A4%87%E4%BF%A1%E6%81%AF)修改`device.json`的协议编号。
--- a/res/wiki/功能使用.md
+++ b/res/wiki/功能使用.md
@@ -225,7 +225,7 @@
 格式: `!cfg <配置项名称> <配置项新值>`  
 以修改`default_prompt`示例
 ```
-!cfg default_prompt 我是Rock Chin
+!cfg default_prompt "我是Rock Chin"
 ```

 输出示例
@@ -243,7 +243,15 @@
 ```
 !~all
 !~default_prompt
-!~default_prompt 我是Rock Chin
+!~default_prompt "我是Rock Chin"
+```
+
+5. 配置项名称支持使用点号(.)拼接以索引子配置项
+
+例如: `openai_config.api_key`将索引`config`字典中的`openai_config`字典中的`api_key`字段，可以通过这个方式查看或修改此子配置项
+
+```
+!~openai_config.api_key
 ```

 </details>
@@ -367,4 +375,5 @@ prompt_submit_length = <模型单次请求token数上限> - 情景预设中token

 ### 加入黑名单

-编辑`banlist.py`，设置`enable = True`，并在其中的`person`或`group`列表中加入要封禁的人或群聊，修改完成后重启程序或进行热重载
+- 支持禁用所有`私聊`或`群聊`，请查看`banlist.py`中的`enable_private`和`enable_group`字段
+- 编辑`banlist.py`，设置`enable = True`，并在其中的`person`或`group`列表中加入要封禁的人或群聊，修改完成后重启程序或进行热重载
--- a/res/wiki/插件使用.md
+++ b/res/wiki/插件使用.md
@@ -23,15 +23,18 @@ QChatGPT 插件使用Wiki

 ## 管理

-### !plugin 指令
+### !plugin 命令

 ```
-!plugin                列出所有已安装的插件
+!plugin                    列出所有已安装的插件
 !plugin get <储存库地址>    从Git储存库安装插件(需要管理员权限)
-!plugin update         更新所有插件(需要管理员权限，仅支持从储存库安装的插件)
-!plugin del <插件名>   删除插件(需要管理员权限)
-!plugin on <插件名>    启用插件(需要管理员权限)
-!plugin off <插件名>   禁用插件(需要管理员权限)
+!plugin update all         更新所有插件(需要管理员权限，仅支持从储存库安装的插件)
+!plugin update <插件名>    更新指定插件
+!plugin del <插件名>       删除插件(需要管理员权限)
+!plugin on <插件名>        启用插件(需要管理员权限)
+!plugin off <插件名>       禁用插件(需要管理员权限)
+
+!func                      列出所有内容函数
 ```

 ### 控制插件执行顺序
@@ -41,4 +44,9 @@ QChatGPT 插件使用Wiki
 ### 启用或关闭插件

 无需卸载即可管理插件的开关  
-编辑`plugins`目录下的`switch.json`文件，将相应的插件的`enabled`字段设置为`true/false(开/关)`，之后重启程序或执行热重载即可控制插件开关
+编辑`plugins`目录下的`switch.json`文件，将相应的插件的`enabled`字段设置为`true/false(开/关)`，之后重启程序或执行热重载即可控制插件开关
+
+### 控制全局内容函数开关
+
+内容函数是基于[GPT的Function Calling能力](https://platform.openai.com/docs/guides/gpt/function-calling)实现的，这是一种嵌入对话中，由GPT自动调用的函数。  
+每个插件可以自行注册内容函数，您可以在`plugins`目录下的`settings.json`中设置`functions`下的`enabled`为`true`或`false`控制这些内容函数的启用或禁用。
--- a/res/wiki/插件开发.md
+++ b/res/wiki/插件开发.md
@@ -113,6 +113,182 @@ class HelloPlugin(Plugin):
 - 一个目录内可以存放多个Python程序文件，以独立出插件的各个功能，便于开发者管理，但不建议在一个目录内注册多个插件
 - 插件需要的依赖库请在插件目录下的`requirements.txt`中指定，程序从储存库获取此插件时将自动安装依赖

+## 🪝内容函数
+
+通过[GPT的Function Calling能力](https://platform.openai.com/docs/guides/gpt/function-calling)实现的`内容函数`，这是一种嵌入对话中，由GPT自动调用的函数。
+
+<details>
+<summary>示例：联网插件</summary>
+
+加载含有联网功能的内容函数的插件[WebwlkrPlugin](https://github.com/RockChinQ/WebwlkrPlugin)，向机器人询问在线内容
+
+```
+# 控制台输出
+[2023-07-29 17:37:18.698] message.py (26) - [INFO] : [person_1010553892]发送消息:介绍一下这个项目：https://git...
+[2023-07-29 17:37:21.292] util.py (67) - [INFO] : message='OpenAI API response' path=https://api.openai.com/v1/chat/completions processing_ms=1902 request_id=941afc13b2e1bba1e7877b92a970cdea response_code=200
+[2023-07-29 17:37:21.293] chat_completion.py (159) - [INFO] : 执行函数调用: name=Webwlkr-access_the_web, arguments={'url': 'https://github.com/RockChinQ/QChatGPT', 'brief_len': 512}
+[2023-07-29 17:37:21.848] chat_completion.py (164) - [INFO] : 函数执行完成。
+```
+
+![Webwlkr插件](https://github.com/RockChinQ/QChatGPT/blob/master/res/screenshots/webwlkr_plugin.png?raw=true)
+
+</details>
+
+### 内容函数编写步骤
+
+1️⃣ 请先按照上方步骤编写您的插件基础结构，现在请删除（当然你也可以不删，只是为了简洁）上述插件内容的诸个由`@on`装饰的类函数
+
+<details>
+<summary>删除后的结构</summary>
+
+```python
+from pkg.plugin.models import *
+from pkg.plugin.host import EventContext, PluginHost
+
+"""
+在收到私聊或群聊消息"hello"时，回复"hello, <发送者id>!"或"hello, everyone!"
+"""
+
+
+# 注册插件
+@register(name="Hello", description="hello world", version="0.1", author="RockChinQ")
+class HelloPlugin(Plugin):
+
+    # 插件加载时触发
+    # plugin_host (pkg.plugin.host.PluginHost) 提供了与主程序交互的一些方法，详细请查看其源码
+    def __init__(self, plugin_host: PluginHost):
+        pass
+
+    # 插件卸载时触发
+    def __del__(self):
+        pass
+```
+
+</details>
+
+2️⃣ 现在我们将以下函数添加到刚刚删除的函数的位置
+
+```Python
+
+# 要添加的函数
+
+@func(name="access_the_web")  # 设置函数名称
+def _(url: str):
+    """Call this function to search about the question before you answer any questions.
+    - Do not search through baidu.com at any time.
+    - If you need to search somthing, visit https://www.google.com/search?q=xxx.
+    - If user ask you to open a url (start with http:// or https://), visit it directly.
+    - Summary the plain content result by yourself, DO NOT directly output anything in the result you got.
+
+    Args:
+        url(str): url to visit
+
+    Returns:
+        str: plain text content of the web page
+    """
+    import requests
+    from bs4 import BeautifulSoup
+    # 你需要先使用
+    # pip install beautifulsoup4
+    # 安装依赖
+
+    r = requests.get(
+        url,
+        timeout=10,
+        headers={
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.183"
+        }
+    )
+    soup = BeautifulSoup(r.text, 'html.parser')
+
+    s = soup.get_text()
+
+    # 删除多余的空行或仅有\t和空格的行
+    s = re.sub(r'\n\s*\n', '\n', s)
+
+    if len(s) >= 512:  # 截取获取到的网页纯文本内容的前512个字
+        return s[:512]
+
+    return s
+
+```
+<details>
+<summary>现在这个文件内容应该是这样</summary>
+
+```python
+from pkg.plugin.models import *
+from pkg.plugin.host import EventContext, PluginHost
+
+"""
+在收到私聊或群聊消息"hello"时，回复"hello, <发送者id>!"或"hello, everyone!"
+"""
+
+
+# 注册插件
+@register(name="Hello", description="hello world", version="0.1", author="RockChinQ")
+class HelloPlugin(Plugin):
+
+    # 插件加载时触发
+    # plugin_host (pkg.plugin.host.PluginHost) 提供了与主程序交互的一些方法，详细请查看其源码
+    def __init__(self, plugin_host: PluginHost):
+        pass
+
+    @func(name="access_the_web")
+    def _(url: str):
+        """Call this function to search about the question before you answer any questions.
+        - Do not search through baidu.com at any time.
+        - If you need to search somthing, visit https://www.google.com/search?q=xxx.
+        - If user ask you to open a url (start with http:// or https://), visit it directly.
+        - Summary the plain content result by yourself, DO NOT directly output anything in the result you got.
+
+        Args:
+            url(str): url to visit
+
+        Returns:
+            str: plain text content of the web page
+        """
+        import requests
+        from bs4 import BeautifulSoup
+        # 你需要先使用
+        # pip install beautifulsoup4
+        # 安装依赖
+
+        r = requests.get(
+            url,
+            timeout=10,
+            headers={
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.183"
+            }
+        )
+        soup = BeautifulSoup(r.text, 'html.parser')
+
+        s = soup.get_text()
+
+        # 删除多余的空行或仅有\t和空格的行
+        s = re.sub(r'\n\s*\n', '\n', s)
+
+        if len(s) >= 512:  # 截取获取到的网页纯文本内容的前512个字
+            return s[:512]
+
+        return s
+
+    # 插件卸载时触发
+    def __del__(self):
+        pass
+```
+
+</details>
+
+#### 请注意：
+
+- 函数的注释必须严格按照要求的格式进行书写，具体格式请查看[此文档](https://github.com/RockChinQ/CallingGPT/wiki/1.-Function-Format#function-format)
+- 内容函数和`以@on装饰的行为函数`可以同时存在于同一个插件，并同时受到`switch.json`中的插件开关的控制
+- 务必确保您使用的模型支持函数调用功能，可以到`config.py`的`completion_api_params`中修改模型，推荐使用`gpt-3.5-turbo-16k`
+
+3️⃣ 现在您的程序已具备网络访问功能，重启程序，询问机器人有关在线的内容或直接发送文章链接请求其总结。
+
+- 这仅仅是一个示例，需要更高效的网络访问能力支持插件，请查看[WebwlkrPlugin](https://github.com/RockChinQ/WebwlkrPlugin)
+
 ## 📄API参考

 ### 说明
--- a/tips-custom-template.py
+++ b/tips-custom-template.py
@@ -27,8 +27,11 @@ replys_message = "[bot]err:请求超时"
 # 指令权限不足提示
 command_admin_message = "[bot]err:权限不足： "
 # 指令无效提示
-command_err_message = "[bot]err:指令执行出错："
+command_err_message = "[bot]err:指令不存在："

 # 会话重置提示
-command_reset_message = "[bot]:会话已重置"
-command_reset_name_message = "[bot]:会话已重置，使用场景预设:"
+command_reset_message = "[bot]会话已重置"
+command_reset_name_message = "[bot]会话已重置，使用场景预设:"
+
+# 会话自动重置时的提示
+session_auto_reset_message = "[bot]会话token超限，已自动重置，请重新发送消息"
Author	SHA1	Message	Date
RockChinQ	a56b340646	Release v2.5.0	2023-07-29 18:59:25 +08:00
Junyan Qin	7473cdfe16	Merge pull request #513 from RockChinQ/feat-function-calling-integration [Feat] 支持GPT的函数调用功能	2023-07-29 18:57:29 +08:00
RockChinQ	24273ac158	doc: README添加内容函数相关内容	2023-07-29 18:55:18 +08:00
RockChinQ	fe6275000e	doc(wiki): 更新wiki插件页	2023-07-29 18:40:49 +08:00
RockChinQ	5fbf369f82	doc(wiki): 更新插件页	2023-07-29 18:37:03 +08:00
Junyan Qin	4400475ffa	chore: 添加Webwlkr插件示例	2023-07-29 17:41:56 +08:00
GitHub Actions Bot	796eb7c95d	Update cmdpriv-template.json	2023-07-29 09:30:22 +00:00
RockChinQ	89a01378e7	ci: 跑工作流	2023-07-29 17:29:52 +08:00
RockChinQ	f4735e5e30	ci(cmd_priv): 添加CallingGPT依赖	2023-07-29 17:28:11 +08:00
RockChinQ	f1bb3045aa	feat: 添加func命令	2023-07-29 17:26:07 +08:00
RockChinQ	96e474a555	feat: 插件开关对其内容函数生效	2023-07-29 17:10:47 +08:00
RockChinQ	833d29b101	typo: enable->enabled	2023-07-29 16:55:01 +08:00
RockChinQ	dce6734ba2	feat: 改为推荐使用func()装饰器注册内容函数	2023-07-29 16:51:19 +08:00
RockChinQ	0481167dc6	feat: 改为在start流程设置openai.proxy	2023-07-29 16:36:31 +08:00
RockChinQ	a002f93f7b	chore: 删除过时代码	2023-07-29 16:30:09 +08:00
RockChinQ	3c894fe70e	feat: chat_completion的函数开关支持	2023-07-29 16:29:16 +08:00
RockChinQ	8c69b8a1d9	feat: 内容函数全局开关支持	2023-07-29 16:28:18 +08:00
Junyan Qin	a9dae05303	doc(README.md): 修改社区群群号	2023-07-29 13:31:58 +08:00
RockChinQ	ae6994e241	feat(contentPlugin): 完成基本的内容函数调用功能	2023-07-28 19:03:02 +08:00
Rock Chin	caa72fa40c	feat: 在插件层面初步支持内容函数	2023-07-27 14:27:36 +08:00
Junyan Qin	46cc9220c3	Merge pull request #506 from RockChinQ/perf-persist-dprompt-when-auto-reset [Perf] 在session自动重置时保留非default的prompt	2023-07-07 17:53:29 +08:00
Rock Chin	ddb56d7a8e	fix: reset命令错误的逻辑	2023-07-07 17:49:43 +08:00
Rock Chin	a0267416d7	fix: 修复reset逻辑导致的无法初始化情景预设问题	2023-07-07 16:37:05 +08:00
Rock Chin	56e1ef3602	fix: 修复reset可能引起的bug	2023-07-07 16:35:37 +08:00
Rock Chin	b4fc1057d1	perf: 在session自动重置时保留非default的prompt (#494 )	2023-07-06 23:09:39 +08:00
Rock Chin	06037df607	ci: 仅在master分支运行sync-wiki工作流	2023-06-20 22:42:18 +08:00
Rock Chin	dce134d08d	Release v2.4.7	2023-06-16 19:43:13 +08:00
Junyan Qin	cca471d068	Merge pull request #500 from RockChinQ/perf-more-model-support Perf more model support	2023-06-16 19:40:29 +08:00
Rock Chin	ddb211b74a	feat: 支持新的模型	2023-06-16 19:35:26 +08:00
Rock Chin	cef70751ff	chore: 修改配置文件说明	2023-06-16 19:35:06 +08:00
JunYan Qin	2d2219fc6e	更新 README.md	2023-06-13 11:59:30 +08:00
JunYan Qin	514a6b4192	更新 README.md	2023-06-13 11:59:07 +08:00
JunYan Qin	7a552b3434	Merge pull request #496 from RockChinQ/dependabot/pip/openai-approx-eq-0.27.8 chore(deps): update openai requirement from ~=0.27.7 to ~=0.27.8	2023-06-12 23:20:02 +08:00
dependabot[bot]	ecebd1b0e0	chore(deps): update openai requirement from ~=0.27.7 to ~=0.27.8 Updates the requirements on [openai](https://github.com/openai/openai-python) to permit the latest version. - [Release notes](https://github.com/openai/openai-python/releases) - [Commits](https://github.com/openai/openai-python/compare/v0.27.7...v0.27.8) --- updated-dependencies: - dependency-name: openai dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>	2023-06-12 09:01:51 +00:00
Rock Chin	8dc34d2a88	doc(README.md): 添加卖号网站	2023-06-12 14:13:36 +08:00
Rock Chin	d52644ceec	doc: 更新README.md	2023-06-12 12:24:59 +08:00
Rock Chin	3052510591	Release v2.4.6	2023-06-08 14:01:18 +08:00
Rock Chin	777a5617db	Merge pull request #492 from RockChinQ/feat-ignore-major-vernum [Feat] 更新时忽略主版本号不同的版本	2023-06-08 14:00:32 +08:00
Rock Chin	e17c1087e9	feat(updater.py): 更新时忽略主版本号不同的版本	2023-06-08 13:57:24 +08:00
Rock Chin	633695175a	Merge pull request #491 from RockChinQ/feat-tokens-auto-reset [Feat] token超限报错时自动重置会话	2023-06-08 13:49:49 +08:00
Rock Chin	9e78bf3d21	perf: 更严格的重置条件判断	2023-06-08 13:49:20 +08:00
Rock Chin	43aa68a55d	feat: 支持在token超限时自动重置会话	2023-06-08 13:45:54 +08:00
Rock Chin	b8308f8c57	Merge branch 'feat-tokens-auto-reset' of https://github.com/RockChinQ/QChatGPT into feat-tokens-auto-reset	2023-06-08 13:43:36 +08:00
Rock Chin	466bfbddeb	perf: 提示语格式	2023-06-08 13:43:33 +08:00
GitHub Actions	b6da07b225	Update override-all.json	2023-06-08 05:20:55 +00:00
Rock Chin	2f2159239a	chore: 添加开关和提示语配置项	2023-06-08 13:20:33 +08:00
Rock Chin	67d1ca8a65	Merge pull request #490 from RockChinQ/feat-global-group-private-enable [Feat] 支持设置全局群聊/私聊消息禁用	2023-06-07 23:49:53 +08:00
Rock Chin	497a393e83	doc: 修改wiki	2023-06-07 23:49:09 +08:00
Rock Chin	782c0e22ea	feat: 支持设置全局群聊、私聊禁用	2023-06-07 23:47:13 +08:00
Rock Chin	2932fc6dfd	chore(banlist-template.py): 添加配置项	2023-06-07 23:23:21 +08:00
Rock Chin	0a9eab2113	chore(requirements.txt): 更新requests版本	2023-06-06 09:37:00 +08:00
Rock Chin	50a673a8ec	doc: 添加插件列表list	2023-06-05 22:37:19 +08:00
Rock Chin	9e25d0f9e4	Release v2.4.5	2023-05-31 18:31:25 +08:00
Rock Chin	23cd7be711	Merge pull request #487 from RockChinQ/feat-banlist-syntax-check feat: 初始化流程异常处理	2023-05-31 18:25:46 +08:00
Rock Chin	025b9e33f1	feat: 初始化流程异常处理	2023-05-31 18:24:01 +08:00
Rock Chin	bab2f64913	doc(README_en.md): 添加wakapi计时	2023-05-29 11:12:07 +08:00
Rock Chin	b00e09aa9c	doc: 添加wakapi计时	2023-05-29 11:10:49 +08:00
Rock Chin	0b109fdc7a	Merge pull request #479 from RockChinQ/dependabot/pip/openai-approx-eq-0.27.7 chore(deps): update openai requirement from ~=0.27.6 to ~=0.27.7	2023-05-22 17:13:50 +08:00
dependabot[bot]	018fea2ddb	chore(deps): update openai requirement from ~=0.27.6 to ~=0.27.7 Updates the requirements on [openai](https://github.com/openai/openai-python) to permit the latest version. - [Release notes](https://github.com/openai/openai-python/releases) - [Commits](https://github.com/openai/openai-python/compare/v0.27.6...v0.27.7) --- updated-dependencies: - dependency-name: openai dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>	2023-05-22 09:05:00 +00:00
Rock Chin	f8a3cc4352	doc: 折起OpenAI注册步骤	2023-05-21 18:25:35 +08:00
Rock Chin	6ab853acc1	doc: 修改关于HuggingChat的说明	2023-05-21 17:50:35 +08:00
Rock Chin	e825dea02f	chore: 排除hugchat.json	2023-05-21 17:47:42 +08:00
Rock Chin	cf8740d16e	Merge branch 'master' of https://github.com/RockChinQ/QChatGPT	2023-05-21 17:33:47 +08:00
Rock Chin	9c4809e26f	chore: 发布revLibs相关公告	2023-05-21 17:33:44 +08:00
Rock Chin	0a232fd9ef	Merge pull request #477 from RockChinQ/feature-detailed-cfg-cmd [Feat] 支持使用!cfg指令修改子配置项	2023-05-21 15:59:59 +08:00
Rock Chin	23016a0791	doc: 更新wiki说明	2023-05-21 15:58:21 +08:00
Rock Chin	cdcc67ff23	feat(!cfg): 使用eval()函数进行类型转换	2023-05-21 15:53:56 +08:00
Rock Chin	92274bfc34	feat(!cfg): 支持使用点号索引子配置项	2023-05-21 15:49:56 +08:00
Rock Chin	2fed6f61ba	Release v2.4.4	2023-05-21 15:15:28 +08:00
Rock Chin	59b2cd26d2	Merge pull request #476 from RockChinQ/hotfix-471-at-no-response-aft-reload [Fix] 热重载之后不响应群内at	2023-05-21 15:12:43 +08:00
Rock Chin	f7b87e99d2	fix(manager.py): 热重载之后不响应群内at	2023-05-21 15:11:34 +08:00
Rock Chin	70bc985145	perf(nakuru.py): access-token被拒时报警	2023-05-18 21:06:32 +08:00
Rock Chin	070dbe9108	chore: 排除venv/目录	2023-05-18 21:05:45 +08:00
Rock Chin	a63fa6d955	chore: yiri-mirai使用0.2.7	2023-05-18 21:05:30 +08:00
Rock Chin	c7703809b0	Merge pull request #475 from RockChinQ/actively-delay [Feat] 支持设置消息回复强制延迟以降低风控概率	2023-05-18 20:15:52 +08:00
GitHub Actions	37eb74338f	Update override-all.json	2023-05-18 12:14:19 +00:00
Rock Chin	77d5585b7c	feat: 修改强制延迟默认范围	2023-05-18 20:13:53 +08:00
Rock Chin	6cab3ef029	Merge branch 'actively-delay' of https://github.com/RockChinQ/QChatGPT into actively-delay	2023-05-18 20:12:39 +08:00
Rock Chin	820a7b78fc	feat: 处理过程支持强制延迟	2023-05-18 20:12:36 +08:00
GitHub Actions	c51dffef3a	Update override-all.json	2023-05-18 12:10:33 +00:00
Rock Chin	983bc3da3c	chore: 添加强制延迟配置项	2023-05-18 20:10:08 +08:00
Rock Chin	09be956a58	Merge pull request #474 from RockChinQ/command-notfound-err [Perf] 修改指令不存在时的提示信息	2023-05-18 19:45:25 +08:00
Rock Chin	5eded50c53	perf: 修改指令不存在时的提示信息	2023-05-18 19:44:20 +08:00
Rock Chin	6d8eebd314	doc: 添加微信赞赏码	2023-05-16 15:36:07 +08:00
Rock Chin	19a0572b5f	Release v2.4.3.1	2023-05-15 17:38:03 +08:00
Rock Chin	6272e98474	Merge pull request #467 from RockChinQ/perf-plugin-update [Perf] 优化插件更新相关操作	2023-05-14 18:45:36 +08:00
Rock Chin	45042fe7d4	doc: 更新插件更新命令wiki	2023-05-14 18:44:14 +08:00
Rock Chin	d85e840126	perf: 优化插件更新操作，支持更新单个插件	2023-05-14 18:41:20 +08:00
Rock Chin	804889f1de	perf: 加载模块的输出改为debug级别	2023-05-14 17:30:05 +08:00
Rock Chin	919c996434	doc: 添加HuggingChat	2023-05-14 17:14:46 +08:00
Rock Chin	00823b3d62	doc(README): 添加HuggingChat	2023-05-14 17:14:28 +08:00
Rock Chin	af54efd24a	doc(README.md): 添加系统状态插件	2023-05-14 14:58:48 +08:00
Rock Chin	b1c9b121f6	Update go-cqhttp配置.md	2023-05-08 21:51:03 +08:00
Rock Chin	7b5649d153	Merge pull request #461 from RockChinQ/dependabot/pip/openai-approx-eq-0.27.6 chore(deps): update openai requirement from ~=0.27.5 to ~=0.27.6	2023-05-08 18:48:20 +08:00
dependabot[bot]	52bf716d84	chore(deps): update openai requirement from ~=0.27.5 to ~=0.27.6 Updates the requirements on [openai](https://github.com/openai/openai-python) to permit the latest version. - [Release notes](https://github.com/openai/openai-python/releases) - [Commits](https://github.com/openai/openai-python/compare/v0.27.5...v0.27.6) --- updated-dependencies: - dependency-name: openai dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>	2023-05-08 10:34:21 +00:00
Rock Chin	c149dd7b66	Merge pull request #462 from RockChinQ/dependabot/pip/dulwich-approx-eq-0.21.5 chore(deps): update dulwich requirement from ~=0.21.3 to ~=0.21.5	2023-05-08 18:24:59 +08:00
dependabot[bot]	65d5a1ed63	chore(deps): update dulwich requirement from ~=0.21.3 to ~=0.21.5 Updates the requirements on [dulwich](https://github.com/dulwich/dulwich) to permit the latest version. - [Release notes](https://github.com/dulwich/dulwich/releases) - [Changelog](https://github.com/jelmer/dulwich/blob/master/NEWS) - [Commits](https://github.com/dulwich/dulwich/compare/dulwich-0.21.3...dulwich-0.21.5) --- updated-dependencies: - dependency-name: dulwich dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>	2023-05-08 09:01:55 +00:00
Rock Chin	5516754bbb	doc(README.md): 添加docker部署提示	2023-05-02 14:30:25 +08:00
Rock Chin	08082f2ee3	Merge pull request #452 from RockChinQ/dependabot/pip/openai-approx-eq-0.27.5 chore(deps): update openai requirement from ~=0.27.4 to ~=0.27.5	2023-05-01 17:26:18 +08:00
dependabot[bot]	8489266080	chore(deps): update openai requirement from ~=0.27.4 to ~=0.27.5 Updates the requirements on [openai](https://github.com/openai/openai-python) to permit the latest version. - [Release notes](https://github.com/openai/openai-python/releases) - [Commits](https://github.com/openai/openai-python/compare/v0.27.4...v0.27.5) --- updated-dependencies: - dependency-name: openai dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com>	2023-05-01 09:06:44 +00:00
Rock Chin	51c7e0b235	doc(README.md): 四群群号	2023-04-28 00:37:29 +08:00
Rock Chin	628b6b0bb4	Merge branch 'master' of https://github.com/RockChinQ/QChatGPT	2023-04-27 15:01:47 +08:00
Rock Chin	7e024d860d	doc: 增加LightQChat的公告	2023-04-27 15:01:44 +08:00
Rock Chin	c2f6273f70	Merge pull request #442 from oliverkirk-sudo/master 修复异常输出时的类型问题	2023-04-26 17:31:19 +08:00
oliverkirk-sudo	96e401ec7b	修复异常输出时的类型问题	2023-04-26 17:27:33 +08:00
Rock Chin	ae8ac65447	feat: 更换使用清华源 (#438 )	2023-04-26 11:52:07 +08:00
Rock Chin	2d4f59f36e	doc: 强调02	2023-04-26 11:18:07 +08:00