Merge pull request #1389 from scut-chenzk/chenzk

修复自己艾特自己会死循环的问题

.github/workflows/deploy-image-arm.yml

@@ -0,0 +1,71 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+# GitHub recommends pinning actions to a commit SHA.
+# To get a newer version, you will need to update the SHA.
+# You can also reference a tag or branch, but the action may change without warning.
+
+name: Create and publish a Docker image
+
+on:
+  push:
+    branches: ['master']
+  create:
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v1
+
+      - name: Available platforms
+        run: echo ${{ steps.buildx.outputs.platforms }}
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v2
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          push: true
+          file: ./docker/Dockerfile.latest
+          platforms: linux/arm64
+          tags: ${{ steps.meta.outputs.tags }}-arm64
+          labels: ${{ steps.meta.outputs.labels }}
+
+      - uses: actions/delete-package-versions@v4
+        with:
+          package-name: 'chatgpt-on-wechat'
+          package-type: 'container'
+          min-versions-to-keep: 10
+          delete-only-untagged-versions: 'true'
+          token: ${{ secrets.GITHUB_TOKEN }}

README.md

@@ -5,7 +5,7 @@
 最新版本支持的功能如下：
 
 - [x] **多端部署：** 有多种部署方式可选择且功能完备，目前已支持个人微信，微信公众号和企业微信应用等部署方式
-- [x] **基础对话：** 私聊及群聊的消息智能回复，支持多轮会话上下文记忆，支持 GPT-3, GPT-3.5, GPT-4, 文心一言模型
+- [x] **基础对话：** 私聊及群聊的消息智能回复，支持多轮会话上下文记忆，支持 GPT-3, GPT-3.5, GPT-4, claude, 文心一言, 讯飞星火
 - [x] **语音识别：** 可识别语音消息，通过文字或语音回复，支持 azure, baidu, google, openai等多种语音模型
 - [x] **图片生成：** 支持图片生成 和 图生图（如照片修复），可选择 Dell-E, stable diffusion, replicate, midjourney模型
 - [x] **丰富插件：** 支持个性化插件扩展，已实现多角色切换、文字冒险、敏感词过滤、聊天记录总结等插件
