Bug修复

pkg/openai~/__init__.py

@@ -0,0 +1,2 @@
+"""OpenAI 接口处理及会话管理相关
+"""

pkg/openai~/dprompt.py

@@ -0,0 +1,79 @@
+# 多情景预设值管理
+
+__current__ = "default"
+"""当前默认使用的情景预设的名称
+
+由管理员使用`!default <名称>`指令切换
+"""
+
+__prompts_from_files__ = {}
+"""从文件中读取的情景预设值"""
+
+
+def read_prompt_from_file() -> str:
+    """从文件读取预设值"""
+    # 读取prompts/目录下的所有文件，以文件名为键，文件内容为值
+    # 保存在__prompts_from_files__中
+    global __prompts_from_files__
+    import os
+
+    __prompts_from_files__ = {}
+    for file in os.listdir("prompts"):
+        with open(os.path.join("prompts", file), encoding="utf-8") as f:
+            __prompts_from_files__[file] = f.read()
+
+
+def get_prompt_dict() -> dict:
+    """获取预设值字典"""
+    import config
+    default_prompt = config.default_prompt
+    if type(default_prompt) == str:
+        default_prompt = {"default": default_prompt}
+    elif type(default_prompt) == dict:
+        pass
+    else:
+        raise TypeError("default_prompt must be str or dict")
+
+    # 将文件中的预设值合并到default_prompt中
+    for key in __prompts_from_files__:
+        default_prompt[key] = __prompts_from_files__[key]
+
+    return default_prompt
+
+
+def set_current(name):
+    global __current__
+    for key in get_prompt_dict():
+        if key.lower().startswith(name.lower()):
+            __current__ = key
+            return
+    raise KeyError("未找到情景预设: " + name)
+
+
+def get_current():
+    global __current__
+    return __current__
+
+
+def set_to_default():
+    global __current__
+    default_dict = get_prompt_dict()
+
+    if "default" in default_dict:
+        __current__ = "default"
+    else:
+        __current__ = list(default_dict.keys())[0]
+
+
+def get_prompt(name: str = None) -> str:
+    """获取预设值"""
+    if name is None:
+        name = get_current()
+
+    default_dict = get_prompt_dict()
+
+    for key in default_dict:
+        if key.lower().startswith(name.lower()):
+            return default_dict[key]
+
+    raise KeyError("未找到情景预设: " + name)

pkg/openai~/keymgr.py

@@ -0,0 +1,91 @@
+# 此模块提供了维护api-key的各种功能
+import hashlib
+import logging
+
+import pkg.plugin.host as plugin_host
+import pkg.plugin.models as plugin_models
+
+
+class KeysManager:
+    api_key = {}
+    """所有api-key"""
+
+    using_key = ""
+    """当前使用的api-key
+    """
+
+    alerted = []
+    """已提示过超额的key
+    
+    记录在此以避免重复提示
+    """
+
+    exceeded = []
+    """已超额的key
+    
+    供自动切换功能识别
+    """
+
+    def get_using_key(self):
+        return self.using_key
+
+    def get_using_key_md5(self):
+        return hashlib.md5(self.using_key.encode('utf-8')).hexdigest()
+
+    def __init__(self, api_key):
+
+        if type(api_key) is dict:
+            self.api_key = api_key
+        elif type(api_key) is str:
+            self.api_key = {
+                "default": api_key
+            }
+        elif type(api_key) is list:
+            for i in range(len(api_key)):
+                self.api_key[str(i)] = api_key[i]
+        # 从usage中删除未加载的api-key的记录
+        # 不删了，也许会运行时添加曾经有记录的api-key
+
+        self.auto_switch()
+
+    def auto_switch(self) -> (bool, str):
+        """尝试切换api-key
+
+        Returns:
+            是否切换成功, 切换后的api-key的别名
+        """
+
+        for key_name in self.api_key:
+            if self.api_key[key_name] not in self.exceeded:
+                self.using_key = self.api_key[key_name]
+
+                logging.info("使用api-key:" + key_name)
+
+                # 触发插件事件
+                args = {
+                    "key_name": key_name,
+                    "key_list": self.api_key.keys()
+                }
+                _ = plugin_host.emit(plugin_models.KeySwitched, **args)
+
+                return True, key_name
+
+        self.using_key = list(self.api_key.values())[0]
+        logging.info("使用api-key:" + list(self.api_key.keys())[0])
+
+        return False, ""
+
+    def add(self, key_name, key):
+        self.api_key[key_name] = key
+
+    def set_current_exceeded(self):
+        """设置当前使用的api-key使用量超限
+        """
+        self.exceeded.append(self.using_key)
+
+    def get_key_name(self, api_key):
+        """根据api-key获取其别名"""
+        for key_name in self.api_key:
+            if self.api_key[key_name] == api_key:
+                return key_name
+        return ""

