chore: release v3.4.5.1

feat: add `discord` adapter

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -12,6 +12,8 @@ body:
         - Nakuru（go-cqhttp）
         - aiocqhttp（使用 OneBot 协议接入的）
         - qq-botpy（QQ官方API）
+        - lark（飞书）
+        - wecom（企业微信）
     validations:
       required: true
   - type: input
@@ -30,9 +32,9 @@ body:
   - type: textarea
     attributes:
       label: 复现步骤
-      description: 如何重现这个问题，越详细越好
+      description: 如何重现这个问题，越详细越好；请贴上所有相关的配置文件和元数据文件（注意隐去敏感信息）
     validations:
-      required: false
+      required: true
   - type: textarea
     attributes:
       label: 启用的插件

.gitignore

@@ -34,4 +34,7 @@ data/labels/instance_id.json
 .DS_Store
 /data
 botpy.log*
-/poc
+/poc
+/libs/wecom_api/test.py
+/venv
+

README.md

@@ -1,6 +1,8 @@
 
 <p align="center">
+<a href="https://langbot.app">
 <img src="https://docs.langbot.app/social.png" alt="LangBot"/>
+</a>
 
 <div align="center">
 
@@ -13,21 +15,14 @@
 <a href="https://docs.langbot.app/plugin/plugin-intro.html">插件介绍</a> ｜
 <a href="https://github.com/RockChinQ/LangBot/issues/new?assignees=&labels=%E7%8B%AC%E7%AB%8B%E6%8F%92%E4%BB%B6&projects=&template=submit-plugin.yml&title=%5BPlugin%5D%3A+%E8%AF%B7%E6%B1%82%E7%99%BB%E8%AE%B0%E6%96%B0%E6%8F%92%E4%BB%B6">提交插件</a>
 
-
 <div align="center">
-😎高稳定、🧩支持扩展、🦄多模态 - 基于大语言模型的即时通讯机器人平台🤖  
+😎高稳定、🧩支持扩展、🦄多模态 - 大模型原生即时通信机器人平台🤖  
 </div>
 
 <br/>
 
-<a href="http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=66-aWvn8cbP4c1ut_1YYkvvGVeEtyTH8&authKey=pTaKBK5C%2B8dFzQ4XlENf6MHTCLaHnlKcCRx7c14EeVVlpX2nRSaS8lJm8YeM4mCU&noverify=0&group_code=195992197">
-<img alt="Static Badge" src="https://img.shields.io/badge/%E5%AE%98%E6%96%B9%E7%BE%A4-195992197-green">
-</a>
-<a href="https://qm.qq.com/q/PClALFK242">
-<img alt="Static Badge" src="https://img.shields.io/badge/%E7%A4%BE%E5%8C%BA%E7%BE%A4-619154800-green">
-</a>
-<br/>
 