@@ -27,6 +27,7 @@ Demo made by [Visionn](https://www.wangpc.cc/)
 <img width="240" src="./docs/images/contact.jpg">
 
 # 更新日志
+>**2023.09.01：** 接入讯飞星火，claude机器人
 
 >**2023.08.08：** 接入百度文心一言模型，通过 [插件](https://github.com/zhayujie/chatgpt-on-wechat/tree/master/plugins/linkai) 支持 Midjourney 绘图
 
@@ -113,7 +114,7 @@ pip3 install azure-cognitiveservices-speech
 # config.json文件内容示例
 {
   "open_ai_api_key": "YOUR API KEY",                          # 填入上面创建的 OpenAI API KEY
-  "model": "gpt-3.5-turbo",                                   # 模型名称。当use_azure_chatgpt为true时，其名称为Azure上model deployment名称
+  "model": "gpt-3.5-turbo",                                   # 模型名称, 支持 gpt-3.5-turbo, gpt-3.5-turbo-16k, gpt-4, wenxin, xunfei
   "proxy": "",                                                # 代理客户端的ip和端口，国内环境开启代理的需要填写该项，如 "127.0.0.1:7890"
   "single_chat_prefix": ["bot", "@bot"],                      # 私聊时文本需要包含该前缀才能触发机器人回复
   "single_chat_reply_prefix": "[bot] ",                       # 私聊时自动回复的前缀，用于区分真人
@@ -129,7 +130,10 @@ pip3 install azure-cognitiveservices-speech
   "azure_api_version": "",                                    # 采用Azure ChatGPT时，API版本
   "character_desc": "你是ChatGPT, 一个由OpenAI训练的大型语言模型, 你旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。",  # 人格描述
   # 订阅消息，公众号和企业微信channel中请填写，当被订阅时会自动回复，可使用特殊占位符。目前支持的占位符有{trigger_prefix}，在程序中它会自动替换成bot的触发词。
-  "subscribe_msg": "感谢您的关注！\n这里是ChatGPT，可以自由对话。\n支持语音对话。\n支持图片输出，画字开头的消息将按要求创作图片。\n支持角色扮演和文字冒险等丰富插件。\n输入{trigger_prefix}#help 查看详细指令。"
+  "subscribe_msg": "感谢您的关注！\n这里是ChatGPT，可以自由对话。\n支持语音对话。\n支持图片输出，画字开头的消息将按要求创作图片。\n支持角色扮演和文字冒险等丰富插件。\n输入{trigger_prefix}#help 查看详细指令。",
+  "use_linkai": false,                                        # 是否使用LinkAI接口，默认关闭，开启后可国内访问，使用知识库和MJ
+  "linkai_api_key": "",                                       # LinkAI Api Key
+  "linkai_app_code": ""                                       # LinkAI 应用code
 }
 ```
 **配置说明：**
@@ -154,7 +158,7 @@ pip3 install azure-cognitiveservices-speech
 
 **4.其他配置**
 
-+ `model`: 模型名称，目前支持 `gpt-3.5-turbo`, `text-davinci-003`, `gpt-4`, `gpt-4-32k`, `wenxin`  (其中gpt-4 api暂未完全开放，申请通过后可使用)
++ `model`: 模型名称，目前支持 `gpt-3.5-turbo`, `text-davinci-003`, `gpt-4`, `gpt-4-32k`, `wenxin` , `claude` ,  `xunfei`(其中gpt-4 api暂未完全开放，申请通过后可使用)
 + `temperature`,`frequency_penalty`,`presence_penalty`: Chat API接口参数，详情参考[OpenAI官方文档。](https://platform.openai.com/docs/api-reference/chat)
 + `proxy`：由于目前 `openai` 接口国内无法访问，需配置代理客户端的地址，详情参考  [#351](https://github.com/zhayujie/chatgpt-on-wechat/issues/351)
 + 对于图像生成，在满足个人或群组触发条件外，还需要额外的关键词前缀来触发，对应配置 `image_create_prefix `
@@ -166,6 +170,32 @@ pip3 install azure-cognitiveservices-speech
 + `character_desc` 配置中保存着你对机器人说的一段话，他会记住这段话并作为他的设定，你可以为他定制任何人格      (关于会话上下文的更多内容参考该 [issue](https://github.com/zhayujie/chatgpt-on-wechat/issues/43))
 + `subscribe_msg`：订阅消息，公众号和企业微信channel中请填写，当被订阅时会自动回复， 可使用特殊占位符。目前支持的占位符有{trigger_prefix}，在程序中它会自动替换成bot的触发词。
 
+**5.LinkAI配置 (可选)**
+
++ `use_linkai`: 是否使用LinkAI接口，开启后可国内访问，使用知识库和 `Midjourney` 绘画, 参考 [文档](https://link-ai.tech/platform/link-app/wechat)
++ `linkai_api_key`: LinkAI Api Key，可在 [控制台](https://chat.link-ai.tech/console/interface) 创建
++ `linkai_app_code`: LinkAI 应用code，选填
+
+**6.wenxin配置 (可选 model 为 wenxin 时生效)**
+
++ `baidu_wenxin_api_key`: 文心一言官网api key。
++ `baidu_wenxin_secret_key`: 文心一言官网secret key。
+
+
+**6.Claude配置 (可选 model 为 claude 时生效)**
+
++ `claude_api_cookie`: claude官网聊天界面复制完整 cookie 字符串。
++ `claude_uuid`: 可以指定对话id，默认新建对话实体。
+
+
+**7.xunfei配置 (可选 model 为 xunfei 时生效)**
+
++ `xunfei_app_id`: 讯飞星火app id。
++ `xunfei_api_key`: 讯飞星火 api key。
++ `xunfei_api_secret`: 讯飞星火 secret。
+
+
+
 **本说明文档可能会未及时更新，当前所有可选的配置项均在该[`config.py`](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/config.py)中列出。**
 
 ## 运行

app.py

@@ -43,7 +43,7 @@ def run():
             # os.environ['WECHATY_PUPPET_SERVICE_ENDPOINT'] = '127.0.0.1:9001'
 
         channel = channel_factory.create_channel(channel_name)
-        if channel_name in ["wx", "wxy", "terminal", "wechatmp", "wechatmp_service", "wechatcom_app"]:
+        if channel_name in ["wx", "wxy", "terminal", "wechatmp", "wechatmp_service", "wechatcom_app", "wework"]:
             PluginManager().load_plugins()
 
         # startup channel

bot/baidu/baidu_wenxin.py

@@ -2,7 +2,6 @@
 
 import requests, json
 from bot.bot import Bot
-from bridge.reply import Reply, ReplyType
 from bot.session_manager import SessionManager
 from bridge.context import ContextType
 from bridge.reply import Reply, ReplyType
@@ -77,6 +76,7 @@ class BaiduWenxinBot(Bot):
             payload = {'messages': session.messages}
             response = requests.request("POST", url, headers=headers, data=json.dumps(payload))
             response_text = json.loads(response.text)
+            logger.info(f"[BAIDU] response text={response_text}")
             res_content = response_text["result"]
             total_tokens = response_text["usage"]["total_tokens"]
             completion_tokens = response_text["usage"]["completion_tokens"]

bot/baidu/baidu_wenxin_session.py

@@ -9,6 +9,7 @@ from common.log import logger
     ]
 """
 
+
 class BaiduWenxinSession(Session):
     def __init__(self, session_id, system_prompt=None, model="gpt-3.5-turbo"):
         super().__init__(session_id, system_prompt)
@@ -17,7 +18,6 @@ class BaiduWenxinSession(Session):
         # self.reset()
 
     def discard_exceeding(self, max_tokens, cur_tokens=None):
-        # pdb.set_trace()
         precise = True
         try:
             cur_tokens = self.calc_tokens()
@@ -27,18 +27,9 @@ class BaiduWenxinSession(Session):
                 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
+            if len(self.messages) >= 2:
+                self.messages.pop(0)
+                self.messages.pop(0)
             else:
                 logger.debug("max_tokens={}, total_tokens={}, len(messages)={}".format(max_tokens, cur_tokens, len(self.messages)))
                 break
@@ -52,36 +43,11 @@ class BaiduWenxinSession(Session):
         return num_tokens_from_messages(self.messages, self.model)
 
 
-# refer to https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
 def num_tokens_from_messages(messages, model):
     """Returns the number of tokens used by a list of messages."""
-    import tiktoken
-
-    if model in ["gpt-3.5-turbo-0301", "gpt-35-turbo"]:
-        return num_tokens_from_messages(messages, model="gpt-3.5-turbo")
-    elif model in ["gpt-4-0314", "gpt-4-0613", "gpt-4-32k", "gpt-4-32k-0613", "gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k", "gpt-3.5-turbo-16k-0613", "gpt-35-turbo-16k"]:
-        return num_tokens_from_messages(messages, model="gpt-4")
-
-    try:
-        encoding = tiktoken.encoding_for_model(model)
-    except KeyError:
-        logger.debug("Warning: model not found. Using cl100k_base encoding.")
-        encoding = tiktoken.get_encoding("cl100k_base")
-    if model == "gpt-3.5-turbo":
-        tokens_per_message = 4  # every message follows <|start|>{role/name}\n{content}<|end|>\n
-        tokens_per_name = -1  # if there's a name, the role is omitted
-    elif model == "gpt-4":
-        tokens_per_message = 3
-        tokens_per_name = 1
-    else:
-        logger.warn(f"num_tokens_from_messages() is not implemented for model {model}. Returning num tokens assuming gpt-3.5-turbo.")
-        return num_tokens_from_messages(messages, model="gpt-3.5-turbo")
-    num_tokens = 0
-    for message in messages:
-        num_tokens += tokens_per_message
-        for key, value in message.items():
-            num_tokens += len(encoding.encode(value))
-            if key == "name":
-                num_tokens += tokens_per_name
-    num_tokens += 3  # every reply is primed with <|start|>assistant<|message|>
-    return num_tokens
+    tokens = 0
+    for msg in messages:
+        # 官方token计算规则暂不明确： "大约为 token数为 "中文字 + 其他语种单词数 x 1.3"
+        # 这里先直接根据字数粗略估算吧，暂不影响正常使用，仅在判断是否丢弃历史会话的时候会有偏差
+        tokens += len(msg["content"])
+    return tokens

bot/bot_factory.py

@@ -14,31 +14,33 @@ def create_bot(bot_type):
         # 替换Baidu Unit为Baidu文心千帆对话接口
         # from bot.baidu.baidu_unit_bot import BaiduUnitBot
         # return BaiduUnitBot()
-
         from bot.baidu.baidu_wenxin import BaiduWenxinBot
-
         return BaiduWenxinBot()
 
     elif bot_type == const.CHATGPT:
         # ChatGPT 网页端web接口
         from bot.chatgpt.chat_gpt_bot import ChatGPTBot
-
         return ChatGPTBot()
 
     elif bot_type == const.OPEN_AI:
         # OpenAI 官方对话模型API
         from bot.openai.open_ai_bot import OpenAIBot
-
         return OpenAIBot()
 
     elif bot_type == const.CHATGPTONAZURE:
         # Azure chatgpt service https://azure.microsoft.com/en-in/products/cognitive-services/openai-service/
         from bot.chatgpt.chat_gpt_bot import AzureChatGPTBot
-
         return AzureChatGPTBot()
 
+    elif bot_type == const.XUNFEI:
+        from bot.xunfei.xunfei_spark_bot import XunFeiBot
+        return XunFeiBot()
+
     elif bot_type == const.LINKAI:
         from bot.linkai.link_ai_bot import LinkAIBot
         return LinkAIBot()
 
+    elif bot_type == const.CLAUDEAI:
+        from bot.claude.claude_ai_bot import ClaudeAIBot
+        return ClaudeAIBot()
     raise RuntimeError

bot/chatgpt/chat_gpt_session.py

@@ -55,11 +55,16 @@ class ChatGPTSession(Session):
 # refer to https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
 def num_tokens_from_messages(messages, model):
     """Returns the number of tokens used by a list of messages."""
+
+    if model in ["wenxin", "xunfei"]:
+        return num_tokens_by_character(messages)
+
     import tiktoken
 
     if model in ["gpt-3.5-turbo-0301", "gpt-35-turbo"]:
         return num_tokens_from_messages(messages, model="gpt-3.5-turbo")
-    elif model in ["gpt-4-0314", "gpt-4-0613", "gpt-4-32k", "gpt-4-32k-0613", "gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k", "gpt-3.5-turbo-16k-0613", "gpt-35-turbo-16k"]:
+    elif model in ["gpt-4-0314", "gpt-4-0613", "gpt-4-32k", "gpt-4-32k-0613", "gpt-3.5-turbo-0613",
+                   "gpt-3.5-turbo-16k", "gpt-3.5-turbo-16k-0613", "gpt-35-turbo-16k"]:
         return num_tokens_from_messages(messages, model="gpt-4")
 
     try:
@@ -85,3 +90,11 @@ def num_tokens_from_messages(messages, model):
                 num_tokens += tokens_per_name
     num_tokens += 3  # every reply is primed with <|start|>assistant<|message|>
     return num_tokens
+
+
+def num_tokens_by_character(messages):
+    """Returns the number of tokens used by a list of messages."""
+    tokens = 0
+    for msg in messages:
+        tokens += len(msg["content"])
+    return tokens

bot/claude/claude_ai_bot.py

@@ -0,0 +1,218 @@
+import re
+import time
+import json
+import uuid
+from curl_cffi import requests
+from bot.bot import Bot
+from bot.claude.claude_ai_session import ClaudeAiSession
+from bot.openai.open_ai_image import OpenAIImage
+from bot.session_manager import SessionManager
+from bridge.context import Context, ContextType
+from bridge.reply import Reply, ReplyType
+from common.log import logger
+from config import conf
+
+
+class ClaudeAIBot(Bot, OpenAIImage):
+    def __init__(self):
+        super().__init__()
+        self.sessions = SessionManager(ClaudeAiSession, model=conf().get("model") or "gpt-3.5-turbo")
+        self.claude_api_cookie = conf().get("claude_api_cookie")
+        self.proxy = conf().get("proxy")
+        self.con_uuid_dic = {}
+        if self.proxy:
+            self.proxies = {
+            "http": self.proxy,
+            "https": self.proxy
+        }
+        else:
+            self.proxies = None
+        self.org_uuid = self.get_organization_id()
+
+    def generate_uuid(self):
+        random_uuid = uuid.uuid4()
+        random_uuid_str = str(random_uuid)
+        formatted_uuid = f"{random_uuid_str[0:8]}-{random_uuid_str[9:13]}-{random_uuid_str[14:18]}-{random_uuid_str[19:23]}-{random_uuid_str[24:]}"
+        return formatted_uuid
+
+    def get_uuid(self):
+        if conf().get("claude_uuid") != None:
+            self.con_uuid = conf().get("claude_uuid")
+        else:
+            con_uuid = self.generate_uuid()
+            self.create_new_chat(con_uuid)
+
+    def get_organization_id(self):
+        url = "https://claude.ai/api/organizations"
+        headers = {
+            'User-Agent':
+                'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Referer': 'https://claude.ai/chats',
+            'Content-Type': 'application/json',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Connection': 'keep-alive',
+            'Cookie': f'{self.claude_api_cookie}'
+        }
+        response = requests.get(url, headers=headers,impersonate="chrome110",proxies=self.proxies)
+        res = json.loads(response.text)
+        uuid = res[0]['uuid']
+        return uuid
+        
+    def reply(self, query, context: Context = None) -> Reply:
+        if context.type == ContextType.TEXT:
+            return self._chat(query, context)
+        elif context.type == ContextType.IMAGE_CREATE:
+            ok, res = self.create_img(query, 0)
+            if ok:
+                reply = Reply(ReplyType.IMAGE_URL, res)
+            else:
+                reply = Reply(ReplyType.ERROR, res)
+            return reply
+        else:
+            reply = Reply(ReplyType.ERROR, "Bot不支持处理{}类型的消息".format(context.type))
+            return reply
+
+    def get_organization_id(self):
+        url = "https://claude.ai/api/organizations"
+        headers = {
+            'User-Agent':
+                'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Referer': 'https://claude.ai/chats',
+            'Content-Type': 'application/json',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Connection': 'keep-alive',
+            'Cookie': f'{self.claude_api_cookie}'
+        }
+        try:
+            response = requests.get(url, headers=headers,impersonate="chrome110",proxies =self.proxies )
+            res = json.loads(response.text)
+            uuid = res[0]['uuid']
+        except:
+            print(response.text)
+        return uuid
+
+    def conversation_share_check(self,session_id):
+        if session_id not in self.con_uuid_dic:
+            self.con_uuid_dic[session_id] = self.generate_uuid()
+            self.create_new_chat(self.con_uuid_dic[session_id])
+        return self.con_uuid_dic[session_id]
+
+    def create_new_chat(self, con_uuid):
+        url = f"https://claude.ai/api/organizations/{self.org_uuid}/chat_conversations"
+        payload = json.dumps({"uuid": con_uuid, "name": ""})
+        headers = {
+            'User-Agent':
+                'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Referer': 'https://claude.ai/chats',
+            'Content-Type': 'application/json',
+            'Origin': 'https://claude.ai',
+            'DNT': '1',
+            'Connection': 'keep-alive',
+            'Cookie': self.claude_api_cookie,
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'TE': 'trailers'
+        }
+        response = requests.post(url, headers=headers, data=payload,impersonate="chrome110", proxies= self.proxies)
+        # Returns JSON of the newly created conversation information
+        return response.json()
+        
+    def _chat(self, query, context, retry_count=0) -> Reply:
+        """
+        发起对话请求
+        :param query: 请求提示词
+        :param context: 对话上下文
+        :param retry_count: 当前递归重试次数
+        :return: 回复
+        """
+        if retry_count >= 2:
+            # exit from retry 2 times
+            logger.warn("[CLAUDEAI] failed after maximum number of retry times")
+            return Reply(ReplyType.ERROR, "请再问我一次吧")
+
+        try:
+            session_id = context["session_id"]
+            session = self.sessions.session_query(query, session_id)
+            con_uuid = self.conversation_share_check(session_id)
+            model = conf().get("model") or "gpt-3.5-turbo"
+            # remove system message
+            if session.messages[0].get("role") == "system":
+                if model == "wenxin" or model == "claude":
+                    session.messages.pop(0)
+            logger.info(f"[CLAUDEAI] query={query}")
+
+            # do http request
+            base_url = "https://claude.ai"
+            payload = json.dumps({
+                "completion": {
+                    "prompt": f"{query}",
+                    "timezone": "Asia/Kolkata",
+                    "model": "claude-2"
+                },
+                "organization_uuid": f"{self.org_uuid}",
+                "conversation_uuid": f"{con_uuid}",
+                "text": f"{query}",
+                "attachments": []
+            })
+            headers = {
+                'User-Agent':
+                    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/115.0',
+                'Accept': 'text/event-stream, text/event-stream',
+                'Accept-Language': 'en-US,en;q=0.5',
+                'Referer': 'https://claude.ai/chats',
+                'Content-Type': 'application/json',
+                'Origin': 'https://claude.ai',
+                'DNT': '1',
+                'Connection': 'keep-alive',
+                'Cookie': f'{self.claude_api_cookie}',
+                'Sec-Fetch-Dest': 'empty',
+                'Sec-Fetch-Mode': 'cors',
+                'Sec-Fetch-Site': 'same-origin',
+                'TE': 'trailers'
+            }
+
+            res = requests.post(base_url + "/api/append_message", headers=headers, data=payload,impersonate="chrome110",proxies= self.proxies,timeout=400)
+            if res.status_code == 200 or "pemission" in res.text:
+                # execute success
+                decoded_data = res.content.decode("utf-8")
+                decoded_data = re.sub('\n+', '\n', decoded_data).strip()
+                data_strings = decoded_data.split('\n')
+                completions = []
+                for data_string in data_strings:
+                    json_str = data_string[6:].strip()
+                    data = json.loads(json_str)
+                    if 'completion' in data:
+                        completions.append(data['completion'])
+
+                reply_content = ''.join(completions)
+                logger.info(f"[CLAUDE] reply={reply_content}, total_tokens=invisible")
+
+                self.sessions.session_reply(reply_content, session_id, 100)
+                return Reply(ReplyType.TEXT, reply_content)
+            else:
+                response = res.json()
+                error = response.get("error")
+                logger.error(f"[CLAUDE] chat failed, status_code={res.status_code}, "
+                             f"msg={error.get('message')}, type={error.get('type')}, detail: {res.text}, uuid: {con_uuid}")
+
+                if res.status_code >= 500:
+                    # server error, need retry
+                    time.sleep(2)
+                    logger.warn(f"[CLAUDE] do retry, times={retry_count}")
+                    return self._chat(query, context, retry_count + 1)
+                return Reply(ReplyType.ERROR, "提问太快啦，请休息一下再问我吧")
+
+        except Exception as e:
+            logger.exception(e)
+            # retry
+            time.sleep(2)
+            logger.warn(f"[CLAUDE] do retry, times={retry_count}")
+            return self._chat(query, context, retry_count + 1)

bot/claude/claude_ai_session

@@ -0,0 +1,9 @@
+from bot.session_manager import Session
+
+
+class ClaudeAiSession(Session):
+    def __init__(self, session_id, system_prompt=None, model="claude"):
+        super().__init__(session_id, system_prompt)
+        self.model = model
+        # claude逆向不支持role prompt
+        # self.reset()

bot/linkai/link_ai_bot.py

@@ -22,7 +22,6 @@ class LinkAIBot(Bot, OpenAIImage):
 
     def __init__(self):
         super().__init__()
-        self.base_url = "https://api.link-ai.chat/v1"
         self.sessions = SessionManager(ChatGPTSession, model=conf().get("model") or "gpt-3.5-turbo")
 
     def reply(self, query, context: Context = None) -> Reply:
@@ -83,7 +82,8 @@ class LinkAIBot(Bot, OpenAIImage):
             headers = {"Authorization": "Bearer " + linkai_api_key}
 
             # do http request
-            res = requests.post(url=self.base_url + "/chat/completions", json=body, headers=headers,
+            base_url = conf().get("linkai_api_base", "https://api.link-ai.chat")
+            res = requests.post(url=base_url + "/v1/chat/completions", json=body, headers=headers,
                                 timeout=conf().get("request_timeout", 180))
             if res.status_code == 200:
                 # execute success

bot/xunfei/xunfei_spark_bot.py

@@ -0,0 +1,250 @@
+# encoding:utf-8
+
+import requests, json
+from bot.bot import Bot
+from bot.session_manager import SessionManager
+from bot.baidu.baidu_wenxin_session import BaiduWenxinSession
+from bridge.context import ContextType, Context
+from bridge.reply import Reply, ReplyType
+from common.log import logger
+from config import conf
+from common import const
+import time
+import _thread as thread
+import datetime
+from datetime import datetime
+from wsgiref.handlers import format_date_time
+from urllib.parse import urlencode
+import base64
+import ssl
+import hashlib
+import hmac
+import json
+from time import mktime
+from urllib.parse import urlparse
+import websocket
+import queue
+import threading
+import random
+
+# 消息队列 map
+queue_map = dict()
+
+# 响应队列 map
+reply_map = dict()
+
+
+class XunFeiBot(Bot):
+    def __init__(self):
+        super().__init__()
+        self.app_id = conf().get("xunfei_app_id")
+        self.api_key = conf().get("xunfei_api_key")
+        self.api_secret = conf().get("xunfei_api_secret")
+        # 默认使用v2.0版本，1.5版本可设置为 general
+        self.domain = "generalv2"
+        # 默认使用v2.0版本，1.5版本可设置为 "ws://spark-api.xf-yun.com/v1.1/chat"
+        self.spark_url = "ws://spark-api.xf-yun.com/v2.1/chat"
+        self.host = urlparse(self.spark_url).netloc
+        self.path = urlparse(self.spark_url).path
+        # 和wenxin使用相同的session机制
+        self.sessions = SessionManager(BaiduWenxinSession, model=const.XUNFEI)
+
+    def reply(self, query, context: Context = None) -> Reply:
+        if context.type == ContextType.TEXT:
+            logger.info("[XunFei] query={}".format(query))
+            session_id = context["session_id"]
+            request_id = self.gen_request_id(session_id)
+            reply_map[request_id] = ""
+            session = self.sessions.session_query(query, session_id)
+            threading.Thread(target=self.create_web_socket, args=(session.messages, request_id)).start()
+            depth = 0
+            time.sleep(0.1)
+            t1 = time.time()
+            usage = {}
+            while depth <= 300:
+                try:
+                    data_queue = queue_map.get(request_id)
+                    if not data_queue:
+                        depth += 1
+                        time.sleep(0.1)
+                        continue
+                    data_item = data_queue.get(block=True, timeout=0.1)
+                    if data_item.is_end:
+                        # 请求结束
+                        del queue_map[request_id]
+                        if data_item.reply:
+                            reply_map[request_id] += data_item.reply
+                        usage = data_item.usage
+                        break
+
+                    reply_map[request_id] += data_item.reply
+                    depth += 1
+                except Exception as e:
+                    depth += 1
+                    continue
+            t2 = time.time()
+            logger.info(f"[XunFei-API] response={reply_map[request_id]}, time={t2 - t1}s, usage={usage}")
+            self.sessions.session_reply(reply_map[request_id], session_id, usage.get("total_tokens"))
+            reply = Reply(ReplyType.TEXT, reply_map[request_id])
+            del reply_map[request_id]
+            return reply
+        else:
+            reply = Reply(ReplyType.ERROR, "Bot不支持处理{}类型的消息".format(context.type))
+            return reply
+
+    def create_web_socket(self, prompt, session_id, temperature=0.5):
+        logger.info(f"[XunFei] start connect, prompt={prompt}")
+        websocket.enableTrace(False)
+        wsUrl = self.create_url()
+        ws = websocket.WebSocketApp(wsUrl, on_message=on_message, on_error=on_error, on_close=on_close,
+                                    on_open=on_open)
+        data_queue = queue.Queue(1000)
+        queue_map[session_id] = data_queue
+        ws.appid = self.app_id
+        ws.question = prompt
+        ws.domain = self.domain
+        ws.session_id = session_id
+        ws.temperature = temperature
+        ws.run_forever(sslopt={"cert_reqs": ssl.CERT_NONE})
+
+    def gen_request_id(self, session_id: str):
+        return session_id + "_" + str(int(time.time())) + "" + str(random.randint(0, 100))
+
+    # 生成url
+    def create_url(self):
+        # 生成RFC1123格式的时间戳
+        now = datetime.now()
+        date = format_date_time(mktime(now.timetuple()))
+
+        # 拼接字符串
+        signature_origin = "host: " + self.host + "\n"
+        signature_origin += "date: " + date + "\n"
+        signature_origin += "GET " + self.path + " HTTP/1.1"
+
+        # 进行hmac-sha256进行加密
+        signature_sha = hmac.new(self.api_secret.encode('utf-8'), signature_origin.encode('utf-8'),
+                                 digestmod=hashlib.sha256).digest()
+
+        signature_sha_base64 = base64.b64encode(signature_sha).decode(encoding='utf-8')
+
+        authorization_origin = f'api_key="{self.api_key}", algorithm="hmac-sha256", headers="host date request-line", ' \
+                               f'signature="{signature_sha_base64}"'
+
+        authorization = base64.b64encode(authorization_origin.encode('utf-8')).decode(encoding='utf-8')
+
+        # 将请求的鉴权参数组合为字典
+        v = {
+            "authorization": authorization,
+            "date": date,
+            "host": self.host
+        }
+        # 拼接鉴权参数，生成url
+        url = self.spark_url + '?' + urlencode(v)
+        # 此处打印出建立连接时候的url,参考本demo的时候可取消上方打印的注释，比对相同参数时生成的url与自己代码生成的url是否一致
+        return url
+
+    def gen_params(self, appid, domain, question):
+        """
+        通过appid和用户的提问来生成请参数
+        """
+        data = {
+            "header": {
+                "app_id": appid,
+                "uid": "1234"
+            },
+            "parameter": {
+                "chat": {
+                    "domain": domain,
+                    "random_threshold": 0.5,
+                    "max_tokens": 2048,
+                    "auditing": "default"
+                }
+            },
+            "payload": {
+                "message": {
+                    "text": question
+                }
+            }
+        }
+        return data
+
+
+class ReplyItem:
+    def __init__(self, reply, usage=None, is_end=False):
+        self.is_end = is_end
+        self.reply = reply
+        self.usage = usage
+
+
+# 收到websocket错误的处理
+def on_error(ws, error):
+    logger.error(f"[XunFei] error: {str(error)}")
+
+
+# 收到websocket关闭的处理
+def on_close(ws, one, two):
+    data_queue = queue_map.get(ws.session_id)
+    data_queue.put("END")
+
+
+# 收到websocket连接建立的处理
+def on_open(ws):
+    logger.info(f"[XunFei] Start websocket, session_id={ws.session_id}")
+    thread.start_new_thread(run, (ws,))
+
+
+def run(ws, *args):
+    data = json.dumps(gen_params(appid=ws.appid, domain=ws.domain, question=ws.question, temperature=ws.temperature))
+    ws.send(data)
+
+
+# Websocket 操作
+# 收到websocket消息的处理
+def on_message(ws, message):
+    data = json.loads(message)
+    code = data['header']['code']
+    if code != 0:
+        logger.error(f'请求错误: {code}, {data}')
+        ws.close()
+    else:
+        choices = data["payload"]["choices"]
+        status = choices["status"]
+        content = choices["text"][0]["content"]
+        data_queue = queue_map.get(ws.session_id)
+        if not data_queue:
+            logger.error(f"[XunFei] can't find data queue, session_id={ws.session_id}")
+            return
+        reply_item = ReplyItem(content)
+        if status == 2:
+            usage = data["payload"].get("usage")
+            reply_item = ReplyItem(content, usage)
+            reply_item.is_end = True
+            ws.close()
+        data_queue.put(reply_item)
+
+
+def gen_params(appid, domain, question, temperature=0.5):
+    """
+    通过appid和用户的提问来生成请参数
+    """
+    data = {
+        "header": {
+            "app_id": appid,
+            "uid": "1234"
+        },
+        "parameter": {
+            "chat": {
+                "domain": domain,
+                "temperature": temperature,
+                "random_threshold": 0.5,
+                "max_tokens": 2048,
+                "auditing": "default"
+            }
+        },
+        "payload": {
+            "message": {
+                "text": question
+            }
+        }
+    }
+    return data

bridge/bridge.py

@@ -25,8 +25,12 @@ class Bridge(object):
             self.btype["chat"] = const.CHATGPTONAZURE
         if model_type in ["wenxin"]:
             self.btype["chat"] = const.BAIDU
+        if model_type in ["xunfei"]:
+            self.btype["chat"] = const.XUNFEI
         if conf().get("use_linkai") and conf().get("linkai_api_key"):
             self.btype["chat"] = const.LINKAI
+        if model_type in ["claude"]:
+            self.btype["chat"] = const.CLAUDEAI
         self.bots = {}
 
     def get_bot(self, typename):

bridge/context.py

@@ -7,9 +7,13 @@ class ContextType(Enum):
     TEXT = 1  # 文本消息
     VOICE = 2  # 音频消息
     IMAGE = 3  # 图片消息
+    FILE = 4  # 文件信息
+    VIDEO = 5  # 视频信息
+
     IMAGE_CREATE = 10  # 创建图片命令
     JOIN_GROUP = 20  # 加入群聊
     PATPAT = 21  # 拍了拍
+    FUNCTION = 22  # 函数调用
 
     def __str__(self):
         return self.name

bridge/reply.py

@@ -8,9 +8,15 @@ class ReplyType(Enum):
     VOICE = 2  # 音频文件
     IMAGE = 3  # 图片文件
     IMAGE_URL = 4  # 图片URL
-
+    VIDEO_URL = 5  # 视频URL
+    FILE = 6  # 文件
+    CARD = 7  # 微信名片，仅支持ntchat
+    InviteRoom = 8  # 邀请好友进群
     INFO = 9
     ERROR = 10
+    TEXT_ = 11  # 强制文本
+    VIDEO = 12
+    MINIAPP = 13  # 小程序
 
     def __str__(self):
         return self.name

channel/channel_factory.py

@@ -33,4 +33,8 @@ def create_channel(channel_type):
         from channel.wechatcom.wechatcomapp_channel import WechatComAppChannel
 
         return WechatComAppChannel()
+    elif channel_type == "wework":
+        from channel.wework.wework_channel import WeworkChannel
+
+        return WeworkChannel()
     raise RuntimeError

channel/chat_channel.py

@@ -103,12 +103,16 @@ class ChatChannel(Channel):
                     flag = True
                     if match_prefix:
                         content = content.replace(match_prefix, "", 1).strip()
-                if context["msg"].is_at:
+                if context["msg"].is_at and context["msg"].to_user_id != context["msg"].actual_user_id:
                     logger.info("[WX]receive group at")
                     if not conf().get("group_at_off", False):
                         flag = True
                     pattern = f"@{re.escape(self.name)}(\u2005|\u0020)"
                     subtract_res = re.sub(pattern, r"", content)
+                    if isinstance(context["msg"].at_list, list):
+                        for at in context["msg"].at_list:
+                            pattern = f"@{re.escape(at)}(\u2005|\u0020)"
+                            subtract_res = re.sub(pattern, r"", subtract_res)
                     if subtract_res == content and context["msg"].self_display_name:
                         # 前缀移除后没有变化，使用群昵称再次移除
                         pattern = f"@{re.escape(context['msg'].self_display_name)}(\u2005|\u0020)"
@@ -197,7 +201,8 @@ class ChatChannel(Channel):
                         reply = self._generate_reply(new_context)
                     else:
                         return
-            elif context.type == ContextType.IMAGE:  # 图片消息，当前无默认逻辑
+            elif context.type == ContextType.IMAGE or context.type == ContextType.FUNCTION \
+                    or context.type == ContextType.FILE:  # 图片/文件消息及函数调用等，当前无默认逻辑
                 pass
             else:
                 logger.error("[WX] unknown context type: {}".format(context.type))

channel/chat_message.py

@@ -53,6 +53,7 @@ class ChatMessage(object):
     is_at = False
     actual_user_id = None
     actual_user_nickname = None
+    at_list = None
 
     _prepare_fn = None
     _prepared = False
@@ -67,7 +68,7 @@ class ChatMessage(object):
             self._prepare_fn()
 
     def __str__(self):
-        return "ChatMessage: id={}, create_time={}, ctype={}, content={}, from_user_id={}, from_user_nickname={}, to_user_id={}, to_user_nickname={}, other_user_id={}, other_user_nickname={}, is_group={}, is_at={}, actual_user_id={}, actual_user_nickname={}".format(
+        return "ChatMessage: id={}, create_time={}, ctype={}, content={}, from_user_id={}, from_user_nickname={}, to_user_id={}, to_user_nickname={}, other_user_id={}, other_user_nickname={}, is_group={}, is_at={}, actual_user_id={}, actual_user_nickname={}, at_list={}".format(
             self.msg_id,
             self.create_time,
             self.ctype,
@@ -82,4 +83,5 @@ class ChatMessage(object):
             self.is_at,
             self.actual_user_id,
             self.actual_user_nickname,
+            self.at_list
         )

channel/wechat/wechat_channel.py

@@ -192,10 +192,14 @@ class WechatChannel(ChatChannel):
             logger.info("[WX] sendFile={}, receiver={}".format(reply.content, receiver))
         elif reply.type == ReplyType.IMAGE_URL:  # 从网络下载图片
             img_url = reply.content
+            logger.debug(f"[WX] start download image, img_url={img_url}")
             pic_res = requests.get(img_url, stream=True)
             image_storage = io.BytesIO()
+            size = 0
             for block in pic_res.iter_content(1024):
+                size += len(block)
                 image_storage.write(block)
+            logger.info(f"[WX] download image success, size={size}, img_url={img_url}")
             image_storage.seek(0)
             itchat.send_image(image_storage, toUserName=receiver)
             logger.info("[WX] sendImage url={}, receiver={}".format(img_url, receiver))

channel/wework/run.py

@@ -0,0 +1,17 @@
+import os
+import time
+os.environ['ntwork_LOG'] = "ERROR"
+import ntwork
+
+wework = ntwork.WeWork()
+
+
+def forever():
+    try:
+        while True:
+            time.sleep(0.1)
+    except KeyboardInterrupt:
+        ntwork.exit_()
+        os._exit(0)
+
+

channel/wework/wework_channel.py

@@ -0,0 +1,306 @@
+import io
+import os
+import random
+import tempfile
+import threading
+os.environ['ntwork_LOG'] = "ERROR"
+import ntwork
+import requests
+import uuid
+
+from bridge.context import *
+from bridge.reply import *
+from channel.chat_channel import ChatChannel
+from channel.wework.wework_message import *
+from channel.wework.wework_message import WeworkMessage
+from common.singleton import singleton
+from common.log import logger
+from common.time_check import time_checker
+from config import conf
+from channel.wework.run import wework
+from channel.wework import run
+from PIL import Image
+
+
+def get_wxid_by_name(room_members, group_wxid, name):
+    if group_wxid in room_members:
+        for member in room_members[group_wxid]['member_list']:
+            if member['room_nickname'] == name or member['username'] == name:
+                return member['user_id']
+    return None  # 如果没有找到对应的group_wxid或name，则返回None
+
+
+def download_and_compress_image(url, filename, quality=30):
+    # 确定保存图片的目录
+    directory = os.path.join(os.getcwd(), "tmp")
+    # 如果目录不存在，则创建目录
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+    # 下载图片
+    response = requests.get(url)
+    image = Image.open(io.BytesIO(response.content))
+
+    # 压缩图片
+    image_path = os.path.join(directory, f"{filename}.jpg")
+    image.save(image_path, "JPEG", quality=quality)
+
+    return image_path
+
+
+def download_video(url, filename):
+    # 确定保存视频的目录
+    directory = os.path.join(os.getcwd(), "tmp")
+    # 如果目录不存在，则创建目录
+    if not os.path.exists(directory):
+        os.makedirs(directory)
+
+    # 下载视频
+    response = requests.get(url, stream=True)
+    total_size = 0
+
+    video_path = os.path.join(directory, f"{filename}.mp4")
+
+    with open(video_path, 'wb') as f:
+        for block in response.iter_content(1024):
+            total_size += len(block)
+
+            # 如果视频的总大小超过30MB (30 * 1024 * 1024 bytes)，则停止下载并返回
+            if total_size > 30 * 1024 * 1024:
+                logger.info("[WX] Video is larger than 30MB, skipping...")
+                return None
+
+            f.write(block)
+
+    return video_path
+
+
+def create_message(wework_instance, message, is_group):
+    logger.debug(f"正在为{'群聊' if is_group else '单聊'}创建 WeworkMessage")
+    cmsg = WeworkMessage(message, wework=wework_instance, is_group=is_group)
+    logger.debug(f"cmsg:{cmsg}")
+    return cmsg
+
+
+def handle_message(cmsg, is_group):
+    logger.debug(f"准备用 WeworkChannel 处理{'群聊' if is_group else '单聊'}消息")
+    if is_group:
+        WeworkChannel().handle_group(cmsg)
+    else:
+        WeworkChannel().handle_single(cmsg)
+    logger.debug(f"已用 WeworkChannel 处理完{'群聊' if is_group else '单聊'}消息")
+
+
+def _check(func):
+    def wrapper(self, cmsg: ChatMessage):
+        msgId = cmsg.msg_id
+        create_time = cmsg.create_time  # 消息时间戳
+        if create_time is None:
+            return func(self, cmsg)
+        if int(create_time) < int(time.time()) - 60:  # 跳过1分钟前的历史消息
+            logger.debug("[WX]history message {} skipped".format(msgId))
+            return
+        return func(self, cmsg)
+
+    return wrapper
+
+
+@wework.msg_register(
+    [ntwork.MT_RECV_TEXT_MSG, ntwork.MT_RECV_IMAGE_MSG, 11072, ntwork.MT_RECV_VOICE_MSG])
+def all_msg_handler(wework_instance: ntwork.WeWork, message):
+    logger.debug(f"收到消息: {message}")
+    if 'data' in message:
+        # 首先查找conversation_id，如果没有找到，则查找room_conversation_id
+        conversation_id = message['data'].get('conversation_id', message['data'].get('room_conversation_id'))
+        if conversation_id is not None:
+            is_group = "R:" in conversation_id
+            try:
+                cmsg = create_message(wework_instance=wework_instance, message=message, is_group=is_group)
+            except NotImplementedError as e:
+                logger.error(f"[WX]{message.get('MsgId', 'unknown')} 跳过: {e}")
+                return None
+            delay = random.randint(1, 2)
+            timer = threading.Timer(delay, handle_message, args=(cmsg, is_group))
+            timer.start()
+        else:
+            logger.debug("消息数据中无 conversation_id")
+            return None
+    return None
+
+
+def accept_friend_with_retries(wework_instance, user_id, corp_id):
+    result = wework_instance.accept_friend(user_id, corp_id)
+    logger.debug(f'result:{result}')
+
+
+# @wework.msg_register(ntwork.MT_RECV_FRIEND_MSG)
+# def friend(wework_instance: ntwork.WeWork, message):
+#     data = message["data"]
+#     user_id = data["user_id"]
+#     corp_id = data["corp_id"]
+#     logger.info(f"接收到好友请求，消息内容：{data}")
+#     delay = random.randint(1, 180)
+#     threading.Timer(delay, accept_friend_with_retries, args=(wework_instance, user_id, corp_id)).start()
+#
+#     return None
+
+
+def get_with_retry(get_func, max_retries=5, delay=5):
+    retries = 0
+    result = None
+    while retries < max_retries:
+        result = get_func()
+        if result:
+            break
+        logger.warning(f"获取数据失败，重试第{retries + 1}次······")
+        retries += 1
+        time.sleep(delay)  # 等待一段时间后重试
+    return result
+
+
+@singleton
+class WeworkChannel(ChatChannel):
+    NOT_SUPPORT_REPLYTYPE = []
+
+    def __init__(self):
+        super().__init__()
+
+    def startup(self):
+        smart = conf().get("wework_smart", True)
+        wework.open(smart)
+        logger.info("等待登录······")
+        wework.wait_login()
+        login_info = wework.get_login_info()
+        self.user_id = login_info['user_id']
+        self.name = login_info['nickname']
+        logger.info(f"登录信息:>>>user_id:{self.user_id}>>>>>>>>name:{self.name}")
+        logger.info("静默延迟60s，等待客户端刷新数据，请勿进行任何操作······")
+        time.sleep(60)
+        contacts = get_with_retry(wework.get_external_contacts)
+        rooms = get_with_retry(wework.get_rooms)
+        directory = os.path.join(os.getcwd(), "tmp")
+        if not contacts or not rooms:
+            logger.error("获取contacts或rooms失败，程序退出")
+            ntwork.exit_()
+            os.exit(0)
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+        # 将contacts保存到json文件中
+        with open(os.path.join(directory, 'wework_contacts.json'), 'w', encoding='utf-8') as f:
+            json.dump(contacts, f, ensure_ascii=False, indent=4)
+        with open(os.path.join(directory, 'wework_rooms.json'), 'w', encoding='utf-8') as f:
+            json.dump(rooms, f, ensure_ascii=False, indent=4)
+        # 创建一个空字典来保存结果
+        result = {}
+
+        # 遍历列表中的每个字典
+        for room in rooms['room_list']:
+            # 获取聊天室ID
+            room_wxid = room['conversation_id']
+
+            # 获取聊天室成员
+            room_members = wework.get_room_members(room_wxid)
+
+            # 将聊天室成员保存到结果字典中
+            result[room_wxid] = room_members
+
+        # 将结果保存到json文件中
+        with open(os.path.join(directory, 'wework_room_members.json'), 'w', encoding='utf-8') as f:
+            json.dump(result, f, ensure_ascii=False, indent=4)
+        logger.info("wework程序初始化完成········")
+        run.forever()
+
+    @time_checker
+    @_check
+    def handle_single(self, cmsg: ChatMessage):
+        if cmsg.ctype == ContextType.VOICE:
+            if not conf().get("speech_recognition"):
+                return
+            logger.debug("[WX]receive voice msg: {}".format(cmsg.content))
+        elif cmsg.ctype == ContextType.IMAGE:
+            logger.debug("[WX]receive image msg: {}".format(cmsg.content))
+        elif cmsg.ctype == ContextType.PATPAT:
+            logger.debug("[WX]receive patpat msg: {}".format(cmsg.content))
+        elif cmsg.ctype == ContextType.TEXT:
+            logger.debug("[WX]receive text msg: {}, cmsg={}".format(json.dumps(cmsg._rawmsg, ensure_ascii=False), cmsg))
+        else:
+            logger.debug("[WX]receive msg: {}, cmsg={}".format(cmsg.content, cmsg))
+        context = self._compose_context(cmsg.ctype, cmsg.content, isgroup=False, msg=cmsg)
+        if context:
+            self.produce(context)
+
+    @time_checker
+    @_check
+    def handle_group(self, cmsg: ChatMessage):
+        if cmsg.ctype == ContextType.VOICE:
+            if not conf().get("speech_recognition"):
+                return
+            logger.debug("[WX]receive voice for group msg: {}".format(cmsg.content))
+        elif cmsg.ctype == ContextType.IMAGE:
+            logger.debug("[WX]receive image for group msg: {}".format(cmsg.content))
+        elif cmsg.ctype in [ContextType.JOIN_GROUP, ContextType.PATPAT]:
+            logger.debug("[WX]receive note msg: {}".format(cmsg.content))
+        elif cmsg.ctype == ContextType.TEXT:
+            pass
+        else:
+            logger.debug("[WX]receive group msg: {}".format(cmsg.content))
+        context = self._compose_context(cmsg.ctype, cmsg.content, isgroup=True, msg=cmsg)
+        if context:
+            self.produce(context)
+
+    # 统一的发送函数，每个Channel自行实现，根据reply的type字段发送不同类型的消息
+    def send(self, reply: Reply, context: Context):
+        logger.debug(f"context: {context}")
+        receiver = context["receiver"]
+        actual_user_id = context["msg"].actual_user_id
+        if reply.type == ReplyType.TEXT or reply.type == ReplyType.TEXT_:
+            match = re.search(r"^@(.*?)\n", reply.content)
+            logger.debug(f"match: {match}")
+            if match:
+                new_content = re.sub(r"^@(.*?)\n", "\n", reply.content)
+                at_list = [actual_user_id]
+                logger.debug(f"new_content: {new_content}")
+                wework.send_room_at_msg(receiver, new_content, at_list)
+            else:
+                wework.send_text(receiver, reply.content)
+            logger.info("[WX] sendMsg={}, receiver={}".format(reply, receiver))
+        elif reply.type == ReplyType.ERROR or reply.type == ReplyType.INFO:
+            wework.send_text(receiver, reply.content)
+            logger.info("[WX] sendMsg={}, receiver={}".format(reply, receiver))
+        elif reply.type == ReplyType.IMAGE:  # 从文件读取图片
+            image_storage = reply.content
+            image_storage.seek(0)
+            # Read data from image_storage
+            data = image_storage.read()
+            # Create a temporary file
+            with tempfile.NamedTemporaryFile(delete=False) as temp:
+                temp_path = temp.name
+                temp.write(data)
+            # Send the image
+            wework.send_image(receiver, temp_path)
+            logger.info("[WX] sendImage, receiver={}".format(receiver))
+            # Remove the temporary file
+            os.remove(temp_path)
+        elif reply.type == ReplyType.IMAGE_URL:  # 从网络下载图片
+            img_url = reply.content
+            filename = str(uuid.uuid4())
+
+            # 调用你的函数，下载图片并保存为本地文件
+            image_path = download_and_compress_image(img_url, filename)
+
+            wework.send_image(receiver, file_path=image_path)
+            logger.info("[WX] sendImage url={}, receiver={}".format(img_url, receiver))
+        elif reply.type == ReplyType.VIDEO_URL:
+            video_url = reply.content
+            filename = str(uuid.uuid4())
+            video_path = download_video(video_url, filename)
+
+            if video_path is None:
+                # 如果视频太大，下载可能会被跳过，此时 video_path 将为 None
+                wework.send_text(receiver, "抱歉，视频太大了！！！")
+            else:
+                wework.send_video(receiver, video_path)
+            logger.info("[WX] sendVideo, receiver={}".format(receiver))
+        elif reply.type == ReplyType.VOICE:
+            wework.send_file(receiver, reply.content)
+            logger.info("[WX] sendFile={}, receiver={}".format(reply.content, receiver))

channel/wework/wework_message.py

@@ -0,0 +1,180 @@
+import datetime
+import json
+import os
+import re
+import time
+import pilk
+
+from bridge.context import ContextType
+from channel.chat_message import ChatMessage
+from common.log import logger
+
+
+def get_with_retry(get_func, max_retries=5, delay=5):
+    retries = 0
+    result = None
+    while retries < max_retries:
+        result = get_func()
+        if result:
+            break
+        logger.warning(f"获取数据失败，重试第{retries + 1}次······")
+        retries += 1
+        time.sleep(delay)  # 等待一段时间后重试
+    return result
+
+
+def get_room_info(wework, conversation_id):
+    logger.debug(f"传入的 conversation_id: {conversation_id}")
+    rooms = wework.get_rooms()
+    if not rooms or 'room_list' not in rooms:
+        logger.error(f"获取群聊信息失败: {rooms}")
+        return None
+    time.sleep(1)
+    logger.debug(f"获取到的群聊信息: {rooms}")
+    for room in rooms['room_list']:
+        if room['conversation_id'] == conversation_id:
+            return room
+    return None
+
+
+def cdn_download(wework, message, file_name):
+    data = message["data"]
+    url = data["cdn"]["url"]
+    auth_key = data["cdn"]["auth_key"]
+    aes_key = data["cdn"]["aes_key"]
+    file_size = data["cdn"]["size"]
+
+    # 获取当前工作目录，然后与文件名拼接得到保存路径
+    current_dir = os.getcwd()
+    save_path = os.path.join(current_dir, "tmp", file_name)
+
+    result = wework.wx_cdn_download(url, auth_key, aes_key, file_size, save_path)
+    logger.debug(result)
+
+
+def c2c_download_and_convert(wework, message, file_name):
+    data = message["data"]
+    aes_key = data["cdn"]["aes_key"]
+    file_size = data["cdn"]["size"]
+    file_type = 5
+    file_id = data["cdn"]["file_id"]
+
+    current_dir = os.getcwd()
+    save_path = os.path.join(current_dir, "tmp", file_name)
+    result = wework.c2c_cdn_download(file_id, aes_key, file_size, file_type, save_path)
+    logger.debug(result)
+
+    # 在下载完SILK文件之后，立即将其转换为WAV文件
+    base_name, _ = os.path.splitext(save_path)
+    wav_file = base_name + ".wav"
+    pilk.silk_to_wav(save_path, wav_file, rate=24000)
+
+
+class WeworkMessage(ChatMessage):
+    def __init__(self, wework_msg, wework, is_group=False):
+        try:
+            super().__init__(wework_msg)
+            self.msg_id = wework_msg['data'].get('conversation_id', wework_msg['data'].get('room_conversation_id'))
+            # 使用.get()防止 'send_time' 键不存在时抛出错误
+            self.create_time = wework_msg['data'].get("send_time")
+            self.is_group = is_group
+            self.wework = wework
+
+            if wework_msg["type"] == 11041:  # 文本消息类型
+                if any(substring in wework_msg['data']['content'] for substring in ("该消息类型暂不能展示", "不支持的消息类型")):
+                    return
+                self.ctype = ContextType.TEXT
+                self.content = wework_msg['data']['content']
+            elif wework_msg["type"] == 11044:  # 语音消息类型，需要缓存文件
+                file_name = datetime.datetime.now().strftime('%Y%m%d%H%M%S') + ".silk"
+                base_name, _ = os.path.splitext(file_name)
+                file_name_2 = base_name + ".wav"
+                current_dir = os.getcwd()
+                self.ctype = ContextType.VOICE
+                self.content = os.path.join(current_dir, "tmp", file_name_2)
+                self._prepare_fn = lambda: c2c_download_and_convert(wework, wework_msg, file_name)
+            elif wework_msg["type"] == 11042:  # 图片消息类型，需要下载文件
+                file_name = datetime.datetime.now().strftime('%Y%m%d%H%M%S') + ".jpg"
+                current_dir = os.getcwd()
+                self.ctype = ContextType.IMAGE
+                self.content = os.path.join(current_dir, "tmp", file_name)
+                self._prepare_fn = lambda: cdn_download(wework, wework_msg, file_name)
+            elif wework_msg["type"] == 11072:  # 新成员入群通知
+                self.ctype = ContextType.JOIN_GROUP
+                member_list = wework_msg['data']['member_list']
+                self.actual_user_nickname = member_list[0]['name']
+                self.actual_user_id = member_list[0]['user_id']
+                self.content = f"{self.actual_user_nickname}加入了群聊！"
+                directory = os.path.join(os.getcwd(), "tmp")
+                rooms = get_with_retry(wework.get_rooms)
+                if not rooms:
+                    logger.error("更新群信息失败···")
+                else:
+                    result = {}
+                    for room in rooms['room_list']:
+                        # 获取聊天室ID
+                        room_wxid = room['conversation_id']
+
+                        # 获取聊天室成员
+                        room_members = wework.get_room_members(room_wxid)
+
+                        # 将聊天室成员保存到结果字典中
+                        result[room_wxid] = room_members
+                    with open(os.path.join(directory, 'wework_room_members.json'), 'w', encoding='utf-8') as f:
+                        json.dump(result, f, ensure_ascii=False, indent=4)
+                    logger.info("有新成员加入，已自动更新群成员列表缓存！")
+            else:
+                raise NotImplementedError(
+                    "Unsupported message type: Type:{} MsgType:{}".format(wework_msg["type"], wework_msg["MsgType"]))
+
+            data = wework_msg['data']
+            login_info = self.wework.get_login_info()
+            logger.debug(f"login_info: {login_info}")
+            nickname = f"{login_info['username']}({login_info['nickname']})" if login_info['nickname'] else login_info['username']
+            user_id = login_info['user_id']
+
+            sender_id = data.get('sender')
+            conversation_id = data.get('conversation_id')
+            sender_name = data.get("sender_name")
+
+            self.from_user_id = user_id if sender_id == user_id else conversation_id
+            self.from_user_nickname = nickname if sender_id == user_id else sender_name
+            self.to_user_id = user_id
+            self.to_user_nickname = nickname
+            self.other_user_nickname = sender_name
+            self.other_user_id = conversation_id
+
+            if self.is_group:
+                conversation_id = data.get('conversation_id') or data.get('room_conversation_id')
+                self.other_user_id = conversation_id
+                if conversation_id:
+                    room_info = get_room_info(wework=wework, conversation_id=conversation_id)
+                    self.other_user_nickname = room_info.get('nickname', None) if room_info else None
+                    at_list = data.get('at_list', [])
+                    tmp_list = []
+                    for at in at_list:
+                        tmp_list.append(at['nickname'])
+                    at_list = tmp_list
+                    logger.debug(f"at_list: {at_list}")
+                    logger.debug(f"nickname: {nickname}")
+                    self.is_at = nickname in at_list
+                    self.at_list = at_list
+
+                    # 检查消息内容是否包含@用户名。处理复制粘贴的消息，这类消息可能不会触发@通知，但内容中可能包含 "@用户名"。
+                    content = data.get('content', '')
+                    name = nickname
+                    pattern = f"@{re.escape(name)}(\u2005|\u0020)"
+                    if re.search(pattern, content):
+                        logger.debug(f"Wechaty message {self.msg_id} includes at")
+                        self.is_at = True
+
+                    if not self.actual_user_id:
+                        self.actual_user_id = data.get("sender")
+                    self.actual_user_nickname = sender_name if self.ctype != ContextType.JOIN_GROUP else self.actual_user_nickname
+                else:
+                    logger.error("群聊消息中没有找到 conversation_id 或 room_conversation_id")
+
+            logger.debug(f"WeworkMessage has been successfully instantiated with message id: {self.msg_id}")
+        except Exception as e:
+            logger.error(f"在 WeworkMessage 的初始化过程中出现错误：{e}")
+            raise e

common/const.py

@@ -2,7 +2,11 @@
 OPEN_AI = "openAI"
 CHATGPT = "chatGPT"
 BAIDU = "baidu"
+XUNFEI = "xunfei"
 CHATGPTONAZURE = "chatGPTOnAzure"
 LINKAI = "linkai"
 
 VERSION = "1.3.0"
+
+CLAUDEAI = "claude"
+MODEL_LIST = ["gpt-3.5-turbo", "gpt-3.5-turbo-16k", "gpt-4", "wenxin", "xunfei","claude"]

config-template.json

@@ -30,6 +30,8 @@
   "conversation_max_tokens": 1000,
   "expires_in_seconds": 3600,
   "character_desc": "你是ChatGPT, 一个由OpenAI训练的大型语言模型, 你旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。",
+  "temperature": 0.7,
+  "top_p": 1,
   "subscribe_msg": "感谢您的关注！\n这里是ChatGPT，可以自由对话。\n支持语音对话。\n支持图片输入。\n支持图片输出，画字开头的消息将按要求创作图片。\n支持tool、角色扮演和文字冒险等丰富的插件。\n输入{trigger_prefix}#help 查看详细指令。",
   "use_linkai": false,
   "linkai_api_key": "",

config.py

@@ -16,15 +16,15 @@ available_setting = {
     "open_ai_api_base": "https://api.openai.com/v1",
     "proxy": "",  # openai使用的代理
     # chatgpt模型， 当use_azure_chatgpt为true时，其名称为Azure上model deployment名称
-    "model": "gpt-3.5-turbo",    # 还支持 gpt-3.5-turbo-16k, gpt-4, wenxin
+    "model": "gpt-3.5-turbo",  # 还支持 gpt-3.5-turbo-16k, gpt-4, wenxin, xunfei
     "use_azure_chatgpt": False,  # 是否使用azure的chatgpt
     "azure_deployment_id": "",  # azure 模型部署名称
     "azure_api_version": "",  # azure api版本
     # Bot触发配置
     "single_chat_prefix": ["bot", "@bot"],  # 私聊时文本需要包含该前缀才能触发机器人回复
     "single_chat_reply_prefix": "[bot] ",  # 私聊时自动回复的前缀，用于区分真人
-    "single_chat_reply_suffix": "",  # 私聊时自动回复的后缀，\n 可以换行    
-    "group_chat_prefix": ["@bot"],  # 群聊时包含该前缀则会触发机器人回复 
+    "single_chat_reply_suffix": "",  # 私聊时自动回复的后缀，\n 可以换行
+    "group_chat_prefix": ["@bot"],  # 群聊时包含该前缀则会触发机器人回复
     "group_chat_reply_prefix": "",  # 群聊时自动回复的前缀
     "group_chat_reply_suffix": "",  # 群聊时自动回复的后缀，\n 可以换行
     "group_chat_keyword": [],  # 群聊时包含该关键词则会触发机器人回复
@@ -52,16 +52,25 @@ available_setting = {
     "request_timeout": 60,  # chatgpt请求超时时间，openai接口默认设置为600，对于难问题一般需要较长时间
     "timeout": 120,  # chatgpt重试超时时间，在这个时间内，将会自动重试
     # Baidu 文心一言参数
-    "baidu_wenxin_model": "eb-instant", # 默认使用ERNIE-Bot-turbo模型
-    "baidu_wenxin_api_key": "", # Baidu api key
-    "baidu_wenxin_secret_key": "", # Baidu secret key
+    "baidu_wenxin_model": "eb-instant",  # 默认使用ERNIE-Bot-turbo模型
+    "baidu_wenxin_api_key": "",  # Baidu api key
+    "baidu_wenxin_secret_key": "",  # Baidu secret key
+    # 讯飞星火API
+    "xunfei_app_id": "",  # 讯飞应用ID
+    "xunfei_api_key": "",  # 讯飞 API key
+    "xunfei_api_secret": "",  # 讯飞 API secret
+    # claude 配置
+    "claude_api_cookie": "",
+    "claude_uuid": "",
+    # wework的通用配置
+    "wework_smart": True,  # 配置wework是否使用已登录的企业微信，False为多开
     # 语音设置
     "speech_recognition": False,  # 是否开启语音识别
     "group_speech_recognition": False,  # 是否开启群组语音识别
     "voice_reply_voice": False,  # 是否使用语音回复语音，需要设置对应语音合成引擎的api key
     "always_reply_voice": False,  # 是否一直使用语音回复
     "voice_to_text": "openai",  # 语音识别引擎，支持openai,baidu,google,azure
-    "text_to_voice": "baidu",  # 语音合成引擎，支持baidu,google,pytts(offline),azure
+    "text_to_voice": "baidu",  # 语音合成引擎，支持baidu,google,pytts(offline),azure,elevenlabs
     # baidu 语音api配置， 使用百度语音识别和语音合成时需要
     "baidu_app_id": "",
     "baidu_api_key": "",
@@ -71,6 +80,9 @@ available_setting = {
     # azure 语音api配置， 使用azure语音识别和语音合成时需要
     "azure_voice_api_key": "",
     "azure_voice_region": "japaneast",
+    # elevenlabs 语音api配置
+    "xi_api_key": "",    #获取ap的方法可以参考https://docs.elevenlabs.io/api-reference/quick-start/authentication
+    "xi_voice_id": "",   #ElevenLabs提供了9种英式、美式等英语发音id，分别是“Adam/Antoni/Arnold/Bella/Domi/Elli/Josh/Rachel/Sam”
     # 服务时间限制，目前支持itchat
     "chat_time_module": False,  # 是否开启服务时间限制
     "chat_start_time": "00:00",  # 服务开始时间
@@ -112,7 +124,8 @@ available_setting = {
     # 知识库平台配置
     "use_linkai": False,
     "linkai_api_key": "",
-    "linkai_app_code": ""
+    "linkai_app_code": "",
+    "linkai_api_base": "https://api.link-ai.chat",  # linkAI服务地址，若国内无法访问或延迟较高可改为 https://api.link-ai.tech
 }
 
 

docker/Dockerfile.latest

@@ -1,4 +1,4 @@
-FROM python:3.10-slim
+FROM python:3.10-slim-bullseye
 
 LABEL maintainer="foo@bar.com"
 ARG TZ='Asia/Shanghai'
@@ -32,4 +32,4 @@ RUN chmod +x /entrypoint.sh \
 
 USER noroot
 
-ENTRYPOINT ["/entrypoint.sh"]
+ENTRYPOINT ["/entrypoint.sh"]

plugins/godcmd/godcmd.py

@@ -4,7 +4,6 @@ import json
 import os
 import random
 import string
-import traceback
 from typing import Tuple
 
 import plugins
@@ -12,7 +11,6 @@ from bridge.bridge import Bridge
 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, global_config
 from plugins import *
 
@@ -32,6 +30,10 @@ COMMANDS = {
         "args": ["口令"],
         "desc": "管理员认证",
     },
+    "model": {
+        "alias": ["model", "模型"],
+        "desc": "查看和设置全局模型",
+    },
     "set_openai_api_key": {
         "alias": ["set_openai_api_key"],
         "args": ["api_key"],
@@ -257,6 +259,18 @@ class Godcmd(Plugin):
                                 break
                         if not ok:
                             result = "插件不存在或未启用"
+                elif cmd == "model":
+                    if not isadmin and not self.is_admin_in_group(e_context["context"]):
+                        ok, result = False, "需要管理员权限执行"
+                    elif len(args) == 0:
+                        ok, result = True, "当前模型为: " + str(conf().get("model"))
+                    elif len(args) == 1:
+                        if args[0] not in const.MODEL_LIST:
+                            ok, result = False, "模型名称不存在"
+                        else:
+                            conf()["model"] = args[0]
+                            Bridge().reset_bot()
+                            ok, result = True, "模型设置为: " + str(conf().get("model"))
                 elif cmd == "id":
                     ok, result = True, user
                 elif cmd == "set_openai_api_key":
@@ -294,7 +308,7 @@ class Godcmd(Plugin):
                     except Exception as e:
                         ok, result = False, "你没有设置私有GPT模型"
                 elif cmd == "reset":
-                    if bottype in [const.OPEN_AI, const.CHATGPT, const.CHATGPTONAZURE, const.LINKAI]:
+                    if bottype in [const.OPEN_AI, const.CHATGPT, const.CHATGPTONAZURE, const.LINKAI, const.BAIDU, const.XUNFEI]:
                         bot.sessions.clear_session(session_id)
                         channel.cancel_session(session_id)
                         ok, result = True, "会话已重置"
@@ -317,7 +331,8 @@ class Godcmd(Plugin):
                             load_config()
                             ok, result = True, "配置已重载"
                         elif cmd == "resetall":
-                            if bottype in [const.OPEN_AI, const.CHATGPT, const.CHATGPTONAZURE, const.LINKAI]:
+                            if bottype in [const.OPEN_AI, const.CHATGPT, const.CHATGPTONAZURE, const.LINKAI,
+                                           const.BAIDU, const.XUNFEI]:
                                 channel.cancel_all_session()
                                 bot.sessions.clear_all_session()
                                 ok, result = True, "重置所有会话成功"
@@ -437,3 +452,9 @@ class Godcmd(Plugin):
 
     def get_help_text(self, isadmin=False, isgroup=False, **kwargs):
         return get_help_text(isadmin, isgroup)
+
+
+    def is_admin_in_group(self, context):
+        if context["isgroup"]:
+            return context.kwargs.get("msg").actual_user_id in global_config["admin_users"]
+        return False

plugins/linkai/midjourney.py

@@ -68,8 +68,7 @@ class MJTask:
 # midjourney bot
 class MJBot:
     def __init__(self, config):
-        self.base_url = "https://api.link-ai.chat/v1/img/midjourney"
-
+        self.base_url = conf().get("linkai_api_base", "https://api.link-ai.chat") + "/v1/img/midjourney"
         self.headers = {"Authorization": "Bearer " + conf().get("linkai_api_key")}
         self.config = config
         self.tasks = {}
@@ -310,7 +309,7 @@ class MJBot:
         # send img
         reply = Reply(ReplyType.IMAGE_URL, task.img_url)
         channel = e_context["channel"]
-        channel._send(reply, e_context["context"])
+        _send(channel, reply, e_context["context"])
 
         # send info
         trigger_prefix = conf().get("plugin_trigger_prefix", "$")
@@ -327,7 +326,7 @@ class MJBot:
             text += f"\n\n🔄使用 {trigger_prefix}mjr 命令重新生成图片\n"
             text += f"例如：\n{trigger_prefix}mjr {task.img_id}"
             reply = Reply(ReplyType.INFO, text)
-            channel._send(reply, e_context["context"])
+            _send(channel, reply, e_context["context"])
 
         self._print_tasks()
         return
@@ -406,6 +405,19 @@ class MJBot:
         return result
 
 
+def _send(channel, reply: Reply, context, retry_cnt=0):
+    try:
+        channel.send(reply, context)
+    except Exception as e:
+        logger.error("[WX] sendMsg error: {}".format(str(e)))
+        if isinstance(e, NotImplementedError):
+            return
+        logger.exception(e)
+        if retry_cnt < 2:
+            time.sleep(3 + 3 * retry_cnt)
+            channel.send(reply, context, retry_cnt + 1)
+
+
 def check_prefix(content, prefix_list):
     if not prefix_list:
         return None

requirements-optional.txt

@@ -16,13 +16,18 @@ dulwich
 # wechaty
 wechaty>=0.10.7
 wechaty_puppet>=0.4.23
-pysilk_mod>=1.6.0 # needed by send voice
+# pysilk_mod>=1.6.0 # needed by send voice only in wechaty
 
 # wechatmp wechatcom
 web.py
 wechatpy
 
 # chatgpt-tool-hub plugin
-
 --extra-index-url https://pypi.python.org/simple
 chatgpt_tool_hub==0.4.6
+
+# xunfei spark
+websocket-client==1.2.0
+
+# claude bot
+curl_cffi

requirements.txt

@@ -6,3 +6,4 @@ requests>=2.28.2
 chardet>=5.1.0
 Pillow
 pre-commit
+web.py

voice/elevent/elevent_voice.py

@@ -0,0 +1,33 @@
+import time
+
+from elevenlabs import set_api_key,generate
+
+from bridge.reply import Reply, ReplyType
+from common.log import logger
+from common.tmp_dir import TmpDir
+from voice.voice import Voice
+from config import conf
+
+XI_API_KEY = conf().get("xi_api_key")
+set_api_key(XI_API_KEY)
+name = conf().get("xi_voice_id")
+
+class ElevenLabsVoice(Voice):
+
+    def __init__(self):
+        pass
+
+    def voiceToText(self, voice_file):
+        pass
+
+    def textToVoice(self, text):
+        audio = generate(
+            text=text,
+            voice=name,
+            model='eleven_multilingual_v1'
+        )
+        fileName = TmpDir().path() + "reply-" + str(int(time.time())) + "-" + str(hash(text) & 0x7FFFFFFF) + ".mp3"
+        with open(fileName, "wb") as f:
+            f.write(audio)
+        logger.info("[ElevenLabs] textToVoice text={} voice file name={}".format(text, fileName))
+        return Reply(ReplyType.VOICE, fileName)

voice/factory.py

@@ -29,4 +29,8 @@ def create_voice(voice_type):
         from voice.azure.azure_voice import AzureVoice
 
         return AzureVoice()
+    elif voice_type == "elevenlabs":
+        from voice.elevent.elevent_voice import ElevenLabsVoice
+
+        return ElevenLabsVoice()
     raise RuntimeError