feat: add qianfan chat bot

models/bot_factory.py

@@ -21,6 +21,10 @@ def create_bot(bot_type):
         from models.deepseek.deepseek_bot import DeepSeekBot
         return DeepSeekBot()
 
+    elif bot_type == const.QIANFAN:
+        from models.qianfan.qianfan_bot import QianfanBot
+        return QianfanBot()
+
     elif bot_type in (const.OPENAI, const.CHATGPT, const.CUSTOM):  # OpenAI-compatible API
         from models.chatgpt.chat_gpt_bot import ChatGPTBot
         return ChatGPTBot()

models/qianfan/__init__.py

@@ -0,0 +1 @@
+# encoding:utf-8

models/qianfan/qianfan_bot.py

@@ -0,0 +1,157 @@
+# encoding:utf-8
+
+import time
+
+import requests
+from bridge.context import ContextType
+from bridge.reply import Reply, ReplyType
+from common import const
+from common.log import logger
+from config import conf, load_config
+from models.bot import Bot
+from models.openai_compatible_bot import OpenAICompatibleBot
+from models.session_manager import SessionManager
+from .qianfan_session import QianfanSession
+
+DEFAULT_API_BASE = "https://qianfan.baidubce.com/v2"
+DEFAULT_MODEL = const.ERNIE_45_TURBO_128K
+
+
+class QianfanBot(Bot, OpenAICompatibleBot):
+    def __init__(self):
+        super().__init__()
+        model = self._resolve_model()
+        self.sessions = SessionManager(QianfanSession, model=model)
+        self.args = {
+            "model": model,
+            "temperature": conf().get("temperature", 0.7),
+            "top_p": conf().get("top_p", 1.0),
+            "frequency_penalty": conf().get("frequency_penalty", 0.0),
+            "presence_penalty": conf().get("presence_penalty", 0.0),
+        }
+
+    def _resolve_model(self):
+        model = conf().get("model") or DEFAULT_MODEL
+        if model == const.QIANFAN:
+            return DEFAULT_MODEL
+        return model
+
+    @property
+    def api_key(self):
+        return conf().get("qianfan_api_key")
+
+    @property
+    def api_base(self):
+        url = conf().get("qianfan_api_base") or DEFAULT_API_BASE
+        url = url.rstrip("/")
+        suffix = "/chat/completions"
+        if url.endswith(suffix):
+            url = url[:-len(suffix)]
+        return url.rstrip("/")
+
+    def get_api_config(self):
+        return {
+            "api_key": self.api_key,
+            "api_base": self.api_base,
+            "model": self._resolve_model(),
+            "default_temperature": conf().get("temperature", 0.7),
+            "default_top_p": conf().get("top_p", 1.0),
+            "default_frequency_penalty": conf().get("frequency_penalty", 0.0),
+            "default_presence_penalty": conf().get("presence_penalty", 0.0),
+        }
+
+    def _build_headers(self):
+        return {
+            "Content-Type": "application/json",
+            "Authorization": "Bearer {}".format(self.api_key),
+        }
+
+    def reply(self, query, context=None):
+        if context.type == ContextType.TEXT:
+            logger.info("[QIANFAN] query={}".format(query))
+
+            session_id = context["session_id"]
+            reply = None
+            clear_memory_commands = conf().get("clear_memory_commands", ["#清除记忆"])
+            if query in clear_memory_commands:
+                self.sessions.clear_session(session_id)
+                reply = Reply(ReplyType.INFO, "记忆已清除")
+            elif query == "#清除所有":
+                self.sessions.clear_all_session()
+                reply = Reply(ReplyType.INFO, "所有人记忆已清除")
+            elif query == "#更新配置":
+                load_config()
+                reply = Reply(ReplyType.INFO, "配置已更新")
+            if reply:
+                return reply
+
+            session = self.sessions.session_query(query, session_id)
+            logger.debug("[QIANFAN] session query={}".format(session.messages))
+
+            reply_content = self.reply_text(session, args=self.args.copy())
+            logger.debug(
+                "[QIANFAN] new_query={}, session_id={}, reply_cont={}, completion_tokens={}".format(
+                    session.messages,
+                    session_id,
+                    reply_content["content"],
+                    reply_content["completion_tokens"],
+                )
+            )
+            if reply_content["completion_tokens"] == 0 and len(reply_content["content"]) > 0:
+                reply = Reply(ReplyType.ERROR, reply_content["content"])
+            elif reply_content["completion_tokens"] > 0:
+                self.sessions.session_reply(
+                    reply_content["content"], session_id, reply_content["total_tokens"],
+                )
+                reply = Reply(ReplyType.TEXT, reply_content["content"])
+            else:
+                reply = Reply(ReplyType.ERROR, reply_content["content"])
+                logger.debug("[QIANFAN] reply {} used 0 tokens.".format(reply_content))
+            return reply
+        else:
+            reply = Reply(ReplyType.ERROR, "Bot不支持处理{}类型的消息".format(context.type))
+            return reply
+
+    def reply_text(self, session, args=None, retry_count=0):
+        try:
+            body = dict(args) if args else dict(self.args)
+            body["messages"] = session.messages
+            response = requests.post(
+                "{}/chat/completions".format(self.api_base),
+                headers=self._build_headers(),
+                json=body,
+                timeout=conf().get("request_timeout", 180),
+            )
+            if response.status_code == 200:
+                data = response.json()
+                return {
+                    "total_tokens": data["usage"]["total_tokens"],
+                    "completion_tokens": data["usage"]["completion_tokens"],
+                    "content": data["choices"][0]["message"]["content"],
+                }
+
+            error = response.json().get("error", {})
+            logger.error(
+                "[QIANFAN] chat failed, status_code={}, msg={}".format(
+                    response.status_code, error.get("message")
+                )
+            )
+            result = {"completion_tokens": 0, "content": "提问太快啦，请休息一下再问我吧"}
+            need_retry = False
+            if response.status_code >= 500:
+                need_retry = retry_count < 2
+            elif response.status_code == 401:
+                result["content"] = "授权失败，请检查 Qianfan API Key 是否正确"
+            elif response.status_code == 429:
+                result["content"] = "请求过于频繁，请稍后再试"
+                need_retry = retry_count < 2
+
+            if need_retry:
+                time.sleep(3)
+                return self.reply_text(session, args, retry_count + 1)
+            return result
+        except Exception as e:
+            logger.exception(e)
+            if retry_count < 2:
+                return self.reply_text(session, args, retry_count + 1)
+            return {"completion_tokens": 0, "content": "我现在有点累了，等会再来吧"}

