chore: release v3.4.14.3 (#1358)

* feat(gewechat): 重构target2yiri代码+引用消息展开

* feat(gewe): 引用消息，图片视频音频是单独的类型

.gitignore

@@ -38,5 +38,5 @@ botpy.log*
 /poc
 /libs/wecom_api/test.py
 /venv
-/jp-tyo-churros-05.rockchin.top
-test.py
+test.py
+/web_ui

README.md

@@ -8,7 +8,7 @@
 
 <a href="https://trendshift.io/repositories/12901" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12901" alt="RockChinQ%2FLangBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 
-<a href="https://docs.langbot.app">项目主页</a> ｜
+<a href="https://langbot.app">项目主页</a> ｜
 <a href="https://docs.langbot.app/insight/intro.html">功能介绍</a> ｜
 <a href="https://docs.langbot.app/insight/guide.html">部署文档</a> ｜
 <a href="https://docs.langbot.app/usage/faq.html">常见问题</a> ｜
@@ -87,6 +87,7 @@
 | QQ 个人号 | ✅ | QQ 个人号私聊、群聊 |
 | QQ 官方机器人 | ✅ | QQ 官方机器人，支持频道、私聊、群聊 |
 | 企业微信 | ✅ |  |
+| 企微对外客服 | ✅ |  |
 | 个人微信 | ✅ | 使用 [Gewechat](https://github.com/Devo919/Gewechat) 接入 |
 | 微信公众号 | ✅ |  |
 | 飞书 | ✅ |  |
@@ -109,6 +110,7 @@
 | [Anthropic](https://www.anthropic.com/) | ✅ |  |
 | [xAI](https://x.ai/) | ✅ |  |
 | [智谱AI](https://open.bigmodel.cn/) | ✅ |  |
+| [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | 大模型和 GPU 资源平台 |
 | [Dify](https://dify.ai) | ✅ | LLMOps 平台 |
 | [Ollama](https://ollama.com/) | ✅ | 本地大模型运行平台 |
 | [LMStudio](https://lmstudio.ai/) | ✅ | 本地大模型运行平台 |

README_EN.md

@@ -7,7 +7,7 @@
 
 <a href="https://trendshift.io/repositories/12901" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12901" alt="RockChinQ%2FLangBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 
-<a href="https://docs.langbot.app">Home</a> ｜
+<a href="https://langbot.app">Home</a> ｜
 <a href="https://docs.langbot.app/insight/intro.html">Features</a> ｜
 <a href="https://docs.langbot.app/insight/guide.html">Deployment</a> ｜
 <a href="https://docs.langbot.app/usage/faq.html">FAQ</a> ｜
@@ -45,6 +45,7 @@
 >
 > - Before you start deploying in any way, please read the [New User Guide](https://docs.langbot.app/insight/guide.html).  
 > - All documentation is in Chinese, we will provide i18n version in the near future.
+> - Read [the auto-generated wiki on DeepWiki](https://deepwiki.com/RockChinQ/LangBot).
 
 #### Docker Compose Deployment
 
@@ -85,6 +86,7 @@ Directly use the released version to run, see the [Manual Deployment](https://do
 | Personal QQ | ✅ |  |
 | QQ Official API | ✅ |  |
 | WeCom | ✅ |  |
+| WeComCS | ✅ |  |
 | Personal WeChat | ✅ | Use [Gewechat](https://github.com/Devo919/Gewechat) to access |
 | Lark | ✅ |  |
 | DingTalk | ✅ |  |
@@ -107,6 +109,7 @@ Directly use the released version to run, see the [Manual Deployment](https://do
 | [xAI](https://x.ai/) | ✅ |  |
 | [Zhipu AI](https://open.bigmodel.cn/) | ✅ |  |
 | [Dify](https://dify.ai) | ✅ | LLMOps platform |
+| [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | LLM and GPU resource platform |
 | [Ollama](https://ollama.com/) | ✅ | Local LLM running platform |
 | [LMStudio](https://lmstudio.ai/) | ✅ | Local LLM running platform |
 | [GiteeAI](https://ai.gitee.com/) | ✅ | LLM interface gateway(MaaS) |

README_JP.md

@@ -7,7 +7,7 @@
 
 <a href="https://trendshift.io/repositories/12901" target="_blank"><img src="https://trendshift.io/api/badge/repositories/12901" alt="RockChinQ%2FLangBot | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
 
-<a href="https://docs.langbot.app">ホーム</a> ｜
+<a href="https://langbot.app">ホーム</a> ｜
 <a href="https://docs.langbot.app/insight/intro.html">機能</a> ｜
 <a href="https://docs.langbot.app/insight/guide.html">デプロイ</a> ｜
 <a href="https://docs.langbot.app/usage/faq.html">FAQ</a> ｜
@@ -44,6 +44,7 @@
 >
 > - どのデプロイ方法を始める前に、必ず[新規ユーザーガイド](https://docs.langbot.app/insight/guide.html)をお読みください。  
 > - すべてのドキュメントは中国語で提供されています。近い将来、i18nバージョンを提供する予定です。
+> - Read [the auto-generated wiki on DeepWiki](https://deepwiki.com/RockChinQ/LangBot)。
 
 #### Docker Compose デプロイ
 
@@ -84,6 +85,7 @@ LangBotはBTPanelにリストされています。BTPanelをインストール
 | 個人QQ | ✅ |  |
 | QQ公式API | ✅ |  |
 | WeCom | ✅ |  |
+| WeComCS | ✅ |  |
 | 個人WeChat | ✅ | [Gewechat](https://github.com/Devo919/Gewechat)を使用して接続 |
 | Lark | ✅ |  |
 | DingTalk | ✅ |  |
@@ -105,6 +107,7 @@ LangBotはBTPanelにリストされています。BTPanelをインストール
 | [Anthropic](https://www.anthropic.com/) | ✅ |  |
 | [xAI](https://x.ai/) | ✅ |  |
 | [Zhipu AI](https://open.bigmodel.cn/) | ✅ |  |
+| [PPIO](https://ppinfra.com/user/register?invited_by=QJKFYD&utm_source=github_langbot) | ✅ | 大模型とGPUリソースプラットフォーム |
 | [Dify](https://dify.ai) | ✅ | LLMOpsプラットフォーム |
 | [Ollama](https://ollama.com/) | ✅ | ローカルLLM実行プラットフォーム |
 | [LMStudio](https://lmstudio.ai/) | ✅ | ローカルLLM実行プラットフォーム |

libs/wecom_customer_service_api/api.py

@@ -0,0 +1,343 @@
+from quart import request
+from ..wecom_api.WXBizMsgCrypt3 import WXBizMsgCrypt
+import base64
+import binascii
+import httpx
+import traceback
+from quart import Quart
+import xml.etree.ElementTree as ET
+from typing import Callable, Dict, Any
+from .wecomcsevent import WecomCSEvent
+from pkg.platform.types import events as platform_events, message as platform_message
+import aiofiles
+
+
+class WecomCSClient():
+    def __init__(self,corpid:str,secret:str,token:str,EncodingAESKey: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.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":[],
+        }
+
+    async def get_pic_url(self, media_id: str):
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+
+        url = f"{self.base_url}/media/get?access_token={self.access_token}&media_id={media_id}"
+
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            if response.headers.get("Content-Type", "").startswith("application/json"):
+                data = response.json()
+                if data.get('errcode') in [40014, 42001]:
+                    self.access_token = await self.get_access_token(self.secret)
+                    return await self.get_pic_url(media_id)
+                else:
+                    raise Exception("Failed to get image: " + str(data))
+
+            # 否则是图片，转成 base64
+            image_bytes = response.content
+            content_type = response.headers.get("Content-Type", "")
+            base64_str = base64.b64encode(image_bytes).decode("utf-8")
+            base64_str = f"data:{content_type};base64,{base64_str}"
+            return base64_str
+
+
+    #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_detailed_message_list(self,xml_msg:str):
+        # 在本方法中解析消息，并且获得消息的具体内容
+        if isinstance(xml_msg, bytes):
+            xml_msg = xml_msg.decode('utf-8')
+        root = ET.fromstring(xml_msg)
+        token = root.find("Token").text
+        open_kfid = root.find("OpenKfId").text
+        
+        # if open_kfid in self.openkfid_list:
+        #     return None
+        # else:
+        #     self.openkfid_list.append(open_kfid)
+        
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+        
+        url = self.base_url+'/kf/sync_msg?access_token='+ self.access_token
+        async with httpx.AsyncClient() as client:
+            params = {
+                "token": token,
+                "voice_format": 0,
+                "open_kfid": open_kfid,
+            }
+            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.get_detailed_message_list(xml_msg)
+            if data['errcode'] != 0:
+                raise Exception("Failed to get message")
+            
+            last_msg_data = data['msg_list'][-1]
+            open_kfid = last_msg_data.get("open_kfid")
+            # 进行获取图片操作
+            if last_msg_data.get("msgtype") == "image":
+                media_id = last_msg_data.get("image").get("media_id")
+                picurl = await self.get_pic_url(media_id)
+                last_msg_data["picurl"] = picurl
+            # await self.change_service_status(userid=external_userid,openkfid=open_kfid,servicer=servicer)
+            return last_msg_data
+    
+    
+    async def change_service_status(self,userid:str,openkfid:str,servicer:str):
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+        url = self.base_url+"/kf/service_state/get?access_token="+self.access_token
+        async with httpx.AsyncClient() as client:
+            params = {
+                "open_kfid" : openkfid,
+                "external_userid" : userid,
+                "service_state" : 1,
+                "servicer_userid" : servicer,
+            }
+            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.change_service_status(userid,openkfid)
+            if data['errcode'] != 0:
+                raise Exception("Failed to change service status: "+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_text_msg(self, open_kfid: str, external_userid: str, msgid: str,content:str):
+        if not await self.check_access_token():
+            self.access_token = await self.get_access_token(self.secret)
+
+        url = f"https://qyapi.weixin.qq.com/cgi-bin/kf/send_msg?access_token={self.access_token}"
+
+        payload = {
+            "touser": external_userid,
+            "open_kfid": open_kfid,
+            "msgid": msgid,
+            "msgtype": "text",
+            "text": {
+                "content": content,
+            }
+        }
+
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, json=payload)
+
+            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_text_msg(open_kfid,external_userid,msgid,content)
+            if data['errcode'] != 0:
+                raise Exception("Failed to send message")
+            return 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_detailed_message_list(xml_msg)
+                if message_data is not None:
+                    event = WecomCSEvent.from_payload(message_data) 
+                    if event:
+                        await self._handle_message(event)
+
+                return "success"
+        except Exception as e:
+            traceback.print_exc()
+            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[[WecomCSEvent], 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: WecomCSEvent):
+        """
+        处理消息事件。
+        """
+        msg_type = event.type
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+    
+    @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_customer_service_api/wecomcsevent.py

@@ -0,0 +1,134 @@
+from typing import Dict, Any, Optional
+
+
+class WecomCSEvent(dict):
+    """
+    封装从企业微信收到的事件数据对象（字典），提供属性以获取其中的字段。
+
+    除 `type` 和 `detail_type` 属性对于任何事件都有效外，其它属性是否存在（若不存在则返回 `None`）依事件类型不同而不同。
+    """
+
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional["WecomCSEvent"]:
+        """
+        从企业微信(客服会话)事件数据构造 `WecomEvent` 对象。
+
+        Args:
+            payload (Dict[str, Any]): 解密后的企业微信事件数据。
+
+        Returns:
+            Optional[WecomEvent]: 如果事件数据合法，则返回 WecomEvent 对象；否则返回 None。
+        """
+        try:
+            event = WecomCSEvent(payload)
+            _ = event.type,
+            return event
+        except KeyError:
+            return None
+
+    @property
+    def type(self) -> str:
+        """
+        事件类型，例如 "message"、"event"、"text" 等。
+
+        Returns:
+            str: 事件类型。
+        """
+        return self.get("msgtype", "")
+    
+    @property
+    def user_id(self) -> Optional[str]:
+        """
+        用户 ID，例如消息的发送者或事件的触发者。
+
+        Returns:
+            Optional[str]: 用户 ID。
+        """
+        return self.get("external_userid")
+
+    @property
+    def receiver_id(self) -> Optional[str]:
+        """
+        接收者 ID，例如机器人自身的企业微信 ID。
+
+        Returns:
+            Optional[str]: 接收者 ID。
+        """
+        return self.get("open_kfid","")
+    
+    @property
+    def picurl(self) -> Optional[str]:
+        """
+        图片 URL，仅在图片消息中存在。
+        base64格式
+        Returns:
+            Optional[str]: 图片 URL。
+        """
+
+        return self.get("picurl","")
+
+    @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]: 消息内容。
+        """
+        if self.get("msgtype") == 'text':
+            return self.get("text").get("content","")
+        else:
+            return None
+
+
+    @property
+    def timestamp(self) -> Optional[int]:
+        """
+        事件发生的时间戳。
+
+        Returns:
+            Optional[int]: 时间戳。
+        """
+        return self.get("send_time")
+
+
+    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/migrations/m039_modelscope_cfg_completion.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 from .. import migration
 
 
-@migration.migration_class("modelscope-config-completion", 4)
+@migration.migration_class("modelscope-config-completion", 39)
 class ModelScopeConfigCompletionMigration(migration.Migration):
-    """OpenAI配置迁移
+    """ModelScope配置迁移
     """
 
     async def need_migrate(self) -> bool:

pkg/core/migrations/m040_ppio_config.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("ppio-config", 40)
+class PPIOConfigMigration(migration.Migration):
+    """PPIO配置迁移
+    """
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移
+        """
+        return 'ppio-chat-completions' not in self.ap.provider_cfg.data['requester'] \
+            or 'ppio' not in self.ap.provider_cfg.data['keys']
+
+    async def run(self):
+        """执行迁移
+        """
+        if 'ppio-chat-completions' not in self.ap.provider_cfg.data['requester']:
+            self.ap.provider_cfg.data['requester']['ppio-chat-completions'] = {
+                'base-url': 'https://api.ppinfra.com/v3/openai',
+                'args': {},
+                'timeout': 120,
+            }
+
+        if 'ppio' not in self.ap.provider_cfg.data['keys']:
+            self.ap.provider_cfg.data['keys']['ppio'] = []
+
+        await self.ap.provider_cfg.dump_config()

pkg/core/stages/migrate.py

@@ -12,7 +12,7 @@ from ..migrations import m020_wecom_config, m021_lark_config, m022_lmstudio_conf
 from ..migrations import m026_qqofficial_config, m027_wx_official_account_config, m028_aliyun_requester_config
 from ..migrations import m029_dashscope_app_api_config, m030_lark_config_cmpl, m031_dingtalk_config, m032_volcark_config
 from ..migrations import m033_dify_thinking_config, m034_gewechat_file_url_config, m035_wxoa_mode, m036_wxoa_loading_message
-from ..migrations import m037_mcp_config, m038_tg_dingtalk_markdown, m039_modelscope_cfg_completion
+from ..migrations import m037_mcp_config, m038_tg_dingtalk_markdown, m039_modelscope_cfg_completion, m040_ppio_config
 
 
 @stage.stage_class("MigrationStage")

pkg/platform/sources/gewechat.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import gewechat_client
 
 import typing
@@ -26,7 +24,8 @@ from ..types import events as platform_events
 from ..types import entities as platform_entities
 from ...utils import image
 import xml.etree.ElementTree as ET
-
+from typing import Optional, List, Tuple
+from functools import partial
 
 class GewechatMessageConverter(adapter.MessageConverter):
 
@@ -58,168 +57,367 @@ class GewechatMessageConverter(adapter.MessageConverter):
             elif isinstance(component, platform_message.WeChatLink):
                 content_list.append({'type': 'WeChatLink', 'link_title': component.link_title, 'link_desc': component.link_desc,
                                      'link_thumb_url': component.link_thumb_url, 'link_url': component.link_url})
-
-
+            elif isinstance(component, platform_message.WeChatForwardLink):
+                content_list.append({'type': 'WeChatForwardLink', 'xml_data': component.xml_data})
             elif isinstance(component, platform_message.Voice):
-                content_list.append({"type": "voice", "url": component.url, "length": component.length})
+                content_list.append({"type": "voice", "url": component.url, "length": component.length})       
+            elif isinstance(component, platform_message.WeChatForwardImage):
+                content_list.append({'type': 'WeChatForwardImage', 'xml_data': component.xml_data})
+            elif isinstance(component, platform_message.WeChatForwardFile):
+                content_list.append({'type': 'WeChatForwardFile', 'xml_data': component.xml_data})
+            elif isinstance(component, platform_message.WeChatAppMsg):
+                content_list.append({'type': 'WeChatAppMsg', 'app_msg': component.app_msg})               
             elif isinstance(component, platform_message.Forward):
                 for node in component.node_list:
-                    content_list.extend(await GewechatMessageConverter.yiri2target(node.message_chain))
+                    if node.message_chain:
+                        content_list.extend(await GewechatMessageConverter.yiri2target(node.message_chain))
 
         return content_list
 
+
     async def target2yiri(
         self,
         message: dict,
         bot_account_id: str
     ) -> platform_message.MessageChain:
+        """外部消息转平台消息"""
+        # 数据预处理
+        message_list = []
+        ats_bot = False # 是否被@
+        content = message["Data"]["Content"]["string"]
+        content_no_preifx = content  # 群消息则去掉前缀
+        is_group_message = self._is_group_message(message)
+        if is_group_message:
+            ats_bot = self._ats_bot(message, bot_account_id)
+            if "@所有人" in content:
+                message_list.append(platform_message.AtAll())
+            elif ats_bot:
+                message_list.append(platform_message.At(target=bot_account_id))
+            content_no_preifx, _ = self._extract_content_and_sender(content)
 
+        msg_type = message["Data"]["MsgType"]
 
+        # 映射消息类型到处理器方法
+        handler_map = {
+            1: self._handler_text,
+            3: self._handler_image,
+            34: self._handler_voice,
+            49: self._handler_compound,  # 复合类型
+        }
 
-        if message["Data"]["MsgType"] == 1:
-            # 检查消息开头，如果有 wxid_sbitaz0mt65n22:\n 则删掉
-            regex = re.compile(r"^wxid_.*:")
-            # print(message)
+        # 分派处理
+        handler = handler_map.get(msg_type, self._handler_default)
+        handler_result = await handler(
+            message = message,  # 原始的message
+            content_no_preifx = content_no_preifx,  # 处理后的content
+        )
+        
+        if handler_result and len(handler_result) > 0:
+            message_list.extend(handler_result)
+        
+        return platform_message.MessageChain(message_list)
 
-            line_split = message["Data"]["Content"]["string"].split("\n")
-
-            if len(line_split) > 0 and regex.match(line_split[0]):
-                message["Data"]["Content"]["string"] = "\n".join(line_split[1:])
-
-
-            # 正则表达式模式，匹配'@'后跟任意数量的非空白字符
+    async def _handler_text(
+        self, 
+        message: Optional[dict],
+        content_no_preifx: str
+    ) -> platform_message.MessageChain:
+        """处理文本消息 (msg_type=1)"""
+        if message and self._is_group_message(message):
             pattern = r'@\S+'
-            at_string = f"@{bot_account_id}"
-            content_list = []
-            if at_string in message["Data"]["Content"]["string"]:
-                content_list.append(platform_message.At(target=bot_account_id))
-                content_list.append(platform_message.Plain(message["Data"]["Content"]["string"].replace(at_string, '', 1)))
-            # 更优雅的替换改名后@机器人，仅仅限于单独AT的情况
-            elif "PushContent" in message['Data'] and '在群聊中@了你' in message["Data"]["PushContent"]:
-                if '@所有人' in message["Data"]["Content"]["string"]:  # at全员时候传入atll不当作at自己
-                    content_list.append(platform_message.AtAll())
-                else:
-                    content_list.append(platform_message.At(target=bot_account_id))
-                content_list.append(platform_message.Plain(re.sub(pattern, '', message["Data"]["Content"]["string"])))
-            else:
-                content_list = [platform_message.Plain(message["Data"]["Content"]["string"])]
-
-            return platform_message.MessageChain(content_list)
-                    
-        elif message["Data"]["MsgType"] == 3:
-            image_xml = message["Data"]["Content"]["string"]
+            content_no_preifx = re.sub(pattern, '', content_no_preifx)
+        
+        return platform_message.MessageChain([platform_message.Plain(content_no_preifx)])
+    
+    async def _handler_image(
+        self,
+        message: Optional[dict],
+        content_no_preifx: str
+    ) -> platform_message.MessageChain:
+        """处理图像消息 (msg_type=3)"""
+        try:
+            image_xml = content_no_preifx
             if not image_xml:
-                return platform_message.MessageChain([
-                    platform_message.Plain(text="[图片内容为空]")
-                ])
-
-
-            try:
-                base64_str, image_format = await image.get_gewechat_image_base64(
-                    gewechat_url=self.config["gewechat_url"],
-                    gewechat_file_url=self.config["gewechat_file_url"],
-                    app_id=self.config["app_id"],
-                    xml_content=image_xml,
-                    token=self.config["token"],
-                    image_type=2,
-                )
-
-                return platform_message.MessageChain([
-                    platform_message.Image(
-                        base64=f"data:image/{image_format};base64,{base64_str}"
-                    )
-                ])
-            except Exception as e:
-                print(f"处理图片消息失败: {str(e)}")
-                return platform_message.MessageChain([
-                    platform_message.Plain(text=f"[图片处理失败]")
-                ])
-        elif message["Data"]["MsgType"] == 34:
-            audio_base64 = message["Data"]["ImgBuf"]["buffer"]
-            return platform_message.MessageChain(
-                [platform_message.Voice(base64=f"data:audio/silk;base64,{audio_base64}")]
+                return platform_message.MessageChain([platform_message.Unknown("[图片内容为空]")])
+            
+            base64_str, image_format = await image.get_gewechat_image_base64(
+                gewechat_url=self.config["gewechat_url"],
+                gewechat_file_url=self.config["gewechat_file_url"],
+                app_id=self.config["app_id"],
+                xml_content=image_xml,
+                token=self.config["token"],
+                image_type=2,
             )
-        elif message["Data"]["MsgType"] == 49:
-            # 支持微信聊天记录的消息类型，将 XML 内容转换为 MessageChain 传递
+
+            elements = [
+                platform_message.Image(base64=f"data:image/{image_format};base64,{base64_str}"),
+                platform_message.WeChatForwardImage(xml_data=image_xml) # 微信消息转发
+            ]
+            return platform_message.MessageChain(elements)
+        except Exception as e:
+            print(f"处理图片失败: {str(e)}")
+            return platform_message.MessageChain([platform_message.Unknown("[图片处理失败]")])
+    
+    async def _handler_voice(
+        self,
+        message: Optional[dict],
+        content_no_preifx: str
+    ) -> platform_message.MessageChain:
+        """处理语音消息 (msg_type=34)"""
+        message_List = []
+        try:
+            # 从消息中提取语音数据（需根据实际数据结构调整字段名）
+            audio_base64 = message["Data"]["ImgBuf"]["buffer"]
+            
+            # 验证语音数据有效性
+            if not audio_base64:
+                message_List.append(platform_message.Unknown(text="[语音内容为空]"))
+                return platform_message.MessageChain(message_List)
+            
+            # 转换为平台支持的语音格式（如 Silk 格式）
+            voice_element = platform_message.Voice(
+                base64=f"data:audio/silk;base64,{audio_base64}"
+            )
+            message_List.append(voice_element)
+            
+        except KeyError as e:
+            print(f"语音数据字段缺失: {str(e)}")
+            message_List.append(platform_message.Unknown(text="[语音数据解析失败]"))
+        except Exception as e:
+            print(f"处理语音消息异常: {str(e)}")
+            message_List.append(platform_message.Unknown(text="[语音处理失败]"))
+        
+        return platform_message.MessageChain(message_List)
+
+
+    async def _handler_compound(
+        self,
+        message: Optional[dict],
+        content_no_preifx: str
+    ) -> platform_message.MessageChain:
+        """处理复合消息 (msg_type=49)，根据子类型分派"""
+        try:
+            xml_data = ET.fromstring(content_no_preifx)
+            appmsg_data = xml_data.find('.//appmsg')
+            data_type = appmsg_data.findtext('.//type', "")
+
+            # 二次分派处理器
+            sub_handler_map = {
+                '57': self._handler_compound_quote,
+                '5': self._handler_compound_link,
+                '6': self._handler_compound_file,
+                '33': self._handler_compound_mini_program,
+                '36': self._handler_compound_mini_program,
+                '2000': partial(self._handler_compound_unsupported, text="[转账消息]"),
+                '2001': partial(self._handler_compound_unsupported, text="[红包消息]"),
+                '51': partial(self._handler_compound_unsupported, text="[视频号消息]"),
+            }
+            
+            handler = sub_handler_map.get(data_type, self._handler_compound_unsupported)
+            return await handler(
+                message=message,        #原始msg
+                xml_data=xml_data,      # xml数据
+            )
+        except Exception as e:
+            print(f"解析复合消息失败: {str(e)}")
+            return platform_message.MessageChain([platform_message.Unknown(text=content_no_preifx)])
+    
+    async def _handler_compound_quote(
+        self,
+        message: Optional[dict],
+        xml_data: ET.Element
+    ) -> platform_message.MessageChain:
+        """处理引用消息 (data_type=57)"""
+        # print("_handler_compound_quote", ET.tostring(xml_data, encoding='unicode'))
+        appmsg_data = xml_data.find('.//appmsg')
+        quote_data = ""  # 引用原文
+        quote_id = None  # 引用消息的原发送者
+        tousername = None # 接收方: 所属微信的wxid
+        user_data = "" # 用户消息
+        sender_id = xml_data.findtext('.//fromusername')   # 发送方：单聊用户/群member
+        if appmsg_data:
+            user_data = appmsg_data.findtext('.//title') or "" 
+            quote_data = appmsg_data.find('.//refermsg').findtext('.//content')
+            quote_id = appmsg_data.find('.//refermsg').findtext('.//chatusr')  
+        if message:
+            tousername = message['Wxid']                       
+
+        message_list = []
+        # quote_data原始的消息
+        if quote_data:
+            quote_data_message_list = platform_message.MessageChain()
+            # 文本消息
             try:
-                content = message["Data"]["Content"]["string"]
-                # 有三种可能的消息结构weid开头，私聊直接<?xml>和直接<msg>
-                if content.startswith('wxid'):
-                    xml_list = content.split('\n')[2:]
-                    xml_data = '\n'.join(xml_list)
-                elif content.startswith('<?xml'):
-                    xml_list = content.split('\n')[1:]
-                    xml_data = '\n'.join(xml_list)
+                if "<msg>" not in quote_data:
+                    quote_data_message_list.append(platform_message.Plain(quote_data))
                 else:
-                    xml_data = content
-
-                content_data = ET.fromstring(xml_data)
-                # print(xml_data)
-                # 拿到细分消息类型，按照gewe接口中描述
-                '''
-                小程序：33/36
-                引用消息：57
-                转账消息：2000
-                红包消息：2001
-                视频号消息：51
-                '''
-                appmsg_data = content_data.find('.//appmsg')
-                data_type = appmsg_data.find('.//type').text
-                if data_type == '57':
-                    user_data = appmsg_data.find('.//title').text  # 拿到用户消息
-                    quote_data = appmsg_data.find('.//refermsg').find('.//content').text  # 引用原文
-                    sender_id = appmsg_data.find('.//refermsg').find('.//chatusr').text  # 引用用户id
-                    from_name = message['Data']['FromUserName']['string']
-                    message_list =[]
-                    if message['Wxid'] == sender_id and from_name.endswith('@chatroom'):  # 因为引用机制暂时无法响应用户，所以当引用用户是机器人是构建一个at激活机器人
-                        message_list.append(platform_message.At(target=bot_account_id))
-                    message_list.append(platform_message.Quote(
-                            sender_id=sender_id,
-                            origin=platform_message.MessageChain(
-                                [platform_message.Plain(quote_data)]
-                            )))
-                    message_list.append(platform_message.Plain(user_data))
-                    return platform_message.MessageChain(message_list)
-                elif data_type == '51':
-                    return platform_message.MessageChain(
-                        [platform_message.Plain(text=f'[视频号消息]')]
-                    )
-                    # print(content_data)
-                elif data_type == '2000':
-                    return platform_message.MessageChain(
-                        [platform_message.Plain(text=f'[转账消息]')]
-                    )
-                elif data_type == '2001':
-                    return platform_message.MessageChain(
-                        [platform_message.Plain(text=f'[红包消息]')]
-                    )
-                elif data_type == '5':
-                    return platform_message.MessageChain(
-                        [platform_message.Plain(text=f'[公众号消息]')]
-                    )
-                elif data_type == '33' or data_type == '36':
-                    return platform_message.MessageChain(
-                        [platform_message.Plain(text=f'[小程序消息]')]
-                    )
-                # print(data_type.text)
-                else:
-
-
-                    try:
-                        content_bytes = content.encode('utf-8')
-                        decoded_content = base64.b64decode(content_bytes)
-                        return platform_message.MessageChain(
-                            [platform_message.Unknown(content=decoded_content)]
-                        )
-                    except Exception as e:
-                        return platform_message.MessageChain(
-                            [platform_message.Plain(text=content)]
-                        )
+                    # 引用消息展开
+                    quote_data_xml = ET.fromstring(quote_data)
+                    if quote_data_xml.find("img"):
+                        quote_data_message_list.extend(await self._handler_image(None, quote_data))
+                    elif quote_data_xml.find("voicemsg"):
+                        quote_data_message_list.extend(await self._handler_voice(None, quote_data))
+                    elif quote_data_xml.find("videomsg"):
+                        quote_data_message_list.extend(await self._handler_default(None, quote_data)) # 先不处理
+                    else:
+                        # appmsg
+                        quote_data_message_list.extend(await self._handler_compound(None, quote_data))
             except Exception as e:
-                print(f"Error processing type 49 message: {str(e)}")
-                return platform_message.MessageChain(
-                    [platform_message.Plain(text="[无法解析的消息]")]
+                print(f"处理引用消息异常 expcetion:{e}")
+                quote_data_message_list.append(platform_message.Plain(quote_data))
+            message_list.append(
+                platform_message.Quote(
+                    sender_id=sender_id,
+                    origin=quote_data_message_list,
                 )
+            )
+            if len(user_data) > 0:
+                pattern = r'^@\S+'
+                user_data = re.sub(pattern, '', user_data)
+                message_list.append(platform_message.Plain(user_data))
+        # print(f"**_handler_compound_quote message_list len={len(message_list)}")
+        # for comp in message_list:
+        #     if isinstance(comp, platform_message.Quote):
+        #         print(f"**_handler_compound_quote send_id {comp.sender_id}" )
+        #         for quote_item in comp.origin:
+        #             print(f"******* _handler_compound_quote item {quote_item.type} + message: {quote_item}" )
+        #     else:
+        #         print(f"_handler_compound_quote type: {comp.type} + message: {comp}")
+        return platform_message.MessageChain(message_list)
+
+    async def _handler_compound_file(
+        self,
+        message: dict,
+        xml_data: ET.Element
+    ) -> platform_message.MessageChain:
+        """处理文件消息 (data_type=6)"""
+        xml_data_str = ET.tostring(xml_data, encoding='unicode')
+        return platform_message.MessageChain([
+            platform_message.WeChatForwardFile(xml_data=xml_data_str)
+        ])
+
+    async def _handler_compound_link(
+        self,
+        message: dict,
+        xml_data: ET.Element
+    ) -> platform_message.MessageChain:
+        """处理链接消息（如公众号文章、外部网页）"""
+        message_list = []
+        try:
+            # 解析 XML 中的链接参数
+            appmsg = xml_data.find('.//appmsg')
+            if appmsg is None:
+                return platform_message.MessageChain()
+            message_list.append(
+                platform_message.WeChatLink(
+                    link_title = appmsg.findtext('title', ''),
+                    link_desc = appmsg.findtext('des', ''),
+                    link_url = appmsg.findtext('url', ''),
+                    link_thumb_url = appmsg.findtext("thumburl", '') # 这个字段拿不到
+                )
+            )
+            # 转发消息
+            xml_data_str = ET.tostring(xml_data, encoding='unicode')
+            # print(xml_data_str)
+            message_list.append(
+                platform_message.WeChatForwardLink(
+                    xml_data=xml_data_str
+                )
+            )
+        except Exception as e:
+            print(f"解析链接消息失败: {str(e)}")
+        return platform_message.MessageChain(message_list)
+
+    async def _handler_compound_mini_program(
+        self,
+        message: dict,
+        xml_data: ET.Element
+    ) -> platform_message.MessageChain:
+        """处理小程序消息（如小程序卡片、服务通知）"""
+        xml_data_str = ET.tostring(xml_data, encoding='unicode')
+        return platform_message.MessageChain([
+            platform_message.WeChatForwardMiniPrograms(xml_data=xml_data_str)
+        ])
+
+    async def _handler_default(
+        self,
+        message: Optional[dict],
+        content_no_preifx: str
+    ) -> platform_message.MessageChain:
+        """处理未知消息类型"""
+        if message:
+            msg_type = message["Data"]["MsgType"]
+        else:
+            msg_type = ""
+        return platform_message.MessageChain([
+            platform_message.Unknown(text=f"[未知消息类型 msg_type:{msg_type}]")
+        ])
+
+    def _handler_compound_unsupported(
+        self,
+        message: dict,
+        xml_data: str,
+        text: Optional[str] = None
+    ) -> platform_message.MessageChain:
+        """处理未支持复合消息类型(msg_type=49)子类型"""
+        if not text:
+            text = f"[xml_data={xml_data}]"
+        content_list = []
+        content_list.append(
+            platform_message.Unknown(text=f"[处理未支持复合消息类型[msg_type=49]|{text}"))
+        
+        return platform_message.MessageChain(content_list)
+
+    # 返回是否被艾特
+    def _ats_bot(self, message: dict, bot_account_id:str) -> bool:
+        ats_bot = False
+        try:
+            to_user_name = message['Wxid']                               # 接收方: 所属微信的wxid
+            raw_content = message["Data"]["Content"]["string"]         # 原始消息内容
+            content_no_prefix, _ = self._extract_content_and_sender(raw_content)
+            # 直接艾特机器人
+            ats_bot =  ats_bot or (f"@{bot_account_id}" in content_no_prefix)
+            # 文本类@bot
+            push_content = message.get('Data', {}).get('PushContent', '')
+            ats_bot =  ats_bot or ('在群聊中@了你' in push_content)
+            # 引用别人时@bot
+            msg_source = message.get('Data', {}).get('MsgSource', '') or ''
+            if len(msg_source) > 0:
+                msg_source_data = ET.fromstring(msg_source)
+                at_user_list = msg_source_data.findtext("atuserlist") or ""
+                ats_bot = ats_bot or (to_user_name in at_user_list)
+            # 引用bot
+            if  message.get('Data', {}).get('MsgType', 0) == 49: 
+                xml_data = ET.fromstring(content_no_prefix)
+                appmsg_data = xml_data.find('.//appmsg')
+                tousername = message['Wxid']                                        # 接收方: 所属微信的wxid
+                quote_id = appmsg_data.find('.//refermsg').findtext('.//chatusr')   # 引用消息的原发送者
+                ats_bot =  ats_bot or (quote_id == tousername)      
+        except Exception as e:
+            print(f"_ats_bot got except: {e}")
+        finally:
+            return ats_bot
+        
+    # 提取一下content前面的sender_id, 和去掉前缀的内容
+    def _extract_content_and_sender(self, raw_content: str) -> Tuple[str, Optional[str]]:
+        try:
+            # 检查消息开头，如果有 wxid_sbitaz0mt65n22:\n 则删掉
+            # add: 有些用户的wxid不是上述格式。换成user_name: 
+            regex = re.compile(r"^[a-zA-Z0-9_\-]{5,20}:")
+            line_split = raw_content.split("\n")
+            if len(line_split) > 0 and regex.match(line_split[0]):
+                raw_content = "\n".join(line_split[1:])
+                sender_id = line_split[0].strip(":")
+                return raw_content, sender_id
+        except Exception as e:
+            print(f"_extract_content_and_sender got except: {e}")
+        finally:
+            return raw_content, None
+
+    # 是否是群消息
+    def _is_group_message(self, message: dict)->bool:
+        from_user_name = message['Data']['FromUserName']['string']
+        return from_user_name.endswith("@chatroom")
 
 class GewechatEventConverter(adapter.EventConverter):
 
@@ -311,7 +509,6 @@ class GeWeChatAdapter(adapter.MessagePlatformAdapter):
     def __init__(self, config: dict, ap: app.Application):
         self.config = config
         self.ap = ap
-
         self.quart_app = quart.Quart(__name__)
 
         self.message_converter = GewechatMessageConverter(config)
@@ -346,50 +543,118 @@ class GeWeChatAdapter(adapter.MessagePlatformAdapter):
 
                 return 'ok'
 
+    async def _handle_message(
+        self,
+        message: platform_message.MessageChain,
+        target_id: str
+    ):
+        """统一消息处理核心逻辑"""
+        content_list = await self.message_converter.yiri2target(message)
+        at_targets = [item["target"] for item in content_list if item["type"] == "at"]
+
+        # 处理@逻辑
+        at_targets = at_targets or []
+        member_info = []
+        if at_targets:
+            member_info = self.bot.get_chatroom_member_detail(
+                self.config["app_id"],
+                target_id,
+                at_targets[::-1]
+            )["data"]
+
+        # 处理消息组件
+        for msg in content_list:
+            # 文本消息处理@
+            if msg['type'] == 'text' and at_targets:
+                for member in member_info:
+                    msg['content'] = f'@{member["nickName"]} {msg["content"]}'
+
+            # 统一消息派发
+            handler_map = {
+                'text': lambda msg: self.bot.post_text(
+                    app_id=self.config['app_id'],
+                    to_wxid=target_id,
+                    content=msg['content'],
+                    ats=",".join(at_targets)
+                ),
+                'image': lambda msg: self.bot.post_image(
+                    app_id=self.config['app_id'],
+                    to_wxid=target_id,
+                    img_url=msg["image"]
+                ),
+                'WeChatForwardMiniPrograms': lambda msg: self.bot.forward_mini_app(
+                    app_id=self.config['app_id'],
+                    to_wxid=target_id,
+                    xml=msg['xml_data'],
+                    cover_img_url=msg.get('image_url')
+                ),
+                'WeChatEmoji': lambda msg: self.bot.post_emoji(
+                    app_id=self.config['app_id'],
+                    to_wxid=target_id,
+                    emoji_md5=msg['emoji_md5'],
+                    emoji_size=msg['emoji_size']
+                ),
+                'WeChatLink': lambda msg: self.bot.post_link(
+                    app_id=self.config['app_id'],
+                    to_wxid=target_id,
+                    title=msg['link_title'],
+                    desc=msg['link_desc'],
+                    link_url=msg['link_url'],
+                    thumb_url=msg['link_thumb_url'],
+                ),
+                'WeChatMiniPrograms': lambda msg: self.bot.post_mini_app(
+                    app_id=self.config['app_id'],
+                    to_wxid=target_id,
+                    mini_app_id=msg['mini_app_id'],
+                    display_name=msg['display_name'],
+                    page_path=msg['page_path'],
+                    cover_img_url=msg['cover_img_url'],
+                    title=msg['title'],
+                    user_name=msg['user_name']
+                ),
+                'WeChatForwardLink': lambda msg: self.bot.forward_url(
+                    app_id=self.config['app_id'],
+                    to_wxid=target_id,
+                    xml=msg['xml_data']
+                ),
+                'WeChatForwardImage': lambda msg: self.bot.forward_image(
+                    app_id=self.config['app_id'],
+                    to_wxid=target_id,
+                    xml=msg['xml_data']
+                ),
+                'WeChatForwardFile': lambda msg: self.bot.forward_file(
+                    app_id=self.config['app_id'],
+                    to_wxid=target_id,
+                    xml=msg['xml_data']
+                ),
+                'voice': lambda msg: self.bot.post_voice(
+                    app_id=self.config['app_id'],
+                    to_wxid=target_id,
+                    voice_url=msg['url'],
+                    voice_duration=msg['length']
+                ),
+                'WeChatAppMsg': lambda msg: self.bot.post_app_msg(
+                    app_id=self.config['app_id'],
+                    to_wxid=target_id,
+                    appmsg=msg['app_msg']
+                ),
+                'at': lambda msg: None
+            }
+
+            if handler := handler_map.get(msg['type']):
+                handler(msg)
+            else:
+                self.ap.logger.warning(f"未处理的消息类型: {msg['type']}")
+                continue
+
     async def send_message(
         self,
         target_type: str,
         target_id: str,
         message: platform_message.MessageChain
     ):
-        geweap_msg = await self.message_converter.yiri2target(message)
-        # 此处加上群消息at处理
-        ats = [item["target"] for item in geweap_msg if item["type"] == "at"]
-
-
-        for msg in geweap_msg:
-            # at主动发送消息
-            if msg['type'] == 'text':
-                if ats:
-                    member_info = self.bot.get_chatroom_member_detail(
-                        self.config["app_id"],
-                        target_id,
-                        ats[::-1]
-                    )["data"]
-
-                    for member in member_info:
-                        msg['content'] = f'@{member["nickName"]} {msg["content"]}'
-                self.bot.post_text(app_id=self.config['app_id'], to_wxid=target_id, content=msg['content'],
-                                   ats=",".join(ats))
-
-            elif msg['type'] == 'image':
-
-                self.bot.post_image(app_id=self.config['app_id'], to_wxid=target_id, img_url=msg["image"])
-            elif msg['type'] == 'WeChatMiniPrograms':
-                self.bot.post_mini_app(app_id=self.config['app_id'], to_wxid=target_id, mini_app_id=msg['mini_app_id']
-                                       , display_name=msg['display_name'], page_path=msg['page_path']
-                                       , cover_img_url=msg['cover_img_url'], title=msg['title'], user_name=msg['user_name'])
-            elif msg['type'] == 'WeChatForwardMiniPrograms':
-                self.bot.forward_mini_app(app_id=self.config['app_id'], to_wxid=target_id, xml=msg['xml_data'], cover_img_url=msg['image_url'])
-            elif msg['type'] == 'WeChatEmoji':
-                self.bot.post_emoji(app_id=self.config['app_id'], to_wxid=target_id,
-                                    emoji_md5=msg['emoji_md5'], emoji_size=msg['emoji_size'])
-            elif msg['type'] == 'WeChatLink':
-                self.bot.post_link(app_id=self.config['app_id'], to_wxid=target_id
-                                   ,title=msg['link_title'], desc=msg['link_desc']
-                                   , link_url=msg['link_url'], thumb_url=msg['link_thumb_url'])
-
-
+        """主动发送消息"""
+        return await self._handle_message(message, target_id)
 
     async def reply_message(
         self,
@@ -397,46 +662,10 @@ class GeWeChatAdapter(adapter.MessagePlatformAdapter):
         message: platform_message.MessageChain,
         quote_origin: bool = False
     ):
-        content_list = await self.message_converter.yiri2target(message)
-
-        ats = [item["target"] for item in content_list if item["type"] == "at"]
-        target_id = message_source.source_platform_object["Data"]["FromUserName"]["string"]
-
-        for msg in content_list:
-            if msg["type"] == "text":
-
-                if ats:
-                    member_info = self.bot.get_chatroom_member_detail(
-                        self.config["app_id"],
-                        message_source.source_platform_object["Data"]["FromUserName"]["string"],
-                        ats[::-1]
-                    )["data"]
-
-                    for member in member_info:
-                        msg['content'] = f'@{member["nickName"]} {msg["content"]}'
-
-                self.bot.post_text(
-                    app_id=self.config["app_id"],
-                    to_wxid=message_source.source_platform_object["Data"]["FromUserName"]["string"],
-                    content=msg["content"],
-                    ats=",".join(ats)
-                )
-            elif msg['type'] == 'image':
-
-                self.bot.post_image(app_id=self.config['app_id'], to_wxid=target_id, img_url=msg["image"])
-            elif msg['type'] == 'WeChatMiniPrograms':
-                self.bot.post_mini_app(app_id=self.config['app_id'], to_wxid=target_id, mini_app_id=msg['mini_app_id']
-                                       , display_name=msg['display_name'], page_path=msg['page_path']
-                                       , cover_img_url=msg['cover_img_url'], title=msg['title'], user_name=msg['user_name'])
-            elif msg['type'] == 'WeChatForwardMiniPrograms':
-                self.bot.forward_mini_app(app_id=self.config['app_id'], to_wxid=target_id, xml=msg['xml_data'], cover_img_url=msg['image_url'])
-            elif msg['type'] == 'WeChatEmoji':
-                self.bot.post_emoji(app_id=self.config['app_id'], to_wxid=target_id,
-                                    emoji_md5=msg['emoji_md5'], emoji_size=msg['emoji_size'])
-            elif msg['type'] == 'WeChatLink':
-                self.bot.post_link(app_id=self.config['app_id'], to_wxid=target_id
-                                   , title=msg['link_title'], desc=msg['link_desc']
-                                   , link_url=msg['link_url'], thumb_url=msg['link_thumb_url'])
+        """回复消息"""
+        if message_source.source_platform_object:
+            target_id = message_source.source_platform_object["Data"]["FromUserName"]["string"]
+            return await self._handle_message(message, target_id)
 
     async def is_muted(self, group_id: int) -> bool:
         pass
@@ -490,8 +719,13 @@ class GeWeChatAdapter(adapter.MessagePlatformAdapter):
 
             time.sleep(2)
 
-            ret = self.bot.set_callback(self.config["token"], self.config["callback_url"])
-            print('设置 Gewechat 回调：', ret)
+            try:
+                # gewechat-server容器重启, token会变，但是还会登录成功
+                # 换新token也会收不到回调，要重新登陆下。
+                ret = self.bot.set_callback(self.config["token"], self.config["callback_url"])
+            except Exception as e:       
+                raise Exception(f"设置 Gewechat 回调失败， token失效： {e}")
+                
 
         threading.Thread(target=gewechat_login_process).start()
 
@@ -506,4 +740,4 @@ class GeWeChatAdapter(adapter.MessagePlatformAdapter):
         )
 
     async def kill(self) -> bool:
-        pass
+        pass

pkg/platform/sources/lark.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import lark_oapi
-
+from lark_oapi.api.im.v1 import CreateImageRequest, CreateImageRequestBody, CreateImageResponse
+import traceback
 import typing
 import asyncio
 import traceback
@@ -60,12 +61,22 @@ class LarkMessageConverter(adapter.MessageConverter):
         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})
+                # Ensure text is valid UTF-8
+                try:
+                    text = msg.text.encode('utf-8').decode('utf-8')
+                    pending_paragraph.append({"tag": "md", "text": text})
+                except UnicodeError:
+                    # If text is not valid UTF-8, try to decode with other encodings
+                    try:
+                        text = msg.text.encode('latin1').decode('utf-8')
+                        pending_paragraph.append({"tag": "md", "text": text})
+                    except UnicodeError:
+                        # If still fails, replace invalid characters
+                        text = msg.text.encode('utf-8', errors='replace').decode('utf-8')
+                        pending_paragraph.append({"tag": "md", "text": text})
             elif isinstance(msg, platform_message.At):
                 pending_paragraph.append(
                     {"tag": "at", "user_id": msg.target, "style": []}
@@ -73,51 +84,84 @@ class LarkMessageConverter(adapter.MessageConverter):
             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)
+                    try:
+                        # Remove data URL prefix if present
+                        if msg.base64.startswith('data:'):
+                            msg.base64 = msg.base64.split(',', 1)[1]
+                        image_bytes = base64.b64decode(msg.base64)
+                    except Exception as e:
+                        traceback.print_exc()
+                        continue
                 elif msg.url:
-                    async with aiohttp.ClientSession() as session:
-                        async with session.get(msg.url) as response:
-                            image_bytes = await response.read()
+                    try:
+                        async with aiohttp.ClientSession() as session:
+                            async with session.get(msg.url) as response:
+                                if response.status == 200:
+                                    image_bytes = await response.read()
+                                else:
+                                    traceback.print_exc()
+                                    continue
+                    except Exception as e:
+                        traceback.print_exc()
+                        continue
                 elif msg.path:
-                    with open(msg.path, "rb") as f:
-                        image_bytes = f.read()
+                    try:
+                        with open(msg.path, "rb") as f:
+                            image_bytes = f.read()
+                    except Exception as e:
+                        traceback.print_exc()
+                        continue
 
-                request: CreateImageRequest = (
-                    CreateImageRequest.builder()
-                    .request_body(
-                        CreateImageRequestBody.builder()
-                        .image_type("message")
-                        .image(image_bytes)
-                        .build()
-                    )
-                    .build()
-                )
+                if image_bytes is None:
+                    continue
 
-                response: CreateImageResponse = await api_client.im.v1.image.acreate(
-                    request
-                )
+                try:
+                    # Create a temporary file to store the image bytes
+                    import tempfile
+                    with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+                        temp_file.write(image_bytes)
+                        temp_file.flush()
+                        
+                        # Create image request using the temporary file
+                        request = CreateImageRequest.builder()\
+                            .request_body(
+                                CreateImageRequestBody.builder()
+                                .image_type("message")
+                                .image(open(temp_file.name, "rb"))
+                                .build()
+                            )\
+                            .build()
+                        
+                        response = 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
 
-                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 = []
+                        message_elements.append(pending_paragraph)
+                        message_elements.append(
+                            [
+                                {
+                                    "tag": "img",
+                                    "image_key": image_key,
+                                }
+                            ]
+                        )
+                        pending_paragraph = []
+                except Exception as e:
+                    traceback.print_exc()
+                    continue
+                finally:
+                    # Clean up the temporary file
+                    import os
+                    if 'temp_file' in locals():
+                        os.unlink(temp_file.name)
             elif isinstance(msg, platform_message.Forward):
                 for node in msg.node_list:
                     message_elements.extend(await LarkMessageConverter.yiri2target(node.message_chain, api_client))

pkg/platform/sources/wecomcs.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+import typing
+import asyncio
+import traceback
+
+import datetime
+
+from libs.wecom_customer_service_api.api import WecomCSClient
+from pkg.platform.adapter import MessagePlatformAdapter
+from pkg.platform.types import events as platform_events, message as platform_message
+from libs.wecom_customer_service_api.wecomcsevent import WecomCSEvent
+from pkg.core import app
+from .. import adapter
+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: WecomCSClient
+    ):
+        content_list = []
+
+        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())
+        )
+        yiri_msg_list.append(platform_message.Image(base64=picurl))
+        chain = platform_message.MessageChain(yiri_msg_list)
+        
+        return chain
+
+
+class WecomEventConverter:
+
+    @staticmethod
+    async def yiri2target(
+        event: platform_events.Event, bot_account_id: int, bot: WecomCSClient
+    ) -> WecomCSEvent:
+        # only for extracting user information
+
+        if type(event) is platform_events.GroupMessage:
+            pass
+
+        if type(event) is platform_events.FriendMessage:
+            return event.source_platform_object
+
+    @staticmethod
+    async def target2yiri(event: WecomCSEvent):
+        """
+        将 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=f"u{event.user_id}",
+                nickname=str(event.user_id),
+                remark="",
+            )
+
+            return platform_events.FriendMessage(
+                sender=friend, message_chain=yiri_chain, time=event.timestamp, source_platform_object=event
+            )
+        elif event.type == "image":
+            friend = platform_entities.Friend(
+                id=f"u{event.user_id}",
+                nickname=str(event.user_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, source_platform_object=event
+            )
+
+
+class WecomCSAdapter(adapter.MessagePlatformAdapter):
+
+    bot: WecomCSClient
+    ap: app.Application
+    bot_account_id: str
+    message_converter: WecomMessageConverter = WecomMessageConverter()
+    event_converter: WecomEventConverter = WecomEventConverter()
+    config: dict
+
+    def __init__(self, config: dict, ap: app.Application):
+        self.config = config
+
+        self.ap = ap
+
+        required_keys = [
+            "corpid",
+            "secret",
+            "token",
+            "EncodingAESKey",
+        ]
+        missing_keys = [key for key in required_keys if key not in config]
+        if missing_keys:
+            raise ParamNotEnoughError("企业微信客服缺少相关配置项，请查看文档或联系管理员")
+
+        self.bot = WecomCSClient(
+            corpid=config["corpid"],
+            secret=config["secret"],
+            token=config["token"],
+            EncodingAESKey=config["EncodingAESKey"],
+        )
+
+    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_text_msg(open_kfid=Wecom_event.receiver_id,external_userid=Wecom_event.user_id,msgid=Wecom_event.message_id,content=content["content"])
+  
+    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.MessagePlatformAdapter], None
+        ],
+    ):
+        async def on_message(event: WecomCSEvent):
+            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="0.0.0.0",
+            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, MessagePlatformAdapter], None],
+    ):
+        return super().unregister_listener(event_type, callback)

pkg/platform/sources/wecomcs.yaml

@@ -0,0 +1,51 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: wecomcs
+  label:
+    en_US: WeComCustomerService
+    zh_CN: 企业微信客服
+  description:
+    en_US: WeComCSAdapter
+    zh_CN: 企业微信客服适配器
+spec:
+  config:
+    - name: port
+      label:
+        en_US: Port
+        zh_CN: 监听端口
+      type: int
+      required: true
+      default: 2289
+    - name: corpid
+      label:
+        en_US: Corpid
+        zh_CN: 企业ID
+      type: string
+      required: true
+      default: ""
+    - name: secret
+      label:
+        en_US: Secret
+        zh_CN: 密钥
+      type: string
+      required: true
+      default: ""
+    - name: token
+      label:
+        en_US: Token
+        zh_CN: 令牌
+      type: string
+      required: true
+      default: ""
+    - name: EncodingAESKey
+      label:
+        en_US: EncodingAESKey
+        zh_CN: 消息加解密密钥
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./wecomcs.py
+    attr: WecomCSAdapter

pkg/platform/types/message.py

@@ -1,16 +1,15 @@
 import itertools
 import logging
+import typing
 from datetime import datetime
 from enum import Enum
 from pathlib import Path
-import typing
 
 import pydantic.v1 as pydantic
 
 from . import entities as platform_entities
 from .base import PlatformBaseModel, PlatformIndexedMetaclass, PlatformIndexedModel
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -642,7 +641,8 @@ class Unknown(MessageComponent):
     """消息组件类型。"""
     text: str
     """文本。"""
-
+    def __str__(self):
+        return f'Unknown Message: {self.text}'
 
 class Voice(MessageComponent):
     """语音。"""
@@ -837,6 +837,8 @@ class WeChatForwardMiniPrograms(MessageComponent):
     xml_data: str
     """首页图片"""
     image_url: typing.Optional[str] = None
+    def __str__(self):
+        return self.xml_data
 
 
 class WeChatEmoji(MessageComponent):
@@ -860,3 +862,35 @@ class WeChatLink(MessageComponent):
     """链接略缩图"""
     link_thumb_url: str = ''
 
+
+class WeChatForwardLink(MessageComponent):
+    """转发链接。个人微信专用组件。"""
+    type: str = 'WeChatForwardLink'
+    """xml数据"""
+    xml_data: str
+    def __str__(self):
+        return self.xml_data
+
+class WeChatForwardImage(MessageComponent):
+    """转发图片。个人微信专用组件。"""
+    type: str = 'WeChatForwardImage'
+    """xml数据"""
+    xml_data: str
+    def __str__(self):
+        return self.xml_data
+
+class WeChatForwardFile(MessageComponent):
+    """转发文件。个人微信专用组件。"""
+    type: str = 'WeChatForwardFile'
+    """xml数据"""
+    xml_data: str
+    def __str__(self):
+        return self.xml_data
+
+class WeChatAppMsg(MessageComponent):
+    """通用appmsg发送。个人微信专用组件。"""
+    type: str = 'WeChatAppMsg'
+    """xml数据"""
+    app_msg: str
+    def __str__(self):
+        return self.app_msg

pkg/provider/modelmgr/requesters/anthropicmsgs.py

@@ -4,6 +4,8 @@ import typing
 import json
 import traceback
 import base64
+import platform
+import socket
 
 import anthropic
 import httpx
@@ -23,6 +25,12 @@ class AnthropicMessages(requester.LLMAPIRequester):
     client: anthropic.AsyncAnthropic
 
     async def initialize(self):
+        # 兼容 Windows 缺失 TCP_KEEPINTVL 和 TCP_KEEPCNT 的问题
+        if platform.system() == "Windows":
+            if not hasattr(socket, "TCP_KEEPINTVL"):
+                socket.TCP_KEEPINTVL = 0
+            if not hasattr(socket, "TCP_KEEPCNT"):
+                socket.TCP_KEEPCNT = 0
 
         httpx_client = anthropic._base_client.AsyncHttpxClientWrapper(
             base_url=self.ap.provider_cfg.data['requester']['anthropic-messages']['base-url'].replace(' ', ''),

pkg/provider/modelmgr/requesters/chatcmpl.py

@@ -65,7 +65,7 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
         
         # deepseek的reasoner模型
         if reasoning_content is not None:
-            chatcmpl_message['content'] = "<think>\n" + reasoning_content + "\n</think>\n\n"+ chatcmpl_message['content']
+            chatcmpl_message['content'] = "<think>\n" + reasoning_content + "\n</think>\n"+ chatcmpl_message['content']
 
         message = llm_entities.Message(**chatcmpl_message)
 

pkg/provider/modelmgr/requesters/ppiochatcmpl.py

@@ -0,0 +1,20 @@
+
+from __future__ import annotations
+
+import openai
+
+from . import chatcmpl, modelscopechatcmpl
+from .. import requester
+from ....core import app
+
+class PPIOChatCompletions(chatcmpl.OpenAIChatCompletions):
+    """欧派云 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']['ppio-chat-completions']

pkg/provider/modelmgr/requesters/ppiochatcmpl.yaml

@@ -0,0 +1,34 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: ppio-chat-completions
+  label:
+    en_US: ppio 
+    zh_CN: 派欧云
+spec:
+  config:
+    - name: base-url
+      label:
+        en_US: Base URL
+        zh_CN: 基础 URL
+      type: string
+      required: true
+      default: "https://api.ppinfra.com/v3/openai"
+    - name: args
+      label:
+        en_US: Args
+        zh_CN: 附加参数
+      type: object
+      required: true
+      default: {}
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_CN: 超时时间
+      type: int
+      required: true
+      default: 120
+execution:
+  python:
+    path: ./ppiochatcmpl.py
+    attr: PPIOChatCompletions

pkg/provider/runners/difysvapi.py

@@ -164,12 +164,14 @@ class DifyServiceAPIRunner(runner.RequestRunner):
             for image_id in image_ids
         ]
 
-        ignored_events = ["agent_message"]
+        ignored_events = []
 
         inputs = {}
         
         inputs.update(query.variables)
 
+        pending_agent_message = ''
+
         async for chunk in self.dify_client.chat_messages(
             inputs=inputs,
             query=plain_text,
@@ -183,50 +185,55 @@ class DifyServiceAPIRunner(runner.RequestRunner):
 
             if chunk["event"] in ignored_events:
                 continue
-            if chunk["event"] == "agent_thought":
-
-                if chunk['tool'] != '' and chunk['observation'] != '':  # 工具调用结果，跳过
-                    continue
-
-                if chunk['thought'].strip() != '':  # 文字回复内容
-                    msg = llm_entities.Message(
-                        role="assistant",
-                        content=chunk["thought"],
-                    )
-                    yield msg
-
-                if chunk['tool']:
-                    msg = llm_entities.Message(
-                        role="assistant",
-                        tool_calls=[
-                            llm_entities.ToolCall(
-                                id=chunk['id'],
-                                type="function",
-                                function=llm_entities.FunctionCall(
-                                    name=chunk["tool"],
-                                    arguments=json.dumps({}),
-                                ),
-                            )
-                        ],
-                    )
-                    yield msg
-            if chunk['event'] == 'message_file':
-
-                if chunk['type'] == 'image' and chunk['belongs_to'] == 'assistant':
-
-                    base_url = self.dify_client.base_url
-
-                    if base_url.endswith('/v1'):
-                        base_url = base_url[:-3]
-
-                    image_url = base_url + chunk['url']
 
+            if chunk['event'] == 'agent_message':
+                pending_agent_message += chunk['answer']
+            else:
+                if pending_agent_message.strip() != '':
+                    pending_agent_message = pending_agent_message.replace('</details>Action:', '</details>')
                     yield llm_entities.Message(
                         role="assistant",
-                        content=[llm_entities.ContentElement.from_image_url(image_url)],
+                        content=self._try_convert_thinking(pending_agent_message),
                     )
-            if chunk['event'] == 'error':
-                raise errors.DifyAPIError("dify 服务错误: " + chunk['message'])
+                pending_agent_message = ''
+
+                if chunk["event"] == "agent_thought":
+
+                    if chunk['tool'] != '' and chunk['observation'] != '':  # 工具调用结果，跳过
+                        continue
+
+                    if chunk['tool']:
+                        msg = llm_entities.Message(
+                            role="assistant",
+                            tool_calls=[
+                                llm_entities.ToolCall(
+                                    id=chunk['id'],
+                                    type="function",
+                                    function=llm_entities.FunctionCall(
+                                        name=chunk["tool"],
+                                        arguments=json.dumps({}),
+                                    ),
+                                )
+                            ],
+                        )
+                        yield msg
+                if chunk['event'] == 'message_file':
+
+                    if chunk['type'] == 'image' and chunk['belongs_to'] == 'assistant':
+
+                        base_url = self.dify_client.base_url
+
+                        if base_url.endswith('/v1'):
+                            base_url = base_url[:-3]
+
+                        image_url = base_url + chunk['url']
+
+                        yield llm_entities.Message(
+                            role="assistant",
+                            content=[llm_entities.ContentElement.from_image_url(image_url)],
+                        )
+                if chunk['event'] == 'error':
+                    raise errors.DifyAPIError("dify 服务错误: " + chunk['message'])
 
         query.session.using_conversation.uuid = chunk["conversation_id"]
 
@@ -303,11 +310,11 @@ class DifyServiceAPIRunner(runner.RequestRunner):
 
                 msg = llm_entities.Message(
                     role="assistant",
-                    content=chunk["data"]["outputs"][
+                    content=self._try_convert_thinking(chunk["data"]["outputs"][
                         self.ap.provider_cfg.data["dify-service-api"]["workflow"][
                             "output-key"
                         ]
-                    ],
+                    ]),
                 )
 
                 yield msg

pkg/utils/constants.py

@@ -1,4 +1,4 @@
-semantic_version = "v3.4.13.1"
+semantic_version = "v3.4.14.3"
 
 debug_mode = False
 

templates/platform.json

@@ -103,6 +103,15 @@
             "bot_token": "",
             "signing_secret": "",
             "port": 2288
+        },
+        {
+            "adapter": "wecomcs",
+            "enable": false,
+            "port": 2289,
+            "corpid": "",
+            "secret": "",
+            "token": "",
+            "EncodingAESKey": ""
         }
     ],
     "track-function-calls": true,

templates/provider.json

@@ -34,6 +34,9 @@
         ],
         "modelscope": [
             "xxxxxxxx"
+        ],
+        "ppio": [
+            "xxxxxxxx"
         ]
     },
     "requester": {
@@ -103,6 +106,11 @@
             "base-url": "https://api-inference.modelscope.cn/v1",
             "args": {},
             "timeout": 120
+        },
+        "ppio-chat-completions": {
+            "base-url": "https://api.ppinfra.com/v3/openai",
+            "args": {},
+            "timeout": 120
         }
     },
     "model": "gpt-4o",