pkg/openai~/manager.py

@@ -0,0 +1,93 @@
+import logging
+
+import openai
+
+import pkg.openai.keymgr
+import pkg.utils.context
+import pkg.audit.gatherer
+from pkg.openai.modelmgr import ModelRequest, create_openai_model_request
+
+
+class OpenAIInteract:
+    """OpenAI 接口封装
+
+    将文字接口和图片接口封装供调用方使用
+    """
+
+    key_mgr: pkg.openai.keymgr.KeysManager = None
+
+    audit_mgr: pkg.audit.gatherer.DataGatherer = None
+
+    default_image_api_params = {
+        "size": "256x256",
+    }
+
+    def __init__(self, api_key: str):
+
+        self.key_mgr = pkg.openai.keymgr.KeysManager(api_key)
+        self.audit_mgr = pkg.audit.gatherer.DataGatherer()
+
+        logging.info("文字总使用量：%d", self.audit_mgr.get_total_text_length())
+
+        openai.api_key = self.key_mgr.get_using_key()
+
+        pkg.utils.context.set_openai_manager(self)
+
+    # 请求OpenAI Completion
+    def request_completion(self, prompts) -> str:
+        """请求补全接口回复
+
+        Parameters:
+            prompts (str): 提示语
+
+        Returns:
+            str: 回复
+        """
+
+        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()
+
+        logging.debug("OpenAI response: %s", response)
+
+        if 'model' in config.completion_api_params:
+            self.audit_mgr.report_text_model_usage(config.completion_api_params['model'],
+                                                   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'])
+
+        return ai.get_message()
+
+    def request_image(self, prompt) -> dict:
+        """请求图片接口回复
+
+        Parameters:
+            prompt (str): 提示语
+
+        Returns:
+            dict: 响应
+        """
+        config = pkg.utils.context.get_config()
+        params = config.image_api_params if hasattr(config, "image_api_params") else self.default_image_api_params
+
+        response = openai.Image.create(
+            prompt=prompt,
+            n=1,
+            **params
+        )
+
+        self.audit_mgr.report_image_model_usage(params['size'])
+
+        return response
+

pkg/openai~/modelmgr.py

@@ -0,0 +1,184 @@
+"""OpenAI 接口底层封装
+
+目前使用的对话接口有：
+ChatCompletion - gpt-3.5-turbo 等模型
+Completion - text-davinci-003 等模型
+此模块封装此两个接口的请求实现，为上层提供统一的调用方式
+"""
+import openai, logging, threading, asyncio
+import openai.error as aiE
+
+COMPLETION_MODELS = {
+    'text-davinci-003',
+    'text-davinci-002',
+    'code-davinci-002',
+    'code-cushman-001',
+    'text-curie-001',
+    'text-babbage-001',
+    'text-ada-001',
+}
+
+CHAT_COMPLETION_MODELS = {
+    'gpt-3.5-turbo',
+    'gpt-3.5-turbo-0301',
+}
+
+EDIT_MODELS = {
+
+}
+
+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 Exception(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:
+    """使用给定的模型名称创建模型请求对象"""
+    if model_name in CHAT_COMPLETION_MODELS:
+        model = ChatCompletionModel(model_name, user_name, http_proxy)
+    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

pkg/openai~/pricing.bak.py

@@ -0,0 +1,28 @@
+# 计费模块
+# 已弃用 https://github.com/RockChinQ/QChatGPT/issues/81
+
+import logging
+
+pricing = {
+    "base": {  # 文字模型单位是1000字符
+        "text-davinci-003": 0.02,
+    },
+    "image": {
+        "256x256": 0.016,
+        "512x512": 0.018,
+        "1024x1024": 0.02,
+    }
+}
+
+
+def language_base_price(model, text):
+    salt_rate = 0.93
+    length = ((len(text.encode('utf-8')) - len(text)) / 2 + len(text)) * salt_rate
+    logging.debug("text length: %d" % length)
+
+    return pricing["base"][model] * length / 1000
+
+
+def image_price(size):
+    logging.debug("image size: %s" % size)
+    return pricing["image"][size]

pkg/openai~/session.py

@@ -0,0 +1,370 @@
+"""主线使用的会话管理模块
+
+每个人、每个群单独一个session，session内部保留了对话的上下文，
+"""
+
+import logging
+import threading
+import time
+import json
+
+import pkg.openai.manager
+import pkg.openai.modelmgr
+import pkg.database.manager
+import pkg.utils.context
+
+import pkg.plugin.host as plugin_host
+import pkg.plugin.models as plugin_models
+
+# 运行时保存的所有session
+sessions = {}
+
+
+class SessionOfflineStatus:
+    ON_GOING = 'on_going'
+    EXPLICITLY_CLOSED = 'explicitly_closed'
+
+
+# 重置session.prompt
+def reset_session_prompt(session_name, prompt):
+    # 备份原始数据
+    bak_path = 'logs/{}-{}.bak'.format(
+        session_name,
+        time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime())
+    )
+    f = open(bak_path, 'w+')
+    f.write(prompt)
+    f.close()
+    # 生成新数据
+    config = pkg.utils.context.get_config()
+    prompt = [
+        {
+            'role': 'system',
+            'content': config.default_prompt['default']
+        }
+    ]
+    # 警告
+    logging.warning(
+        """
+用户[{}]的数据已被重置，有可能是因为数据版本过旧或存储错误
+原始数据将备份在：
+{}""".format(session_name, bak_path)
+    )  # 为保证多行文本格式正确故无缩进
+    return prompt
+
+
+# 从数据加载session
+def load_sessions():
+    """从数据库加载sessions"""
+
+    global sessions
+
+    db_inst = pkg.utils.context.get_database_manager()
+
+    session_data = db_inst.load_valid_sessions()
+
+    for session_name in session_data:
+        logging.info('加载session: {}'.format(session_name))
+
+        temp_session = Session(session_name)
+        temp_session.name = session_name
+        temp_session.create_timestamp = session_data[session_name]['create_timestamp']
+        temp_session.last_interact_timestamp = session_data[session_name]['last_interact_timestamp']
+        try:
+            temp_session.prompt = json.loads(session_data[session_name]['prompt'])
+        except Exception:
+            temp_session.prompt = reset_session_prompt(session_name, session_data[session_name]['prompt'])
+            temp_session.persistence()
+
+        sessions[session_name] = temp_session
+
+
+# 获取指定名称的session，如果不存在则创建一个新的
+def get_session(session_name: str):
+    global sessions
+    if session_name not in sessions:
+        sessions[session_name] = Session(session_name)
+    return sessions[session_name]
+
+
+def dump_session(session_name: str):
+    global sessions
+    if session_name in sessions:
+        assert isinstance(sessions[session_name], Session)
+        sessions[session_name].persistence()
+        del sessions[session_name]
+
+
+# 通用的OpenAI API交互session
+# session内部保留了对话的上下文，
+# 收到用户消息后，将上下文提交给OpenAI API生成回复
+class Session:
+    name = ''
+
+    prompt = []
+    """使用list来保存会话中的回合"""
+
+    create_timestamp = 0
+    """会话创建时间"""
+
+    last_interact_timestamp = 0
+    """上次交互(产生回复)时间"""
+
+    just_switched_to_exist_session = False
+
+    response_lock = None
+
+    # 加锁
+    def acquire_response_lock(self):
+        logging.debug('{},lock acquire,{}'.format(self.name, self.response_lock))
+        self.response_lock.acquire()
+        logging.debug('{},lock acquire successfully,{}'.format(self.name, self.response_lock))
+
+    # 释放锁
+    def release_response_lock(self):
+        if self.response_lock.locked():
+            logging.debug('{},lock release,{}'.format(self.name, self.response_lock))
+            self.response_lock.release()
+            logging.debug('{},lock release successfully,{}'.format(self.name, self.response_lock))
+
+    # 从配置文件获取会话预设信息
+    def get_default_prompt(self, use_default: str = None):
+        config = pkg.utils.context.get_config()
+
+        import pkg.openai.dprompt as dprompt
+
+        if use_default is None:
+            current_default_prompt = dprompt.get_prompt(dprompt.get_current())
+        else:
+            current_default_prompt = dprompt.get_prompt(use_default)
+
+        return [
+            {
+                'role': 'user',
+                'content': current_default_prompt
+            }, {
+                'role': 'assistant',
+                'content': 'ok'
+            }
+        ]
+
+    def __init__(self, name: str):
+        self.name = name
+        self.create_timestamp = int(time.time())
+        self.last_interact_timestamp = int(time.time())
+        self.schedule()
+
+        self.response_lock = threading.Lock()
+        self.prompt = self.get_default_prompt()
+
+    # 设定检查session最后一次对话是否超过过期时间的计时器
+    def schedule(self):
+        threading.Thread(target=self.expire_check_timer_loop, args=(self.create_timestamp,)).start()
+
+    # 检查session是否已经过期
+    def expire_check_timer_loop(self, create_timestamp: int):
+        global sessions
+        while True:
+            time.sleep(60)
+
+            # 不是此session已更换，退出
+            if self.create_timestamp != create_timestamp or self not in sessions.values():
+                return
+
+            config = pkg.utils.context.get_config()
+            if int(time.time()) - self.last_interact_timestamp > config.session_expire_time:
+                logging.info('session {} 已过期'.format(self.name))
+
+                # 触发插件事件
+                args = {
+                    'session_name': self.name,
+                    'session': self,
+                    'session_expire_time': config.session_expire_time
+                }
+                event = pkg.plugin.host.emit(plugin_models.SessionExpired, **args)
+                if event.is_prevented_default():
+                    return
+
+                self.reset(expired=True, schedule_new=False)
+
+                # 删除此session
+                del sessions[self.name]
+                return
+
+    # 请求回复
+    # 这个函数是阻塞的
+    def append(self, text: str) -> str:
+        """向session中添加一条消息，返回接口回复"""
+
+        self.last_interact_timestamp = int(time.time())
+
+        # 触发插件事件
+        if self.prompt == self.get_default_prompt():
+            args = {
+                'session_name': self.name,
+                'session': self,
+                'default_prompt': self.prompt,
+            }
+
+            event = pkg.plugin.host.emit(plugin_models.SessionFirstMessageReceived, **args)
+            if event.is_prevented_default():
+                return None
+
+        config = pkg.utils.context.get_config()
+        max_length = config.prompt_submit_length if hasattr(config, "prompt_submit_length") else 1024
+
+        # 向API请求补全
+        message = pkg.utils.context.get_openai_manager().request_completion(
+            self.cut_out(text, max_length),
+        )
+
+        # 成功获取，处理回复
+        res_test = message
+        res_ans = res_test
+
+        # 去除开头可能的提示
+        res_ans_spt = res_test.split("\n\n")
+        if len(res_ans_spt) > 1:
+            del (res_ans_spt[0])
+            res_ans = '\n\n'.join(res_ans_spt)
+
+        # 将此次对话的双方内容加入到prompt中
+        self.prompt.append({'role': 'user', 'content': text})
+        self.prompt.append({'role': 'assistant', 'content': res_ans})
+
+        if self.just_switched_to_exist_session:
+            self.just_switched_to_exist_session = False
+            self.set_ongoing()
+
+        return res_ans if res_ans[0] != '\n' else res_ans[1:]
+
+    # 删除上一回合并返回上一回合的问题
+    def undo(self) -> str:
+        self.last_interact_timestamp = int(time.time())
+
+        # 删除最后两个消息
+        if len(self.prompt) < 2:
+            raise Exception('之前无对话，无法撤销')
+
+        question = self.prompt[-2]['content']
+        self.prompt = self.prompt[:-2]
+
+        # 返回上一回合的问题
+        return question
+
+    # 构建对话体
+    def cut_out(self, msg: str, max_tokens: int) -> list:
+        """将现有prompt进行切割处理，使得新的prompt长度不超过max_tokens"""
+        # 如果用户消息长度超过max_tokens，直接返回
+
+        temp_prompt = [
+            {
+                'role': 'user',
+                'content': msg
+            }
+        ]
+
+        token_count = len(msg)
+        # 倒序遍历prompt
+        for i in range(len(self.prompt) - 1, -1, -1):
+            if token_count >= max_tokens:
+                break
+
+            # 将prompt加到temp_prompt头部
+            temp_prompt.insert(0, self.prompt[i])
+            token_count += len(self.prompt[i]['content'])
+
+        logging.debug('cut_out: {}'.format(str(temp_prompt)))
+
+        return temp_prompt
+
+    # 持久化session
+    def persistence(self):
+        if self.prompt == self.get_default_prompt():
+            return
+
+        db_inst = pkg.utils.context.get_database_manager()
+
+        name_spt = self.name.split('_')
+
+        subject_type = name_spt[0]
+        subject_number = int(name_spt[1])
+
+        db_inst.persistence_session(subject_type, subject_number, self.create_timestamp, self.last_interact_timestamp,
+                                    json.dumps(self.prompt))
+
+    # 重置session
+    def reset(self, explicit: bool = False, expired: bool = False, schedule_new: bool = True, use_prompt: str = None):
+        if self.prompt[-1]['role'] != "system":
+            self.persistence()
+            if explicit:
+                # 触发插件事件
+                args = {
+                    'session_name': self.name,
+                    'session': self
+                }
+
+                # 此事件不支持阻止默认行为
+                _ = pkg.plugin.host.emit(plugin_models.SessionExplicitReset, **args)
+
+                pkg.utils.context.get_database_manager().explicit_close_session(self.name, self.create_timestamp)
+
+            if expired:
+                pkg.utils.context.get_database_manager().set_session_expired(self.name, self.create_timestamp)
+        self.prompt = self.get_default_prompt(use_prompt)
+        self.create_timestamp = int(time.time())
+        self.last_interact_timestamp = int(time.time())
+        self.just_switched_to_exist_session = False
+
+        # self.response_lock = threading.Lock()
+
+        if schedule_new:
+            self.schedule()
+
+    # 将本session的数据库状态设置为on_going
+    def set_ongoing(self):
+        pkg.utils.context.get_database_manager().set_session_ongoing(self.name, self.create_timestamp)
+
+    # 切换到上一个session
+    def last_session(self):
+        last_one = pkg.utils.context.get_database_manager().last_session(self.name, self.last_interact_timestamp)
+        if last_one is None:
+            return None
+        else:
+            self.persistence()
+
+            self.create_timestamp = last_one['create_timestamp']
+            self.last_interact_timestamp = last_one['last_interact_timestamp']
+            try:
+                self.prompt = json.loads(last_one['prompt'])
+            except json.decoder.JSONDecodeError:
+                self.prompt = reset_session_prompt(self.name, last_one['prompt'])
+                self.persistence()
+
+            self.just_switched_to_exist_session = True
+            return self
+
+    # 切换到下一个session
+    def next_session(self):
+        next_one = pkg.utils.context.get_database_manager().next_session(self.name, self.last_interact_timestamp)
+        if next_one is None:
+            return None
+        else:
+            self.persistence()
+
+            self.create_timestamp = next_one['create_timestamp']
+            self.last_interact_timestamp = next_one['last_interact_timestamp']
+            try:
+                self.prompt = json.loads(next_one['prompt'])
+            except json.decoder.JSONDecodeError:
+                self.prompt = reset_session_prompt(self.name, next_one['prompt'])
+                self.persistence()
+
+            self.just_switched_to_exist_session = True
+            return self
+
+    def list_history(self, capacity: int = 10, page: int = 0):
+        return pkg.utils.context.get_database_manager().list_history(self.name, capacity, page)
+
+    def draw_image(self, prompt: str):
+        return pkg.utils.context.get_openai_manager().request_image(prompt)