models/qianfan/qianfan_session.py

@@ -0,0 +1,57 @@
+from models.session_manager import Session
+from common.log import logger
+
+
+class QianfanSession(Session):
+    def __init__(self, session_id, system_prompt=None, model="ernie-4.5-turbo-128k"):
+        super().__init__(session_id, system_prompt)
+        self.model = model
+        self.reset()
+
+    def discard_exceeding(self, max_tokens, cur_tokens=None):
+        precise = True
+        try:
+            cur_tokens = self.calc_tokens()
+        except Exception as e:
+            precise = False
+            if cur_tokens is None:
+                raise e
+            logger.debug("Exception when counting tokens precisely for query: {}".format(e))
+        while cur_tokens > max_tokens:
+            if len(self.messages) > 2:
+                self.messages.pop(1)
+            elif len(self.messages) == 2 and self.messages[1]["role"] == "assistant":
+                self.messages.pop(1)
+                if precise:
+                    cur_tokens = self.calc_tokens()
+                else:
+                    cur_tokens = cur_tokens - max_tokens
+                break
+            elif len(self.messages) == 2 and self.messages[1]["role"] == "user":
+                logger.warn("user message exceed max_tokens. total_tokens={}".format(cur_tokens))
+                break
+            else:
+                logger.debug("max_tokens={}, total_tokens={}, len(messages)={}".format(
+                    max_tokens, cur_tokens, len(self.messages)))
+                break
+            if precise:
+                cur_tokens = self.calc_tokens()
+            else:
+                cur_tokens = cur_tokens - max_tokens
+        return cur_tokens
+
+    def calc_tokens(self):
+        return num_tokens_from_messages(self.messages, self.model)
+
+
+def num_tokens_from_messages(messages, model):
+    tokens = 0
+    for msg in messages:
+        content = msg.get("content", "")
+        if isinstance(content, str):
+            tokens += len(content)
+        elif isinstance(content, list):
+            for block in content:
+                if isinstance(block, dict):
+                    tokens += len(block.get("text", ""))
+    return tokens