+[![QQ Group](https://img.shields.io/badge/%E7%A4%BE%E5%8C%BAQQ%E7%BE%A4-1030838208-blue)](https://qm.qq.com/q/PF9OuQCCcM)
 [![GitHub release (latest by date)](https://img.shields.io/github/v/release/RockChinQ/LangBot)](https://github.com/RockChinQ/LangBot/releases/latest)
  ![Dynamic JSON Badge](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fapi.qchatgpt.rockchin.top%2Fapi%2Fv2%2Fview%2Frealtime%2Fcount_query%3Fminute%3D10080&query=%24.data.count&label=%E4%BD%BF%E7%94%A8%E9%87%8F%EF%BC%887%E6%97%A5%EF%BC%89)
 <img src="https://img.shields.io/badge/python-3.10 | 3.11 | 3.12-blue.svg" alt="python">
@@ -37,7 +32,7 @@
 
 ## ✨ Features
 
-- 💬 大模型对话、Agent：支持多种大模型，适配群聊和私聊；具有多轮对话、工具调用、多模态能力，并深度适配 [Dify](https://dify.ai)。目前支持 QQ、QQ频道，后续还将支持微信、WhatsApp、Discord等平台。
+- 💬 大模型对话、Agent：支持多种大模型，适配群聊和私聊；具有多轮对话、工具调用、多模态能力，并深度适配 [Dify](https://dify.ai)。目前支持 QQ、QQ频道、企业微信、飞书、Discord，后续还将支持个人微信、WhatsApp、Telegram 等平台。
 - 🛠️ 高稳定性、功能完备：原生支持访问控制、限速、敏感词过滤等机制；配置简单，支持多种部署方式。
 - 🧩 插件扩展、活跃社区：支持事件驱动、组件扩展等插件机制；丰富生态，目前已有数十个[插件](https://docs.langbot.app/plugin/plugin-intro.html)
 - 😻 [New] Web 管理面板：支持通过浏览器管理 LangBot 实例，具体支持功能，查看[文档](https://docs.langbot.app/webui/intro.html)
@@ -84,10 +79,13 @@
 
 | 平台 | 状态 | 备注 |
 | --- | --- | --- |
-| OneBot v11 | ✅ | QQ 个人号私聊、群聊 |
-| go-cqhttp | ✅ | QQ 个人号私聊、群聊 |
-| QQ 官方 API | ✅ | QQ 频道机器人，支持频道、私聊、群聊 |
-| 企业微信 | 🚧 |  |
+| QQ 个人号 | ✅ | QQ 个人号私聊、群聊 |
+| QQ 官方机器人 | ✅ | QQ 官方机器人，支持频道、私聊、群聊 |
+| 企业微信 | ✅ |  |
+| 飞书 | ✅ |  |
+| Discord | ✅ |  |
+| 个人微信 | 🚧 |  |
+| WhatsApp | 🚧 |  |
 | 钉钉 | 🚧 |  |
 
 🚧: 正在开发中
@@ -103,5 +101,17 @@
 | [xAI](https://x.ai/) | ✅ |  |
 | [智谱AI](https://open.bigmodel.cn/) | ✅ |  |
 | [Dify](https://dify.ai) | ✅ | LLMOps 平台 |
-| [Ollama](https://ollama.com/) | ✅ | 本地大模型管理平台 |
+| [Ollama](https://ollama.com/) | ✅ | 本地大模型运行平台 |
+| [LMStudio](https://lmstudio.ai/) | ✅ | 本地大模型运行平台 |
 | [GiteeAI](https://ai.gitee.com/) | ✅ | 大模型接口聚合平台 |
+| [SiliconFlow](https://siliconflow.cn/) | ✅ | 大模型聚合平台 |
+| [阿里云百炼](https://bailian.console.aliyun.com/) | ✅ | 大模型聚合平台 |
+
+## 😘 社区贡献
+
+LangBot 离不开以下贡献者和社区内所有人的贡献，我们欢迎任何形式的贡献和反馈。
+
+
+<a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
+</a>

libs/wecom_api/WXBizMsgCrypt3.py

@@ -0,0 +1,279 @@
+#!/usr/bin/env python
+# -*- encoding:utf-8 -*-
+
+""" 对企业微信发送给企业后台的消息加解密示例代码.
+@copyright: Copyright (c) 1998-2014 Tencent Inc.
+
+"""
+# ------------------------------------------------------------------------
+import logging
+import base64
+import random
+import hashlib
+import time
+import struct
+from Crypto.Cipher import AES
+import xml.etree.cElementTree as ET
+import socket
+
+from . import ierror
+
+
+"""
+Crypto.Cipher包已不再维护，开发者可以通过以下命令下载安装最新版的加解密工具包
+    pip install pycryptodome
+"""
+
+
+class FormatException(Exception):
+    pass
+
+
+def throw_exception(message, exception_class=FormatException):
+    """my define raise exception function"""
+    raise exception_class(message)
+
+
+class SHA1:
+    """计算企业微信的消息签名接口"""
+
+    def getSHA1(self, token, timestamp, nonce, encrypt):
+        """用SHA1算法生成安全签名
+        @param token:  票据
+        @param timestamp: 时间戳
+        @param encrypt: 密文
+        @param nonce: 随机字符串
+        @return: 安全签名
+        """
+        try:
+            sortlist = [token, timestamp, nonce, encrypt]
+            sortlist.sort()
+            sha = hashlib.sha1()
+            sha.update("".join(sortlist).encode())
+            return ierror.WXBizMsgCrypt_OK, sha.hexdigest()
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_ComputeSignature_Error, None
+
+
+class XMLParse:
+    """提供提取消息格式中的密文及生成回复消息格式的接口"""
+
+    # xml消息模板
+    AES_TEXT_RESPONSE_TEMPLATE = """<xml>
+<Encrypt><![CDATA[%(msg_encrypt)s]]></Encrypt>
+<MsgSignature><![CDATA[%(msg_signaturet)s]]></MsgSignature>
+<TimeStamp>%(timestamp)s</TimeStamp>
+<Nonce><![CDATA[%(nonce)s]]></Nonce>
+</xml>"""
+
+    def extract(self, xmltext):
+        """提取出xml数据包中的加密消息
+        @param xmltext: 待提取的xml字符串
+        @return: 提取出的加密消息字符串
+        """
+        try:
+            xml_tree = ET.fromstring(xmltext)
+            encrypt = xml_tree.find("Encrypt")
+            return ierror.WXBizMsgCrypt_OK, encrypt.text
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_ParseXml_Error, None
+
+    def generate(self, encrypt, signature, timestamp, nonce):
+        """生成xml消息
+        @param encrypt: 加密后的消息密文
+        @param signature: 安全签名
+        @param timestamp: 时间戳
+        @param nonce: 随机字符串
+        @return: 生成的xml字符串
+        """
+        resp_dict = {
+            'msg_encrypt': encrypt,
+            'msg_signaturet': signature,
+            'timestamp': timestamp,
+            'nonce': nonce,
+        }
+        resp_xml = self.AES_TEXT_RESPONSE_TEMPLATE % resp_dict
+        return resp_xml
+
+
+class PKCS7Encoder():
+    """提供基于PKCS7算法的加解密接口"""
+
+    block_size = 32
+
+    def encode(self, text):
+        """ 对需要加密的明文进行填充补位
+        @param text: 需要进行填充补位操作的明文
+        @return: 补齐明文字符串
+        """
+        text_length = len(text)
+        # 计算需要填充的位数
+        amount_to_pad = self.block_size - (text_length % self.block_size)
+        if amount_to_pad == 0:
+            amount_to_pad = self.block_size
+        # 获得补位所用的字符
+        pad = chr(amount_to_pad)
+        return text + (pad * amount_to_pad).encode()
+
+    def decode(self, decrypted):
+        """删除解密后明文的补位字符
+        @param decrypted: 解密后的明文
+        @return: 删除补位字符后的明文
+        """
+        pad = ord(decrypted[-1])
+        if pad < 1 or pad > 32:
+            pad = 0
+        return decrypted[:-pad]
+
+
+class Prpcrypt(object):
+    """提供接收和推送给企业微信消息的加解密接口"""
+
+    def __init__(self, key):
+
+        # self.key = base64.b64decode(key+"=")
+        self.key = key
+        # 设置加解密模式为AES的CBC模式
+        self.mode = AES.MODE_CBC
+
+    def encrypt(self, text, receiveid):
+        """对明文进行加密
+        @param text: 需要加密的明文
+        @return: 加密得到的字符串
+        """
+        # 16位随机字符串添加到明文开头
+        text = text.encode()
+        text = self.get_random_str() + struct.pack("I", socket.htonl(len(text))) + text + receiveid.encode()
+
+        # 使用自定义的填充方式对明文进行补位填充
+        pkcs7 = PKCS7Encoder()
+        text = pkcs7.encode(text)
+        # 加密
+        cryptor = AES.new(self.key, self.mode, self.key[:16])
+        try:
+            ciphertext = cryptor.encrypt(text)
+            # 使用BASE64对加密后的字符串进行编码
+            return ierror.WXBizMsgCrypt_OK, base64.b64encode(ciphertext)
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_EncryptAES_Error, None
+
+    def decrypt(self, text, receiveid):
+        """对解密后的明文进行补位删除
+        @param text: 密文
+        @return: 删除填充补位后的明文
+        """
+        try:
+            cryptor = AES.new(self.key, self.mode, self.key[:16])
+            # 使用BASE64对密文进行解码，然后AES-CBC解密
+            plain_text = cryptor.decrypt(base64.b64decode(text))
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_DecryptAES_Error, None
+        try:
+            pad = plain_text[-1]
+            # 去掉补位字符串
+            # pkcs7 = PKCS7Encoder()
+            # plain_text = pkcs7.encode(plain_text)
+            # 去除16位随机字符串
+            content = plain_text[16:-pad]
+            xml_len = socket.ntohl(struct.unpack("I", content[: 4])[0])
+            xml_content = content[4: xml_len + 4]
+            from_receiveid = content[xml_len + 4:]
+        except Exception as e:
+            logger = logging.getLogger()
+            logger.error(e)
+            return ierror.WXBizMsgCrypt_IllegalBuffer, None
+
+        if from_receiveid.decode('utf8') != receiveid:
+            return ierror.WXBizMsgCrypt_ValidateCorpid_Error, None
+        return 0, xml_content
+
+    def get_random_str(self):
+        """ 随机生成16位字符串
+        @return: 16位字符串
+        """
+        return str(random.randint(1000000000000000, 9999999999999999)).encode()
+
+
+class WXBizMsgCrypt(object):
+    # 构造函数
+    def __init__(self, sToken, sEncodingAESKey, sReceiveId):
+        try:
+            self.key = base64.b64decode(sEncodingAESKey + "=")
+            assert len(self.key) == 32
+        except:
+            throw_exception("[error]: EncodingAESKey unvalid !", FormatException)
+            # return ierror.WXBizMsgCrypt_IllegalAesKey,None
+        self.m_sToken = sToken
+        self.m_sReceiveId = sReceiveId
+
+        # 验证URL
+        # @param sMsgSignature: 签名串，对应URL参数的msg_signature
+        # @param sTimeStamp: 时间戳，对应URL参数的timestamp
+        # @param sNonce: 随机串，对应URL参数的nonce
+        # @param sEchoStr: 随机串，对应URL参数的echostr
+        # @param sReplyEchoStr: 解密之后的echostr，当return返回0时有效
+        # @return：成功0，失败返回对应的错误码
+
+    def VerifyURL(self, sMsgSignature, sTimeStamp, sNonce, sEchoStr):
+        sha1 = SHA1()
+        ret, signature = sha1.getSHA1(self.m_sToken, sTimeStamp, sNonce, sEchoStr)
+        if ret != 0:
+            return ret, None
+        if not signature == sMsgSignature:
+            return ierror.WXBizMsgCrypt_ValidateSignature_Error, None
+        pc = Prpcrypt(self.key)
+        ret, sReplyEchoStr = pc.decrypt(sEchoStr, self.m_sReceiveId)
+        return ret, sReplyEchoStr
+
+    def EncryptMsg(self, sReplyMsg, sNonce, timestamp=None):
+        # 将企业回复用户的消息加密打包
+        # @param sReplyMsg: 企业号待回复用户的消息，xml格式的字符串
+        # @param sTimeStamp: 时间戳，可以自己生成，也可以用URL参数的timestamp,如为None则自动用当前时间
+        # @param sNonce: 随机串，可以自己生成，也可以用URL参数的nonce
+        # sEncryptMsg: 加密后的可以直接回复用户的密文，包括msg_signature, timestamp, nonce, encrypt的xml格式的字符串,
+        # return：成功0，sEncryptMsg,失败返回对应的错误码None
+        pc = Prpcrypt(self.key)
+        ret, encrypt = pc.encrypt(sReplyMsg, self.m_sReceiveId)
+        encrypt = encrypt.decode('utf8')
+        if ret != 0:
+            return ret, None
+        if timestamp is None:
+            timestamp = str(int(time.time()))
+        # 生成安全签名
+        sha1 = SHA1()
+        ret, signature = sha1.getSHA1(self.m_sToken, timestamp, sNonce, encrypt)
+        if ret != 0:
+            return ret, None
+        xmlParse = XMLParse()
+        return ret, xmlParse.generate(encrypt, signature, timestamp, sNonce)
+
+    def DecryptMsg(self, sPostData, sMsgSignature, sTimeStamp, sNonce):
+        # 检验消息的真实性，并且获取解密后的明文
+        # @param sMsgSignature: 签名串，对应URL参数的msg_signature
+        # @param sTimeStamp: 时间戳，对应URL参数的timestamp
+        # @param sNonce: 随机串，对应URL参数的nonce
+        # @param sPostData: 密文，对应POST请求的数据
+        #  xml_content: 解密后的原文，当return返回0时有效
+        # @return: 成功0，失败返回对应的错误码
+        # 验证安全签名
+        xmlParse = XMLParse()
+        ret, encrypt = xmlParse.extract(sPostData)
+        if ret != 0:
+            return ret, None
+        sha1 = SHA1()
+        ret, signature = sha1.getSHA1(self.m_sToken, sTimeStamp, sNonce, encrypt)
+        if ret != 0:
+            return ret, None
+        if not signature == sMsgSignature:
+            return ierror.WXBizMsgCrypt_ValidateSignature_Error, None
+        pc = Prpcrypt(self.key)
+        ret, xml_content = pc.decrypt(encrypt, self.m_sReceiveId)
+        return ret, xml_content

libs/wecom_api/api.py

@@ -0,0 +1,319 @@
+from quart import request
+from .WXBizMsgCrypt3 import WXBizMsgCrypt
+import base64
+import binascii
+import httpx
+from quart import Quart
+import xml.etree.ElementTree as ET
+from typing import Callable, Dict, Any
+from .wecomevent import WecomEvent
+from pkg.platform.types import events as platform_events, message as platform_message
+import aiofiles
+
+
+class WecomClient():
+    def __init__(self,corpid:str,secret:str,token:str,EncodingAESKey:str,contacts_secret:str):
+        self.corpid = corpid
+        self.secret = secret
+        self.access_token_for_contacts =''
+        self.token = token
+        self.aes = EncodingAESKey
+        self.base_url = 'https://qyapi.weixin.qq.com/cgi-bin'
+        self.access_token = ''
+        self.secret_for_contacts = contacts_secret
+        self.app = Quart(__name__)
+        self.wxcpt = WXBizMsgCrypt(self.token, self.aes, self.corpid)
+        self.app.add_url_rule('/callback/command', 'handle_callback', self.handle_callback_request, methods=['GET', 'POST'])
+        self._message_handlers = {
+            "example":[],
+        }
+
+    #access——token操作
+    async def check_access_token(self):
+        return bool(self.access_token and self.access_token.strip())
+
+    async def check_access_token_for_contacts(self):
+        return bool(self.access_token_for_contacts and self.access_token_for_contacts.strip())
+
+    async def get_access_token(self,secret):
+        url = f'https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid={self.corpid}&corpsecret={secret}'
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            data = response.json()
+            if 'access_token' in data:
+                return data['access_token']
+            else:
+                raise Exception(f"未获取access token: {data}")
+
+    async def get_users(self):
+        if not self.check_access_token_for_contacts():
+            self.access_token_for_contacts = await self.get_access_token(self.secret_for_contacts)
+
+        url = self.base_url+'/user/list_id?access_token='+self.access_token_for_contacts
+        async with httpx.AsyncClient() as client:
+            params = {
+                "cursor":"",
+                "limit":10000,
+            }
+            response = await client.post(url,json=params)
+            data = response.json()
+            if data['errcode'] == 0:
+                dept_users = data['dept_user']
+                userid = []
+                for user in dept_users:
+                    userid.append(user["userid"])
+                return userid
+            else:
+                raise Exception("未获取用户")
+            
+    async def send_to_all(self,content:str):
+        if not self.check_access_token_for_contacts():
+            self.access_token_for_contacts = await self.get_access_token(self.secret_for_contacts)
+
+            url = self.base_url+'/message/send?access_token='+self.access_token_for_contacts
+            user_ids = await self.get_users()
+            user_ids_string = "|".join(user_ids)
+            async with httpx.AsyncClient() as client:
+                params = {
+                "touser" : user_ids_string,
+                "msgtype" : "text",
+                "agentid" : 1000002,
+                "text" : {
+                    "content" : content,
+                },
+                "safe":0,
+                "enable_id_trans": 0,
+                "enable_duplicate_check": 0,
+                "duplicate_check_interval": 1800
+                }
+                response = await client.post(url,json=params)
+                data = response.json()
+                if data['errcode'] != 0:
+                    raise Exception("Failed to send message: "+str(data))
+
+    async def send_image(self,user_id:str,agent_id:int,media_id:str):
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+        url = self.base_url+'/media/upload?access_token='+self.access_token
+        async with httpx.AsyncClient() as client:
+            params = {
+                "touser" : user_id,
+                "toparty" : "",
+                "totag":"",
+                "agentid" : agent_id,
+                "msgtype" : "image",
+                "image" : {
+                    "media_id" : media_id,
+                },
+                "safe":0,
+                "enable_id_trans": 0,
+                "enable_duplicate_check": 0,
+                "duplicate_check_interval": 1800
+            }
+            try:
+                response = await client.post(url,json=params)
+                data = response.json()
+            except Exception as e:
+                raise Exception("Failed to send image: "+str(e))
+
+            # 企业微信错误码40014和42001，代表accesstoken问题
+            if data['errcode'] == 40014 or data['errcode'] == 42001:
+                self.access_token = await self.get_access_token(self.secret)
+                return await self.send_image(user_id,agent_id,media_id)
+
+            if data['errcode'] != 0:
+                raise Exception("Failed to send image: "+str(data))
+            
+    async def send_private_msg(self,user_id:str, agent_id:int,content:str):
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+
+        url = self.base_url+'/message/send?access_token='+self.access_token
+
+        async with httpx.AsyncClient() as client:
+            params={
+                "touser" : user_id,
+                "msgtype" : "text",
+                "agentid" : agent_id,
+                "text" : {
+                    "content" : content,
+                },
+                "safe":0,
+                "enable_id_trans": 0,
+                "enable_duplicate_check": 0,
+                "duplicate_check_interval": 1800
+            }
+            response = await client.post(url,json=params)
+            data = response.json()
+            if data['errcode'] == 40014 or data['errcode'] == 42001:
+                self.access_token = await self.get_access_token(self.secret)
+                return await self.send_private_msg(user_id,agent_id,content)
+            if data['errcode'] != 0:
+                raise Exception("Failed to send message: "+str(data))
+
+    async def handle_callback_request(self):
+        """
+        处理回调请求，包括 GET 验证和 POST 消息接收。
+        """
+        try:
+
+            msg_signature = request.args.get("msg_signature")
+            timestamp = request.args.get("timestamp")
+            nonce = request.args.get("nonce")
+
+            if request.method == "GET":
+                echostr = request.args.get("echostr")
+                ret, reply_echo_str = self.wxcpt.VerifyURL(msg_signature, timestamp, nonce, echostr)
+                if ret != 0:
+                    raise Exception(f"验证失败，错误码: {ret}")
+                return reply_echo_str
+
+            elif request.method == "POST":
+                encrypt_msg = await request.data
+                ret, xml_msg = self.wxcpt.DecryptMsg(encrypt_msg, msg_signature, timestamp, nonce)
+                if ret != 0:
+                    raise Exception(f"消息解密失败，错误码: {ret}")
+
+                # 解析消息并处理
+                message_data = await self.get_message(xml_msg)
+                if message_data:
+                    event = WecomEvent.from_payload(message_data)  # 转换为 WecomEvent 对象
+                    if event:
+                        await self._handle_message(event)
+
+                return "success"
+        except Exception as e:
+            return f"Error processing request: {str(e)}", 400
+
+    async def run_task(self, host: str, port: int, *args, **kwargs):
+        """
+        启动 Quart 应用。
+        """
+        await self.app.run_task(host=host, port=port, *args, **kwargs)
+
+    def on_message(self, msg_type: str):
+        """
+        注册消息类型处理器。
+        """
+        def decorator(func: Callable[[WecomEvent], None]):
+            if msg_type not in self._message_handlers:
+                self._message_handlers[msg_type] = []
+            self._message_handlers[msg_type].append(func)
+            return func
+        return decorator
+
+    async def _handle_message(self, event: WecomEvent):
+        """
+        处理消息事件。
+        """
+        msg_type = event.type
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+    async def get_message(self, xml_msg: str) -> Dict[str, Any]:
+        """
+        解析微信返回的 XML 消息并转换为字典。
+        """
+        root = ET.fromstring(xml_msg)
+        message_data = {
+            "ToUserName": root.find("ToUserName").text,
+            "FromUserName": root.find("FromUserName").text,
+            "CreateTime": int(root.find("CreateTime").text),
+            "MsgType": root.find("MsgType").text,
+            "Content": root.find("Content").text if root.find("Content") is not None else None,
+            "MsgId": int(root.find("MsgId").text) if root.find("MsgId") is not None else None,
+            "AgentID": int(root.find("AgentID").text) if root.find("AgentID") is not None else None,
+        }
+        if message_data["MsgType"] == "image":
+            message_data["MediaId"] = root.find("MediaId").text if root.find("MediaId") is not None else None
+            message_data["PicUrl"] = root.find("PicUrl").text if root.find("PicUrl") is not None else None
+    
+        return message_data
+    
+    @staticmethod
+    async def get_image_type(image_bytes: bytes) -> str:
+        """
+        通过图片的magic numbers判断图片类型
+        """
+        magic_numbers = {
+            b'\xFF\xD8\xFF': 'jpg',
+            b'\x89\x50\x4E\x47': 'png',
+            b'\x47\x49\x46': 'gif',
+            b'\x42\x4D': 'bmp',
+            b'\x00\x00\x01\x00': 'ico'
+        }
+    
+        for magic, ext in magic_numbers.items():
+            if image_bytes.startswith(magic):
+                return ext
+        return 'jpg'  # 默认返回jpg
+    
+
+    async def upload_to_work(self, image: platform_message.Image):
+        """
+        获取 media_id
+        """
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+
+        url = self.base_url + '/media/upload?access_token=' + self.access_token + '&type=file'
+        file_bytes = None
+        file_name = "uploaded_file.txt"
+
+        # 获取文件的二进制数据
+        if image.path:
+            async with aiofiles.open(image.path, 'rb') as f:
+                file_bytes = await f.read()
+                file_name = image.path.split('/')[-1]
+        elif image.url:
+            file_bytes = await self.download_image_to_bytes(image.url)
+            file_name = image.url.split('/')[-1]
+        elif image.base64:
+            try:
+                base64_data = image.base64
+                if ',' in base64_data:
+                    base64_data = base64_data.split(',', 1)[1]
+                padding = 4 - (len(base64_data) % 4) if len(base64_data) % 4 else 0
+                padded_base64 = base64_data + '=' * padding
+                file_bytes = base64.b64decode(padded_base64)
+            except binascii.Error as e:
+                raise ValueError(f"Invalid base64 string: {str(e)}")
+        else:
+            raise ValueError("image对象出错")
+
+        # 设置 multipart/form-data 格式的文件
+        boundary = "-------------------------acebdf13572468"
+        headers = {
+            'Content-Type': f'multipart/form-data; boundary={boundary}'
+        }
+        body = (
+            f"--{boundary}\r\n"
+            f"Content-Disposition: form-data; name=\"media\"; filename=\"{file_name}\"; filelength={len(file_bytes)}\r\n"
+            f"Content-Type: application/octet-stream\r\n\r\n"
+        ).encode('utf-8') + file_bytes + f"\r\n--{boundary}--\r\n".encode('utf-8')
+
+        # 上传文件
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, headers=headers, content=body)
+            data = response.json()
+            if data['errcode'] == 40014 or data['errcode'] == 42001:
+                self.access_token = await self.get_access_token(self.secret)
+                media_id = await self.upload_to_work(image)
+            if data.get('errcode', 0) != 0:
+                raise Exception("failed to upload file")
+
+            media_id = data.get('media_id')
+            return media_id
+
+    async def download_image_to_bytes(self,url:str) -> bytes:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            return response.content
+
+    #进行media_id的获取
+    async def get_media_id(self, image: platform_message.Image):
+
+        media_id = await self.upload_to_work(image=image)
+        return media_id

libs/wecom_api/ierror.py

@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#########################################################################
+# Author: jonyqin
+# Created Time: Thu 11 Sep 2014 01:53:58 PM CST
+# File Name: ierror.py
+# Description:定义错误码含义 
+#########################################################################
+WXBizMsgCrypt_OK = 0
+WXBizMsgCrypt_ValidateSignature_Error = -40001
+WXBizMsgCrypt_ParseXml_Error = -40002
+WXBizMsgCrypt_ComputeSignature_Error = -40003
+WXBizMsgCrypt_IllegalAesKey = -40004
+WXBizMsgCrypt_ValidateCorpid_Error = -40005
+WXBizMsgCrypt_EncryptAES_Error = -40006
+WXBizMsgCrypt_DecryptAES_Error = -40007
+WXBizMsgCrypt_IllegalBuffer = -40008
+WXBizMsgCrypt_EncodeBase64_Error = -40009
+WXBizMsgCrypt_DecodeBase64_Error = -40010
+WXBizMsgCrypt_GenReturnXml_Error = -40011

libs/wecom_api/wecomevent.py

@@ -0,0 +1,179 @@
+from typing import Dict, Any, Optional
+
+
+class WecomEvent(dict):
+    """
+    封装从企业微信收到的事件数据对象（字典），提供属性以获取其中的字段。
+
+    除 `type` 和 `detail_type` 属性对于任何事件都有效外，其它属性是否存在（若不存在则返回 `None`）依事件类型不同而不同。
+    """
+
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional["WecomEvent"]:
+        """
+        从企业微信事件数据构造 `WecomEvent` 对象。
+
+        Args:
+            payload (Dict[str, Any]): 解密后的企业微信事件数据。
+
+        Returns:
+            Optional[WecomEvent]: 如果事件数据合法，则返回 WecomEvent 对象；否则返回 None。
+        """
+        try:
+            event = WecomEvent(payload)
+            _ = event.type, event.detail_type  # 确保必须字段存在
+            return event
+        except KeyError:
+            return None
+
+    @property
+    def type(self) -> str:
+        """
+        事件类型，例如 "message"、"event"、"text" 等。
+
+        Returns:
+            str: 事件类型。
+        """
+        return self.get("MsgType", "")
+    
+    @property
+    def picurl(self) -> str:
+        """
+        图片链接
+        """
+        return self.get("PicUrl")
+
+    @property
+    def detail_type(self) -> str:
+        """
+        事件详细类型，依 `type` 的不同而不同。例如：
+        - 消息事件: "text", "image", "voice", 等
+        - 事件通知: "subscribe", "unsubscribe", "click", 等
+
+        Returns:
+            str: 事件详细类型。
+        """
+        if self.type == "event":
+            return self.get("Event", "")
+        return self.type
+
+    @property
+    def name(self) -> str:
+        """
+        事件名，对于消息事件是 `type.detail_type`，对于其他事件是 `event_type`。
+
+        Returns:
+            str: 事件名。
+        """
+        return f"{self.type}.{self.detail_type}"
+
+    @property
+    def user_id(self) -> Optional[str]:
+        """
+        用户 ID，例如消息的发送者或事件的触发者。
+
+        Returns:
+            Optional[str]: 用户 ID。
+        """
+        return self.get("FromUserName")
+    
+    @property
+    def agent_id(self) -> Optional[int]:
+        """
+        机器人 ID，仅在消息类型事件中存在。
+
+        Returns:
+            Optional[int]: 机器人 ID。
+        """
+        return self.get("AgentID")
+
+    @property
+    def receiver_id(self) -> Optional[str]:
+        """
+        接收者 ID，例如机器人自身的企业微信 ID。
+
+        Returns:
+            Optional[str]: 接收者 ID。
+        """
+        return self.get("ToUserName")
+
+    @property
+    def message_id(self) -> Optional[str]:
+        """
+        消息 ID，仅在消息类型事件中存在。
+
+        Returns:
+            Optional[str]: 消息 ID。
+        """
+        return self.get("MsgId")
+
+    @property
+    def message(self) -> Optional[str]:
+        """
+        消息内容，仅在消息类型事件中存在。
+
+        Returns:
+            Optional[str]: 消息内容。
+        """
+        return self.get("Content")
+
+    @property
+    def media_id(self) -> Optional[str]:
+        """
+        媒体文件 ID，仅在图片、语音等消息类型中存在。
+
+        Returns:
+            Optional[str]: 媒体文件 ID。
+        """
+        return self.get("MediaId")
+
+    @property
+    def timestamp(self) -> Optional[int]:
+        """
+        事件发生的时间戳。
+
+        Returns:
+            Optional[int]: 时间戳。
+        """
+        return self.get("CreateTime")
+
+    @property
+    def event_key(self) -> Optional[str]:
+        """
+        事件的 Key 值，例如点击菜单时的 `EventKey`。
+
+        Returns:
+            Optional[str]: 事件 Key。
+        """
+        return self.get("EventKey")
+
+    def __getattr__(self, key: str) -> Optional[Any]:
+        """
+        允许通过属性访问数据中的任意字段。
+
+        Args:
+            key (str): 字段名。
+
+        Returns:
+            Optional[Any]: 字段值。
+        """
+        return self.get(key)
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        """
+        允许通过属性设置数据中的任意字段。
+
+        Args:
+            key (str): 字段名。
+            value (Any): 字段值。
+        """
+        self[key] = value
+
+    def __repr__(self) -> str:
+        """
+        生成事件对象的字符串表示。
+
+        Returns:
+            str: 字符串表示。
+        """
+        return f"<WecomEvent {super().__repr__()}>"

pkg/core/bootutils/deps.py

@@ -1,5 +1,7 @@
 import pip
 
+# 检查依赖，防止用户未安装
+# 左边为引入名称，右边为依赖名称
 required_deps = {
     "requests": "requests",
     "openai": "openai",
@@ -23,6 +25,9 @@ required_deps = {
     "aioshutil": "aioshutil",
     "argon2": "argon2-cffi",
     "jwt": "pyjwt",
+    "Crypto": "pycryptodome",
+    "lark_oapi": "lark-oapi",
+    "discord": "discord.py"
 }
 
 

pkg/core/entities.py

@@ -45,10 +45,10 @@ class Query(pydantic.BaseModel):
     launcher_type: LauncherTypes
     """会话类型，platform处理阶段设置"""
 
-    launcher_id: int
+    launcher_id: typing.Union[int, str]
     """会话ID，platform处理阶段设置"""
 
-    sender_id: int
+    sender_id: typing.Union[int, str]
     """发送者ID，platform处理阶段设置"""
 
     message_event: platform_events.MessageEvent
@@ -114,9 +114,9 @@ class Session(pydantic.BaseModel):
     """会话，一个 Session 对应一个 {launcher_type.value}_{launcher_id}"""
     launcher_type: LauncherTypes
 
-    launcher_id: int
+    launcher_id: typing.Union[int, str]
 
-    sender_id: typing.Optional[int] = 0
+    sender_id: typing.Optional[typing.Union[int, str]] = 0
 
     use_prompt_name: typing.Optional[str] = 'default'
 

pkg/core/migrations/m020_wecom_config.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("wecom-config", 20)
+class WecomConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] == 'wecom':
+                return False
+
+        return True
+
+    async def run(self):
+        """执行迁移"""
+        self.ap.platform_cfg.data['platform-adapters'].append({
+            "adapter": "wecom",
+            "enable": False,
+            "host": "0.0.0.0",
+            "port": 2290,
+            "corpid": "",
+            "secret": "",
+            "token": "",
+            "EncodingAESKey": "",
+            "contacts_secret": ""
+        })
+
+        await self.ap.platform_cfg.dump_config()

pkg/core/migrations/m021_lark_config.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("lark-config", 21)
+class LarkConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] == 'lark':
+                return False
+
+        return True
+
+    async def run(self):
+        """执行迁移"""
+        self.ap.platform_cfg.data['platform-adapters'].append({
+            "adapter": "lark",
+            "enable": False,
+            "app_id": "cli_abcdefgh",
+            "app_secret": "XXXXXXXXXX",
+            "bot_name": "LangBot"
+        })
+
+        await self.ap.platform_cfg.dump_config()

pkg/core/migrations/m022_lmstudio_config.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("lmstudio-config", 22)
+class LmStudioConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        
+        return 'lmstudio-chat-completions' not in self.ap.provider_cfg.data['requester']
+
+    async def run(self):
+        """执行迁移"""
+        self.ap.provider_cfg.data['requester']['lmstudio-chat-completions'] = {
+            "base-url": "http://127.0.0.1:1234/v1",
+            "args": {},
+            "timeout": 120
+        }
+
+        await self.ap.provider_cfg.dump_config()

pkg/core/migrations/m023_siliconflow_config.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("siliconflow-config", 23)
+class SiliconFlowConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        
+        return 'siliconflow-chat-completions' not in self.ap.provider_cfg.data['requester']
+
+    async def run(self):
+        """执行迁移"""
+        self.ap.provider_cfg.data['keys']['siliconflow'] = [
+            "xxxxxxx"
+        ]
+
+        self.ap.provider_cfg.data['requester']['siliconflow-chat-completions'] = {
+            "base-url": "https://api.siliconflow.cn/v1",
+            "args": {},
+            "timeout": 120
+        }
+
+        await self.ap.provider_cfg.dump_config()

pkg/core/migrations/m024_discord_config.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("discord-config", 24)
+class DiscordConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] == 'discord':
+                return False
+
+        return True
+
+    async def run(self):
+        """执行迁移"""
+        self.ap.platform_cfg.data['platform-adapters'].append({
+            "adapter": "discord",
+            "enable": False,
+            "client_id": "1234567890",
+            "token": "XXXXXXXXXX"
+        })
+
+        await self.ap.platform_cfg.dump_config()

pkg/core/stages/migrate.py

@@ -8,6 +8,7 @@ from ..migrations import m001_sensitive_word_migration, m002_openai_config_migra
 from ..migrations import m005_deepseek_cfg_completion, m006_vision_config, m007_qcg_center_url, m008_ad_fixwin_config_migrate, m009_msg_truncator_cfg
 from ..migrations import m010_ollama_requester_config, m011_command_prefix_config, m012_runner_config, m013_http_api_config, m014_force_delay_config
 from ..migrations import m015_gitee_ai_config, m016_dify_service_api, m017_dify_api_timeout_params, m018_xai_config, m019_zhipuai_config
+from ..migrations import m020_wecom_config, m021_lark_config, m022_lmstudio_config, m023_siliconflow_config, m024_discord_config
 
 
 @stage.stage_class("MigrationStage")

pkg/pipeline/controller.py

@@ -68,7 +68,7 @@ class Controller:
         except Exception as e:
             # traceback.print_exc()
             self.ap.logger.error(f"控制器循环出错: {e}")
-            self.ap.logger.debug(f"Traceback: {traceback.format_exc()}")
+            self.ap.logger.error(f"Traceback: {traceback.format_exc()}")
 
     async def _check_output(self, query: entities.Query, result: pipeline_entities.StageProcessResult):
         """检查输出
@@ -163,29 +163,30 @@ class Controller:
     async def process_query(self, query: entities.Query):
         """处理请求
         """
-
-        # ======== 触发 MessageReceived 事件 ========
-        event_type = events.PersonMessageReceived if query.launcher_type == entities.LauncherTypes.PERSON else events.GroupMessageReceived
-
-        event_ctx = await self.ap.plugin_mgr.emit_event(
-            event=event_type(
-                launcher_type=query.launcher_type.value,
-                launcher_id=query.launcher_id,
-                sender_id=query.sender_id,
-                message_chain=query.message_chain,
-                query=query
-            )
-        )
-
-        if event_ctx.is_prevented_default():
-            return
-        
-        self.ap.logger.debug(f"Processing query {query}")
-
         try:
+
+            # ======== 触发 MessageReceived 事件 ========
+            event_type = events.PersonMessageReceived if query.launcher_type == entities.LauncherTypes.PERSON else events.GroupMessageReceived
+
+            event_ctx = await self.ap.plugin_mgr.emit_event(
+                event=event_type(
+                    launcher_type=query.launcher_type.value,
+                    launcher_id=query.launcher_id,
+                    sender_id=query.sender_id,
+                    message_chain=query.message_chain,
+                    query=query
+                )
+            )
+
+            if event_ctx.is_prevented_default():
+                return
+            
+            self.ap.logger.debug(f"Processing query {query}")
+
             await self._execute_from_stage(0, query)
         except Exception as e:
-            self.ap.logger.error(f"处理请求时出错 query_id={query.query_id} stage={query.current_stage.inst_name} : {e}")
+            inst_name = query.current_stage.inst_name if query.current_stage else 'unknown'
+            self.ap.logger.error(f"处理请求时出错 query_id={query.query_id} stage={inst_name} : {e}")
             self.ap.logger.debug(f"Traceback: {traceback.format_exc()}")
         finally:
             self.ap.logger.debug(f"Query {query} processed")

pkg/pipeline/pool.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import asyncio
-
+import typing
 
 from ..core import entities
 from ..platform import adapter as msadapter
@@ -29,8 +29,8 @@ class QueryPool:
     async def add_query(
         self,
         launcher_type: entities.LauncherTypes,
-        launcher_id: int,
-        sender_id: int,
+        launcher_id: typing.Union[int, str],
+        sender_id: typing.Union[int, str],
         message_event: platform_events.MessageEvent,
         message_chain: platform_message.MessageChain,
         adapter: msadapter.MessageSourceAdapter

pkg/pipeline/ratelimit/algo.py

@@ -31,7 +31,7 @@ class ReteLimitAlgo(metaclass=abc.ABCMeta):
         pass
 
     @abc.abstractmethod
-    async def require_access(self, launcher_type: str, launcher_id: int) -> bool:
+    async def require_access(self, launcher_type: str, launcher_id: typing.Union[int, str]) -> bool:
         """进入处理流程
 
         这个方法对等待是友好的，意味着算法可以实现在这里等待一段时间以控制速率。
@@ -46,7 +46,7 @@ class ReteLimitAlgo(metaclass=abc.ABCMeta):
         raise NotImplementedError
     
     @abc.abstractmethod
-    async def release_access(self, launcher_type: str, launcher_id: int):
+    async def release_access(self, launcher_type: str, launcher_id: typing.Union[int, str]):
         """退出处理流程
 
         Args:

pkg/pipeline/ratelimit/algos/fixedwin.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 import asyncio
 import time
+import typing
 from .. import algo
 
 # 固定窗口算法
@@ -29,7 +30,7 @@ class FixedWindowAlgo(algo.ReteLimitAlgo):
         self.containers_lock = asyncio.Lock()
         self.containers = {}
 
-    async def require_access(self, launcher_type: str, launcher_id: int) -> bool:
+    async def require_access(self, launcher_type: str, launcher_id: typing.Union[int, str]) -> bool:
         # 加锁，找容器
         container: SessionContainer = None
 
@@ -83,5 +84,5 @@ class FixedWindowAlgo(algo.ReteLimitAlgo):
             # 返回True
             return True
         
-    async def release_access(self, launcher_type: str, launcher_id: int):
+    async def release_access(self, launcher_type: str, launcher_id: typing.Union[int, str]):
         pass

pkg/platform/adapter.py

@@ -52,7 +52,7 @@ class MessageSourceAdapter(metaclass=abc.ABCMeta):
         self.config = config
         self.ap = ap
 
-    async def send_message(
+    async def send_message(  
         self,
         target_type: str,
         target_id: str,

pkg/platform/manager.py

@@ -37,7 +37,7 @@ class PlatformManager:
     
     async def initialize(self):
 
-        from .sources import nakuru, aiocqhttp, qqbotpy
+        from .sources import nakuru, aiocqhttp, qqbotpy, wecom, lark, discord
 
         async def on_friend_message(event: platform_events.FriendMessage, adapter: msadapter.MessageSourceAdapter):
 

pkg/platform/sources/discord.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+import discord
+
+import typing
+import asyncio
+import traceback
+import time
+import re
+import base64
+import uuid
+import json
+import os
+import datetime
+
+import aiohttp
+
+from .. import adapter
+from ...pipeline.longtext.strategies import forward
+from ...core import app
+from ..types import message as platform_message
+from ..types import events as platform_events
+from ..types import entities as platform_entities
+from ...utils import image
+
+
+class DiscordMessageConverter(adapter.MessageConverter):
+
+    @staticmethod
+    async def yiri2target(
+        message_chain: platform_message.MessageChain
+    ) -> typing.Tuple[str, typing.List[discord.File]]:
+        for ele in message_chain:
+            if isinstance(ele, platform_message.At):
+                message_chain.remove(ele)
+                break
+
+        text_string = ""
+        image_files = []
+
+        for ele in message_chain:
+            if isinstance(ele, platform_message.Image):
+                image_bytes = None
+
+                if ele.base64:
+                    image_bytes = base64.b64decode(ele.base64)
+                elif ele.url:
+                    async with aiohttp.ClientSession() as session:
+                        async with session.get(ele.url) as response:
+                            image_bytes = await response.read()
+                elif ele.path:
+                    with open(ele.path, "rb") as f:
+                        image_bytes = f.read()
+
+                image_files.append(discord.File(fp=image_bytes, filename=f"{uuid.uuid4()}.png"))
+            elif isinstance(ele, platform_message.Plain):
+                text_string += ele.text
+
+        return text_string, image_files
+
+    @staticmethod
+    async def target2yiri(
+        message: discord.Message
+    ) -> platform_message.MessageChain:
+        lb_msg_list = []
+
+        msg_create_time = datetime.datetime.fromtimestamp(
+            int(message.created_at.timestamp())
+        )
+
+        lb_msg_list.append(
+            platform_message.Source(id=message.id, time=msg_create_time)
+        )
+
+        element_list = []
+
+        def text_element_recur(text_ele: str) -> list[platform_message.MessageComponent]:
+            if text_ele == "":
+                return []
+
+            # <@1234567890>
+            # @everyone
+            # @here
+            at_pattern = re.compile(r"(@everyone|@here|<@[\d]+>)")
+            at_matches = at_pattern.findall(text_ele)
+            
+            if len(at_matches) > 0:
+                mid_at = at_matches[0]
+
+                text_split = text_ele.split(mid_at)
+
+                mid_at_component = []
+
+                if mid_at == "@everyone" or mid_at == "@here":
+                    mid_at_component.append(platform_message.AtAll())
+                else:
+                    mid_at_component.append(platform_message.At(target=mid_at[2:-1]))
+
+                return text_element_recur(text_split[0]) + \
+                    mid_at_component + \
+                    text_element_recur(text_split[1])
+            else:
+                return [platform_message.Plain(text=text_ele)]
+
+        
+        element_list.extend(text_element_recur(message.content))
+
+        # attachments
+        for attachment in message.attachments:
+            async with aiohttp.ClientSession(trust_env=True) as session:
+                async with session.get(attachment.url) as response:
+                    image_data = await response.read()
+                    image_base64 = base64.b64encode(image_data).decode("utf-8")
+                    image_format = response.headers["Content-Type"]
+                    element_list.append(platform_message.Image(base64=f"data:{image_format};base64,{image_base64}"))
+
+        return platform_message.MessageChain(element_list)
+
+
+class DiscordEventConverter(adapter.EventConverter):
+
+    @staticmethod
+    async def yiri2target(
+        event: platform_events.Event
+    ) -> discord.Message:
+        pass
+
+    @staticmethod
+    async def target2yiri(
+        event: discord.Message
+    ) -> platform_events.Event:
+        message_chain = await DiscordMessageConverter.target2yiri(event)
+
+        if type(event.channel) == discord.DMChannel:
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id=event.author.id,
+                    nickname=event.author.name,
+                    remark=event.channel.id,
+                ),
+                message_chain=message_chain,
+                time=event.created_at.timestamp(),
+                source_platform_object=event,
+            )
+        elif type(event.channel) == discord.TextChannel:
+            return platform_events.GroupMessage(
+                sender=platform_entities.GroupMember(
+                    id=event.author.id,
+                    member_name=event.author.name,
+                    permission=platform_entities.Permission.Member,
+                    group=platform_entities.Group(
+                        id=event.channel.id,
+                        name=event.channel.name,
+                        permission=platform_entities.Permission.Member,
+                    ),
+                    special_title="",
+                    join_timestamp=0,
+                    last_speak_timestamp=0,
+                    mute_time_remaining=0,
+                ),
+                message_chain=message_chain,
+                time=event.created_at.timestamp(),
+                source_platform_object=event,
+            )
+
+@adapter.adapter_class("discord")
+class DiscordMessageSourceAdapter(adapter.MessageSourceAdapter):
+
+    bot: discord.Client
+
+    bot_account_id: str  # 用于在流水线中识别at是否是本bot，直接以bot_name作为标识
+
+    config: dict
+
+    ap: app.Application
+
+    message_converter: DiscordMessageConverter = DiscordMessageConverter()
+    event_converter: DiscordEventConverter = DiscordEventConverter()
+
+    listeners: typing.Dict[
+        typing.Type[platform_events.Event],
+        typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None],
+    ] = {}
+
+    def __init__(self, config: dict, ap: app.Application):
+        self.config = config
+        self.ap = ap
+
+        self.bot_account_id = self.config["client_id"]
+
+        adapter_self = self
+
+        class MyClient(discord.Client):
+
+            async def on_message(self: discord.Client, message: discord.Message):
+                if message.author.id == self.user.id or message.author.bot:
+                    return
+
+                lb_event = await adapter_self.event_converter.target2yiri(message)
+                await adapter_self.listeners[type(lb_event)](lb_event, adapter_self)
+
+        intents = discord.Intents.default()
+        intents.message_content = True
+
+        args = {}
+
+        if os.getenv("http_proxy"):
+            args["proxy"] = os.getenv("http_proxy")
+
+        self.bot = MyClient(intents=intents, **args)
+        
+    async def send_message(
+        self, target_type: str, target_id: str, message: platform_message.MessageChain
+    ):
+        pass
+
+    async def reply_message(
+        self,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
+        quote_origin: bool = False,
+    ):
+        msg_to_send, image_files = await self.message_converter.yiri2target(message)
+        assert isinstance(message_source.source_platform_object, discord.Message)
+
+        args = {
+            "content": msg_to_send,
+        }
+
+        if len(image_files) > 0:
+            args["files"] = image_files
+
+        if quote_origin:
+            args["reference"] = message_source.source_platform_object
+
+        if message.has(platform_message.At):
+            args["mention_author"] = True
+
+        await message_source.source_platform_object.channel.send(**args)
+
+    async def is_muted(self, group_id: int) -> bool:
+        return False
+
+    def register_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None],
+    ):
+        self.listeners[event_type] = callback
+
+    def unregister_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None],
+    ):
+        self.listeners.pop(event_type)
+
+    async def run_async(self):
+        async with self.bot:
+            await self.bot.start(self.config["token"], reconnect=True)
+
+    async def kill(self) -> bool:
+        await self.bot.close()
+        return True

pkg/platform/sources/lark.py

@@ -0,0 +1,404 @@
+from __future__ import annotations
+
+import lark_oapi
+
+import typing
+import asyncio
+import traceback
+import time
+import re
+import base64
+import uuid
+import json
+import datetime
+
+import aiohttp
+import lark_oapi.ws.exception
+from lark_oapi.api.im.v1 import *
+
+from .. import adapter
+from ...pipeline.longtext.strategies import forward
+from ...core import app
+from ..types import message as platform_message
+from ..types import events as platform_events
+from ..types import entities as platform_entities
+from ...utils import image
+
+
+class LarkMessageConverter(adapter.MessageConverter):
+
+    @staticmethod
+    async def yiri2target(
+        message_chain: platform_message.MessageChain, api_client: lark_oapi.Client
+    ) -> typing.Tuple[list]:
+        message_elements = []
+
+        pending_paragraph = []
+
+        for msg in message_chain:
+            if isinstance(msg, platform_message.Plain):
+                pending_paragraph.append({"tag": "md", "text": msg.text})
+            elif isinstance(msg, platform_message.At):
+                pending_paragraph.append(
+                    {"tag": "at", "user_id": msg.target, "style": []}
+                )
+            elif isinstance(msg, platform_message.AtAll):
+                pending_paragraph.append({"tag": "at", "user_id": "all", "style": []})
+            elif isinstance(msg, platform_message.Image):
+
+                image_bytes = None
+
+                if msg.base64:
+                    image_bytes = base64.b64decode(msg.base64)
+                elif msg.url:
+                    async with aiohttp.ClientSession() as session:
+                        async with session.get(msg.url) as response:
+                            image_bytes = await response.read()
+                elif msg.path:
+                    with open(msg.path, "rb") as f:
+                        image_bytes = f.read()
+
+                request: CreateImageRequest = (
+                    CreateImageRequest.builder()
+                    .request_body(
+                        CreateImageRequestBody.builder()
+                        .image_type("message")
+                        .image(image_bytes)
+                        .build()
+                    )
+                    .build()
+                )
+
+                response: CreateImageResponse = await api_client.im.v1.image.acreate(
+                    request
+                )
+
+                if not response.success():
+                    raise Exception(
+                        f"client.im.v1.image.create failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}, resp: \n{json.dumps(json.loads(response.raw.content), indent=4, ensure_ascii=False)}"
+                    )
+
+                image_key = response.data.image_key
+
+                message_elements.append(pending_paragraph)
+                message_elements.append(
+                    [
+                        {
+                            "tag": "img",
+                            "image_key": image_key,
+                        }
+                    ]
+                )
+                pending_paragraph = []
+
+        if pending_paragraph:
+            message_elements.append(pending_paragraph)
+
+        return message_elements
+
+    @staticmethod
+    async def target2yiri(
+        message: lark_oapi.api.im.v1.model.event_message.EventMessage,
+        api_client: lark_oapi.Client,
+    ) -> platform_message.MessageChain:
+        message_content = json.loads(message.content)
+
+        lb_msg_list = []
+
+        msg_create_time = datetime.datetime.fromtimestamp(
+            int(message.create_time) / 1000
+        )
+
+        lb_msg_list.append(
+            platform_message.Source(id=message.message_id, time=msg_create_time)
+        )
+
+        if message.message_type == "text":
+            element_list = []
+
+            def text_element_recur(text_ele: dict) -> list[dict]:
+                if text_ele["text"] == "":
+                    return []
+
+                at_pattern = re.compile(r"@_user_[\d]+")
+                at_matches = at_pattern.findall(text_ele["text"])
+
+                name_mapping = {}
+                for mathc in at_matches:
+                    for mention in message.mentions:
+                        if mention.key == mathc:
+                            name_mapping[mathc] = mention.name
+                            break
+
+                if len(name_mapping.keys()) == 0:
+                    return [text_ele]
+
+                # 只处理第一个，剩下的递归处理
+                text_split = text_ele["text"].split(list(name_mapping.keys())[0])
+
+                new_list = []
+
+                left_text = text_split[0]
+                right_text = text_split[1]
+
+                new_list.extend(
+                    text_element_recur({"tag": "text", "text": left_text, "style": []})
+                )
+
+                new_list.append(
+                    {
+                        "tag": "at",
+                        "user_id": list(name_mapping.keys())[0],
+                        "user_name": name_mapping[list(name_mapping.keys())[0]],
+                        "style": [],
+                    }
+                )
+
+                new_list.extend(
+                    text_element_recur({"tag": "text", "text": right_text, "style": []})
+                )
+
+                return new_list
+
+            element_list = text_element_recur(
+                {"tag": "text", "text": message_content["text"], "style": []}
+            )
+
+            message_content = {"title": "", "content": element_list}
+
+        elif message.message_type == "post":
+            new_list = []
+
+            for ele in message_content["content"]:
+                if type(ele) is dict:
+                    new_list.append(ele)
+                elif type(ele) is list:
+                    new_list.extend(ele)
+
+            message_content["content"] = new_list
+        elif message.message_type == "image":
+            message_content["content"] = [
+                {"tag": "img", "image_key": message_content["image_key"], "style": []}
+            ]
+
+        for ele in message_content["content"]:
+            if ele["tag"] == "text":
+                lb_msg_list.append(platform_message.Plain(text=ele["text"]))
+            elif ele["tag"] == "at":
+                lb_msg_list.append(platform_message.At(target=ele["user_name"]))
+            elif ele["tag"] == "img":
+                image_key = ele["image_key"]
+
+                request: GetMessageResourceRequest = (
+                    GetMessageResourceRequest.builder()
+                    .message_id(message.message_id)
+                    .file_key(image_key)
+                    .type("image")
+                    .build()
+                )
+
+                response: GetMessageResourceResponse = (
+                    await api_client.im.v1.message_resource.aget(request)
+                )
+
+                if not response.success():
+                    raise Exception(
+                        f"client.im.v1.message_resource.get failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}, resp: \n{json.dumps(json.loads(response.raw.content), indent=4, ensure_ascii=False)}"
+                    )
+
+                image_bytes = response.file.read()
+                image_base64 = base64.b64encode(image_bytes).decode()
+
+                image_format = response.raw.headers["content-type"]
+
+                lb_msg_list.append(
+                    platform_message.Image(
+                        base64=f"data:{image_format};base64,{image_base64}"
+                    )
+                )
+
+        return platform_message.MessageChain(lb_msg_list)
+
+
+class LarkEventConverter(adapter.EventConverter):
+
+    @staticmethod
+    async def yiri2target(
+        event: platform_events.MessageEvent,
+    ) -> lark_oapi.im.v1.P2ImMessageReceiveV1:
+        pass
+
+    @staticmethod
+    async def target2yiri(
+        event: lark_oapi.im.v1.P2ImMessageReceiveV1, api_client: lark_oapi.Client
+    ) -> platform_events.Event:
+        message_chain = await LarkMessageConverter.target2yiri(
+            event.event.message, api_client
+        )
+
+        if event.event.message.chat_type == "p2p":
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id=event.event.sender.sender_id.open_id,
+                    nickname=event.event.sender.sender_id.union_id,
+                    remark="",
+                ),
+                message_chain=message_chain,
+                time=event.event.message.create_time,
+            )
+        elif event.event.message.chat_type == "group":
+            return platform_events.GroupMessage(
+                sender=platform_entities.GroupMember(
+                    id=event.event.sender.sender_id.open_id,
+                    member_name=event.event.sender.sender_id.union_id,
+                    permission=platform_entities.Permission.Member,
+                    group=platform_entities.Group(
+                        id=event.event.message.chat_id,
+                        name="",
+                        permission=platform_entities.Permission.Member,
+                    ),
+                    special_title="",
+                    join_timestamp=0,
+                    last_speak_timestamp=0,
+                    mute_time_remaining=0,
+                ),
+                message_chain=message_chain,
+                time=event.event.message.create_time,
+            )
+
+
+@adapter.adapter_class("lark")
+class LarkMessageSourceAdapter(adapter.MessageSourceAdapter):
+
+    bot: lark_oapi.ws.Client
+    api_client: lark_oapi.Client
+
+    bot_account_id: str  # 用于在流水线中识别at是否是本bot，直接以bot_name作为标识
+    lark_tenant_key: str  # 飞书企业key
+
+    message_converter: LarkMessageConverter = LarkMessageConverter()
+    event_converter: LarkEventConverter = LarkEventConverter()
+
+    listeners: typing.Dict[
+        typing.Type[platform_events.Event],
+        typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None],
+    ] = {}
+
+    config: dict
+
+    ap: app.Application
+
+    def __init__(self, config: dict, ap: app.Application):
+        self.config = config
+        self.ap = ap
+
+        async def on_message(event: lark_oapi.im.v1.P2ImMessageReceiveV1):
+
+            lb_event = await self.event_converter.target2yiri(event, self.api_client)
+
+            await self.listeners[type(lb_event)](lb_event, self)
+
+        def sync_on_message(event: lark_oapi.im.v1.P2ImMessageReceiveV1):
+            asyncio.create_task(on_message(event))
+
+        event_handler = (
+            lark_oapi.EventDispatcherHandler.builder("", "")
+            .register_p2_im_message_receive_v1(sync_on_message)
+            .build()
+        )
+
+        self.bot_account_id = config["bot_name"]
+
+        self.bot = lark_oapi.ws.Client(
+            config["app_id"], config["app_secret"], event_handler=event_handler
+        )
+        self.api_client = (
+            lark_oapi.Client.builder()
+            .app_id(config["app_id"])
+            .app_secret(config["app_secret"])
+            .build()
+        )
+
+    async def send_message(
+        self, target_type: str, target_id: str, message: platform_message.MessageChain
+    ):
+        pass
+
+    async def reply_message(
+        self,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
+        quote_origin: bool = False,
+    ):
+
+        # 不再需要了，因为message_id已经被包含到message_chain中
+        # lark_event = await self.event_converter.yiri2target(message_source)
+        lark_message = await self.message_converter.yiri2target(
+            message, self.api_client
+        )
+
+        final_content = {
+            "zh_cn": {
+                "title": "",
+                "content": lark_message,
+            },
+        }
+
+        request: ReplyMessageRequest = (
+            ReplyMessageRequest.builder()
+            .message_id(message_source.message_chain.message_id)
+            .request_body(
+                ReplyMessageRequestBody.builder()
+                .content(json.dumps(final_content))
+                .msg_type("post")
+                .reply_in_thread(False)
+                .uuid(str(uuid.uuid4()))
+                .build()
+            )
+            .build()
+        )
+
+        response: ReplyMessageResponse = await self.api_client.im.v1.message.areply(
+            request
+        )
+
+        if not response.success():
+            raise Exception(
+                f"client.im.v1.message.reply failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}, resp: \n{json.dumps(json.loads(response.raw.content), indent=4, ensure_ascii=False)}"
+            )
+
+    async def is_muted(self, group_id: int) -> bool:
+        return False
+
+    def register_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[
+            [platform_events.Event, adapter.MessageSourceAdapter], None
+        ],
+    ):
+        self.listeners[event_type] = callback
+
+    def unregister_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[
+            [platform_events.Event, adapter.MessageSourceAdapter], None
+        ],
+    ):
+        self.listeners.pop(event_type)
+
+    async def run_async(self):
+        try:
+            await self.bot._connect()
+        except lark_oapi.ws.exception.ClientException as e:
+            raise e
+        except Exception as e:
+            await self.bot._disconnect()
+            if self.bot._auto_reconnect:
+                await self.bot._reconnect()
+            else:
+                raise e
+
+    async def kill(self) -> bool:
+        return False

pkg/platform/sources/wecom.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+import typing
+import asyncio
+import traceback
+import time
+import datetime
+
+import aiocqhttp
+import aiohttp
+from libs.wecom_api.api import WecomClient
+from pkg.platform.adapter import MessageSourceAdapter
+from pkg.platform.types import events as platform_events, message as platform_message
+from libs.wecom_api.wecomevent import WecomEvent
+from pkg.core import app
+from .. import adapter
+from ...pipeline.longtext.strategies import forward
+from ...core import app
+from ..types import message as platform_message
+from ..types import events as platform_events
+from ..types import entities as platform_entities
+from ...command.errors import ParamNotEnoughError
+from ...utils import image
+
+class WecomMessageConverter(adapter.MessageConverter):
+
+    @staticmethod
+    async def yiri2target(
+        message_chain: platform_message.MessageChain, bot: WecomClient
+    ):
+        content_list = []
+
+        [
+            {
+                "type": "text",
+                "content": "text",
+            },
+            {
+                "type": "image",
+                "media_id": "media_id",
+            }
+        ]
+
+        for msg in message_chain:
+            if type(msg) is platform_message.Plain:
+                content_list.append({
+                    "type": "text",
+                    "content": msg.text,
+                })
+            elif type(msg) is platform_message.Image:
+                content_list.append({
+                    "type": "image",
+                    "media_id": await bot.get_media_id(msg),
+                })
+            elif type(msg) is platform_message.Forward:
+                for node in msg.node_list:
+                    content_list.extend((await WecomMessageConverter.yiri2target(node.message_chain, bot)))
+            else:
+                content_list.append({
+                    "type": "text",
+                    "content": str(msg),
+                })
+
+        return content_list
+
+    @staticmethod
+    async def target2yiri(message: str, message_id: int = -1):
+        yiri_msg_list = []
+        yiri_msg_list.append(
+            platform_message.Source(id=message_id, time=datetime.datetime.now())
+        )
+
+        yiri_msg_list.append(platform_message.Plain(text=message))
+        chain = platform_message.MessageChain(yiri_msg_list)
+
+        return chain
+
+    @staticmethod
+    async def target2yiri_image(picurl: str, message_id: int = -1):
+        yiri_msg_list = []
+        yiri_msg_list.append(
+            platform_message.Source(id=message_id, time=datetime.datetime.now())
+        )
+        image_base64, image_format = await image.get_wecom_image_base64(pic_url=picurl)
+        yiri_msg_list.append(platform_message.Image(base64=f"data:image/{image_format};base64,{image_base64}"))
+        chain = platform_message.MessageChain(yiri_msg_list)
+
+        return chain
+
+
+class WecomEventConverter:
+
+    @staticmethod
+    async def yiri2target(
+        event: platform_events.Event, bot_account_id: int, bot: WecomClient
+    ) -> WecomEvent:
+        # only for extracting user information
+
+        if type(event) is platform_events.GroupMessage:
+            pass
+
+        if type(event) is platform_events.FriendMessage:
+
+            payload = {
+                "MsgType": "text",
+                "Content": '',
+                "FromUserName": event.sender.id,
+                "ToUserName": bot_account_id,
+                "CreateTime": int(datetime.datetime.now().timestamp()),
+                "AgentID": event.sender.nickname,
+            }
+            wecom_event = WecomEvent.from_payload(payload=payload)
+            if not wecom_event:
+                raise ValueError("无法从 message_data 构造 WecomEvent 对象")
+
+            return wecom_event
+
+    @staticmethod
+    async def target2yiri(event: WecomEvent):
+        """
+        将 WecomEvent 转换为平台的 FriendMessage 对象。
+
+        Args:
+            event (WecomEvent): 企业微信事件。
+
+        Returns:
+            platform_events.FriendMessage: 转换后的 FriendMessage 对象。
+        """
+        # 转换消息链
+        if event.type == "text":
+            yiri_chain = await WecomMessageConverter.target2yiri(
+                event.message, event.message_id
+            )
+
+            friend = platform_entities.Friend(
+                id=event.user_id,
+                nickname=str(event.agent_id),
+                remark="",
+            )
+
+            return platform_events.FriendMessage(
+                sender=friend, message_chain=yiri_chain, time=event.timestamp
+            )
+        elif event.type == "image":
+            friend = platform_entities.Friend(
+                id=event.user_id,
+                nickname=str(event.agent_id),
+                remark="",
+            )
+
+            yiri_chain = await WecomMessageConverter.target2yiri_image(
+                picurl=event.picurl, message_id=event.message_id
+            )
+
+            return platform_events.FriendMessage(
+                sender=friend, message_chain=yiri_chain, time=event.timestamp
+            )
+
+
+@adapter.adapter_class("wecom")
+class WecomeAdapter(adapter.MessageSourceAdapter):
+
+    bot: WecomClient
+    ap: app.Application
+    bot_account_id: str
+    message_converter: WecomMessageConverter = WecomMessageConverter()
+    event_converter: WecomEventConverter = WecomEventConverter()
+    config: dict
+    ap: app.Application
+
+    def __init__(self, config: dict, ap: app.Application):
+        self.config = config
+
+        self.ap = ap
+
+        required_keys = [
+            "corpid",
+            "secret",
+            "token",
+            "EncodingAESKey",
+            "contacts_secret",
+        ]
+        missing_keys = [key for key in required_keys if key not in config]
+        if missing_keys:
+            raise ParamNotEnoughError("企业微信缺少相关配置项，请查看文档或联系管理员")
+
+        self.bot = WecomClient(
+            corpid=config["corpid"],
+            secret=config["secret"],
+            token=config["token"],
+            EncodingAESKey=config["EncodingAESKey"],
+            contacts_secret=config["contacts_secret"],
+        )
+
+    async def reply_message(
+        self,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
+        quote_origin: bool = False,
+    ):
+
+        Wecom_event = await WecomEventConverter.yiri2target(
+            message_source, self.bot_account_id, self.bot
+        )
+        content_list = await WecomMessageConverter.yiri2target(message, self.bot)
+
+        for content in content_list:
+            if content["type"] == "text":
+                await self.bot.send_private_msg(Wecom_event.user_id, Wecom_event.agent_id, content["content"])
+            elif content["type"] == "image":
+                await self.bot.send_image(Wecom_event.user_id, Wecom_event.agent_id, content["media_id"])
+
+    async def send_message(
+        self, target_type: str, target_id: str, message: platform_message.MessageChain
+    ):
+        pass
+
+    def register_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[
+            [platform_events.Event, adapter.MessageSourceAdapter], None
+        ],
+    ):
+        async def on_message(event: WecomEvent):
+            self.bot_account_id = event.receiver_id
+            try:
+                return await callback(
+                    await self.event_converter.target2yiri(event), self
+                )
+            except:
+                traceback.print_exc()
+
+        if event_type == platform_events.FriendMessage:
+            self.bot.on_message("text")(on_message)
+            self.bot.on_message("image")(on_message)
+        elif event_type == platform_events.GroupMessage:
+            pass
+
+    async def run_async(self):
+        async def shutdown_trigger_placeholder():
+            while True:
+                await asyncio.sleep(1)
+
+        await self.bot.run_task(
+            host=self.config["host"],
+            port=self.config["port"],
+            shutdown_trigger=shutdown_trigger_placeholder,
+        )
+
+    async def kill(self) -> bool:
+        return False
+
+    async def unregister_listener(
+        self,
+        event_type: type,
+        callback: typing.Callable[[platform_events.Event, MessageSourceAdapter], None],
+    ):
+        return super().unregister_listener(event_type, callback)

pkg/platform/types/entities.py

@@ -25,7 +25,7 @@ class Entity(pydantic.BaseModel):
 
 class Friend(Entity):
     """好友。"""
-    id: int
+    id: typing.Union[int, str]
     """QQ 号。"""
     nickname: typing.Optional[str]
     """昵称。"""
@@ -52,7 +52,7 @@ class Permission(str, Enum):
 
 class Group(Entity):
     """群。"""
-    id: int
+    id: typing.Union[int, str]
     """群号。"""
     name: str
     """群名称。"""
@@ -67,7 +67,7 @@ class Group(Entity):
 
 class GroupMember(Entity):
     """群成员。"""
-    id: int
+    id: typing.Union[int, str]
     """QQ 号。"""
     member_name: str
     """群成员名称。"""
@@ -92,7 +92,7 @@ class GroupMember(Entity):
 
 class Client(Entity):
     """来自其他客户端的用户。"""
-    id: int
+    id: typing.Union[int, str]
     """识别 id。"""
     platform: str
     """来源平台。"""
@@ -105,7 +105,7 @@ class Client(Entity):
 
 class Subject(pydantic.BaseModel):
     """另一种实体类型表示。"""
-    id: int
+    id: typing.Union[int, str]
     """QQ 号或群号。"""
     kind: typing.Literal['Friend', 'Group', 'Stranger']
     """类型。"""

pkg/platform/types/events.py

@@ -72,6 +72,11 @@ class MessageEvent(Event):
     message_chain: platform_message.MessageChain
     """消息内容。"""
 
+    source_platform_object: typing.Optional[typing.Any] = None
+    """原消息平台对象。
+    供消息平台适配器开发者使用，如果回复用户时需要使用原消息事件对象的信息，
+    那么可以将其存到这个字段以供之后取出使用。"""
+
 
 class FriendMessage(MessageEvent):
     """好友消息。

pkg/platform/types/message.py

@@ -460,7 +460,7 @@ class Source(MessageComponent):
     """源。包含消息的基本信息。"""
     type: str = "Source"
     """消息组件类型。"""
-    id: int
+    id: typing.Union[int, str]
     """消息的识别号，用于引用回复（Source 类型永远为 MessageChain 的第一个元素）。"""
     time: datetime
     """消息时间。"""
@@ -485,11 +485,11 @@ class Quote(MessageComponent):
     """消息组件类型。"""
     id: typing.Optional[int] = None
     """被引用回复的原消息的 message_id。"""
-    group_id: typing.Optional[int] = None
+    group_id: typing.Optional[typing.Union[int, str]] = None
     """被引用回复的原消息所接收的群号，当为好友消息时为0。"""
-    sender_id: typing.Optional[int] = None
+    sender_id: typing.Optional[typing.Union[int, str]] = None
     """被引用回复的原消息的发送者的QQ号。"""
-    target_id: typing.Optional[int] = None
+    target_id: typing.Optional[typing.Union[int, str]] = None
     """被引用回复的原消息的接收者者的QQ号（或群号）。"""
     origin: MessageChain
     """被引用回复的原消息的消息链对象。"""
@@ -503,7 +503,7 @@ class At(MessageComponent):
     """At某人。"""
     type: str = "At"
     """消息组件类型。"""
-    target: int
+    target: typing.Union[int, str]
     """群员 QQ 号。"""
     display: typing.Optional[str] = None
     """At时显示的文字，发送消息时无效，自动使用群名片。"""
@@ -749,7 +749,7 @@ class Voice(MessageComponent):
 
 class ForwardMessageNode(pydantic.BaseModel):
     """合并转发中的一条消息。"""
-    sender_id: typing.Optional[int] = None
+    sender_id: typing.Optional[typing.Union[int, str]] = None
     """发送人QQ号。"""
     sender_name: typing.Optional[str] = None
     """显示名称。"""

pkg/plugin/events.py

@@ -25,10 +25,10 @@ class PersonMessageReceived(BaseEventModel):
     launcher_type: str
     """发起对象类型(group/person)"""
 
-    launcher_id: int
+    launcher_id: typing.Union[int, str]
     """发起对象ID(群号/QQ号)"""
     
-    sender_id: int
+    sender_id: typing.Union[int, str]
     """发送者ID(QQ号)"""
 
     message_chain: platform_message.MessageChain
@@ -39,9 +39,9 @@ class GroupMessageReceived(BaseEventModel):
 
     launcher_type: str
 
-    launcher_id: int
+    launcher_id: typing.Union[int, str]
     
-    sender_id: int
+    sender_id: typing.Union[int, str]
 
     message_chain: platform_message.MessageChain
 
@@ -51,9 +51,9 @@ class PersonNormalMessageReceived(BaseEventModel):
 
     launcher_type: str
 
-    launcher_id: int
+    launcher_id: typing.Union[int, str]
     
-    sender_id: int
+    sender_id: typing.Union[int, str]
 
     text_message: str
 
@@ -69,9 +69,9 @@ class PersonCommandSent(BaseEventModel):
 
     launcher_type: str
 
-    launcher_id: int
+    launcher_id: typing.Union[int, str]
     
-    sender_id: int
+    sender_id: typing.Union[int, str]
 
     command: str
 
@@ -93,9 +93,9 @@ class GroupNormalMessageReceived(BaseEventModel):
 
     launcher_type: str
 
-    launcher_id: int
+    launcher_id: typing.Union[int, str]
     
-    sender_id: int
+    sender_id: typing.Union[int, str]
 
     text_message: str
 
@@ -111,9 +111,9 @@ class GroupCommandSent(BaseEventModel):
 
     launcher_type: str
 
-    launcher_id: int
+    launcher_id: typing.Union[int, str]
     
-    sender_id: int
+    sender_id: typing.Union[int, str]
 
     command: str
 
@@ -135,9 +135,9 @@ class NormalMessageResponded(BaseEventModel):
 
     launcher_type: str
 
-    launcher_id: int
+    launcher_id: typing.Union[int, str]
     
-    sender_id: int
+    sender_id: typing.Union[int, str]
 
     session: core_entities.Session
     """会话对象"""

pkg/provider/modelmgr/modelmgr.py

@@ -6,7 +6,7 @@ from . import entities, requester
 from ...core import app
 
 from . import token
-from .requesters import chatcmpl, anthropicmsgs, moonshotchatcmpl, deepseekchatcmpl, ollamachat, giteeaichatcmpl, xaichatcmpl, zhipuaichatcmpl
+from .requesters import chatcmpl, anthropicmsgs, moonshotchatcmpl, deepseekchatcmpl, ollamachat, giteeaichatcmpl, xaichatcmpl, zhipuaichatcmpl, lmstudiochatcmpl, siliconflowchatcmpl
 
 FETCH_MODEL_LIST_URL = "https://api.qchatgpt.rockchin.top/api/v2/fetch/model_list"
 
@@ -109,4 +109,4 @@ class ModelManager:
                 self.model_list.append(model_info)
             
             except Exception as e:
-                self.ap.logger.error(f"初始化模型 {model['name']} 失败: {e} ,请检查配置文件")
+                self.ap.logger.error(f"初始化模型 {model['name']} 失败: {type(e)} {e} ,请检查配置文件")

pkg/provider/modelmgr/requesters/anthropicmsgs.py

@@ -30,7 +30,7 @@ class AnthropicMessages(requester.LLMAPIRequester):
             timeout=typing.cast(httpx.Timeout, self.ap.provider_cfg.data['requester']['anthropic-messages']['timeout']),
             limits=anthropic._constants.DEFAULT_CONNECTION_LIMITS,
             follow_redirects=True,
-            proxies=self.ap.proxy_mgr.get_forward_proxies()
+            trust_env=True,
         )
 
         self.client = anthropic.AsyncAnthropic(

pkg/provider/modelmgr/requesters/chatcmpl.py

@@ -39,7 +39,7 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
             base_url=self.requester_cfg['base-url'],
             timeout=self.requester_cfg['timeout'],
             http_client=httpx.AsyncClient(
-                proxies=self.ap.proxy_mgr.get_forward_proxies()
+                trust_env=True,
             )
         )
 

pkg/provider/modelmgr/requesters/lmstudiochatcmpl.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import openai
+
+from . import chatcmpl
+from .. import requester
+from ....core import app
+
+
+@requester.requester_class("lmstudio-chat-completions")
+class LmStudioChatCompletions(chatcmpl.OpenAIChatCompletions):
+    """LMStudio ChatCompletion API 请求器"""
+
+    client: openai.AsyncClient
+
+    requester_cfg: dict
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+
+        self.requester_cfg = self.ap.provider_cfg.data['requester']['lmstudio-chat-completions']

pkg/provider/modelmgr/requesters/siliconflowchatcmpl.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import openai
+
+from . import chatcmpl
+from .. import requester
+from ....core import app
+
+
+@requester.requester_class("siliconflow-chat-completions")
+class SiliconFlowChatCompletions(chatcmpl.OpenAIChatCompletions):
+    """SiliconFlow ChatCompletion API 请求器"""
+
+    client: openai.AsyncClient
+
+    requester_cfg: dict
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+
+        self.requester_cfg = self.ap.provider_cfg.data['requester']['siliconflow-chat-completions']

pkg/utils/constants.py

@@ -1,4 +1,4 @@
-semantic_version = "v3.4.2.1"
+semantic_version = "v3.4.5.1"
 
 debug_mode = False
 

pkg/utils/image.py

@@ -7,6 +7,31 @@ import ssl
 import aiohttp
 import PIL.Image
 
+async def get_wecom_image_base64(pic_url: str) -> tuple[str, str]:
+    """
+    下载企业微信图片并转换为 base64
+    :param pic_url: 企业微信图片URL
+    :return: (base64_str, image_format)
+    """
+    async with aiohttp.ClientSession() as session:
+        async with session.get(pic_url) as response:
+            if response.status != 200:
+                raise Exception(f"Failed to download image: {response.status}")
+            
+            # 读取图片数据
+            image_data = await response.read()
+            
+            # 获取图片格式
+            content_type = response.headers.get('Content-Type', '')
+            image_format = content_type.split('/')[-1]  # 例如 'image/jpeg' -> 'jpeg'
+            
+            # 转换为 base64
+            import base64
+            image_base64 = base64.b64encode(image_data).decode('utf-8')
+            
+            return image_base64, image_format
+
+
 
 def get_qq_image_downloadable_url(image_url: str) -> tuple[str, dict]:
     """获取QQ图片的下载链接"""

requirements.txt

@@ -24,6 +24,9 @@ aiofiles
 aioshutil
 argon2-cffi
 pyjwt
+pycryptodome
+lark-oapi
+discord.py
 
 # indirect
 taskgroup==0.0.0a4

templates/metadata/llm-models.json

@@ -116,6 +116,11 @@
             "requester": "deepseek-chat-completions",
             "token_mgr": "deepseek"
         },
+        {
+            "name": "deepseek-reasoner",
+            "requester": "deepseek-chat-completions",
+            "token_mgr": "deepseek"
+        },
         {
             "name": "grok-2-latest",
             "requester": "xai-chat-completions",

templates/platform.json

@@ -24,6 +24,30 @@
                 "public_guild_messages",
                 "direct_message"
             ]
+        },
+        {
+            "adapter": "wecom",
+            "enable": false,
+            "host": "0.0.0.0",
+            "port": 2290,
+            "corpid": "",
+            "secret": "",
+            "token": "",
+            "EncodingAESKey": "",
+            "contacts_secret": ""
+        },
+        {
+            "adapter": "lark",
+            "enable": false,
+            "app_id": "cli_abcdefgh",
+            "app_secret": "XXXXXXXXXX",
+            "bot_name": "LangBot"
+        },
+        {
+            "adapter": "discord",
+            "enable": false,
+            "client_id": "1234567890",
+            "token": "XXXXXXXXXX"
         }
     ],
     "track-function-calls": true,

templates/provider.json

@@ -22,6 +22,9 @@
         ],
         "zhipuai": [
             "xxxxxxx"
+        ],
+        "siliconflow": [
+            "xxxxxxx"
         ]
     },
     "requester": {
@@ -66,6 +69,16 @@
             "base-url": "https://open.bigmodel.cn/api/paas/v4",
             "args": {},
             "timeout": 120
+        },
+        "lmstudio-chat-completions": {
+            "base-url": "http://127.0.0.1:1234/v1",
+            "args": {},
+            "timeout": 120
+        },
+        "siliconflow-chat-completions": {
+            "base-url": "https://api.siliconflow.cn/v1",
+            "args": {},
+            "timeout": 120
         }
     },
     "model": "gpt-4o",

templates/schema/platform.json

@@ -121,6 +121,129 @@
                                 ]
                             }
                         }
+                    },
+                    {
+                        "title": "企业微信适配器",
+                        "description": "用于接入企业微信",
+                        "properties": {
+                            "adapter": {
+                                "type": "string",
+                                "const": "wecom"
+                            },
+                            "enable": {
+                                "type": "boolean",
+                                "default": false,
+                                "description": "是否启用此适配器",
+                                "layout": {
+                                    "comp": "switch",
+                                    "props": {
+                                        "color": "primary"
+                                    }
+                                }
+                            },
+                            "host": {
+                                "type": "string",
+                                "default": "0.0.0.0",
+                                "description": "监听的IP地址"
+                            },
+                            "port": {
+                                "type": "integer",
+                                "default": 2290,
+                                "description": "监听的端口"
+                            },
+                            "corpid": {
+                                "type": "string",
+                                "default": "",
+                                "description": "企业微信的corpid"
+                            },
+                            "secret": {
+                                "type": "string",
+                                "default": "",
+                                "description": "企业微信的secret"
+                            },
+                            "token": {
+                                "type": "string",
+                                "default": "",
+                                "description": "企业微信的token"
+                            },
+                            "EncodingAESKey": {
+                                "type": "string",
+                                "default": "",
+                                "description": "企业微信的EncodingAESKey"
+                            },
+                            "contacts_secret": {
+                                "type": "string",
+                                "default": "",
+                                "description": "企业微信的contacts_secret"
+                            }
+                        }
+                    },
+                    {
+                        "title": "飞书适配器",
+                        "description": "用于接入飞书",
+                        "properties": {
+                            "adapter": {
+                                "type": "string",
+                                "const": "lark"
+                            },
+                            "enable": {
+                                "type": "boolean",
+                                "default": false,
+                                "description": "是否启用此适配器",
+                                "layout": {
+                                    "comp": "switch",
+                                    "props": {
+                                        "color": "primary"
+                                    }
+                                }
+                            },
+                            "app_id": {
+                                "type": "string",
+                                "default": "",
+                                "description": "飞书的app_id"
+                            },
+                            "app_secret": {
+                                "type": "string",
+                                "default": "",
+                                "description": "飞书的app_secret"
+                            },
+                            "bot_name": {
+                                "type": "string",
+                                "default": "",
+                                "description": "飞书的bot_name"
+                            }
+                        }
+                    },
+                    {
+                        "title": "Discord 适配器",
+                        "description": "用于接入 Discord",
+                        "properties": {
+                            "adapter": {
+                                "type": "string",
+                                "const": "discord"
+                            },
+                            "enable": {
+                                "type": "boolean",
+                                "default": false,
+                                "description": "是否启用此适配器",
+                                "layout": {
+                                    "comp": "switch",
+                                    "props": {
+                                        "color": "primary"
+                                    }
+                                }
+                            },
+                            "client_id": {
+                                "type": "string",
+                                "default": "",
+                                "description": "Discord 的 client_id"
+                            },
+                            "token": {
+                                "type": "string",
+                                "default": "",
+                                "description": "Discord 的 token"
+                            }
+                        }
                     }
                 ]
             }

templates/schema/provider.json

@@ -74,6 +74,14 @@
                         "type": "string"
                     },
                     "default": []
+                },
+                "siliconflow": {
+                    "type": "array",
+                    "title": "SiliconFlow API 密钥",
+                    "items": {
+                        "type": "string"
+                    },
+                    "default": []
                 }
             }
         },
@@ -172,7 +180,8 @@
                             "title": "API URL"
                         },
                         "args": {
-                            "type": "object"
+                            "type": "object",
+                            "default": {}
                         },
                         "timeout": {
                             "type": "number",
@@ -191,7 +200,8 @@
                             "title": "API URL"
                         },
                         "args": {
-                            "type": "object"
+                            "type": "object",
+                            "default": {}
                         },
                         "timeout": {
                             "type": "number",
@@ -210,7 +220,8 @@
                             "title": "API URL"
                         },
                         "args": {
-                            "type": "object"
+                            "type": "object",
+                            "default": {}
                         },
                         "timeout": {
                             "type": "number",
@@ -229,10 +240,52 @@
                             "title": "API URL"
                         },
                         "args": {
-                            "type": "object"
+                            "type": "object",
+                            "default": {}
                         },
                         "timeout": {
-                            "type": "number"
+                            "type": "number",
+                            "default": 120
+                        }
+                    }
+                },
+                "lmstudio-chat-completions": {
+                    "type": "object",
+                    "title": "LMStudio API 请求配置",
+                    "description": "仅可编辑 URL 和 超时时间，额外请求参数不支持可视化编辑，请到编辑器编辑",
+                    "properties": {
+                        "base-url": {
+                            "type": "string",
+                            "title": "API URL"
+                        },
+                        "args": {
+                            "type": "object",
+                            "default": {}
+                        },
+                        "timeout": {
+                            "type": "number",
+                            "title": "API 请求超时时间",
+                            "default": 120
+                        }
+                    }
+                },
+                "siliconflow-chat-completions": {
+                    "type": "object",
+                    "title": "SiliconFlow API 请求配置",
+                    "description": "仅可编辑 URL 和 超时时间，额外请求参数不支持可视化编辑，请到编辑器编辑",
+                    "properties": {
+                        "base-url": {
+                            "type": "string",
+                            "title": "API URL"
+                        },
+                        "args": {
+                            "type": "object",
+                            "default": {}
+                        },
+                        "timeout": {
+                            "type": "number",
+                            "title": "API 请求超时时间",
+                            "default": 120
                         }
                     }
                 }
@@ -292,7 +345,7 @@
                     "type": "string",
                     "title": "应用类型",
                     "description": "支持 chat 和 workflow，chat：聊天助手（含高级编排）和 Agent；workflow：工作流；请填写下方对应的应用类型 API 参数",
-                    "enum": ["chat", "workflow"],
+                    "enum": ["chat", "workflow", "agent"],
                     "default": "chat"
                 },
                 "chat": {