chore: release v3.4.8

feat: add adapter `telegram`

.github/ISSUE_TEMPLATE/bug-report.yml

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

.gitignore

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

README.md

@@ -6,7 +6,7 @@
 
 <div align="center">
 
-<a href="https://trendshift.io/repositories/6187" target="_blank"><img src="https://trendshift.io/api/badge/repositories/6187" alt="RockChinQ%2FQChatGPT | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+<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://docs.langbot.app/insight/intro.htmll">功能介绍</a> ｜
@@ -15,25 +15,28 @@
 <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/>
 
 
-[![QQ Group](https://img.shields.io/badge/%E7%A4%BE%E5%8C%BA%E7%BE%A4-619154800-blue)](https://qm.qq.com/q/PClALFK242)
+[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
+[![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">
+
+[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md)
+
 </div>
 
 </p>
 
-## ✨ 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)
@@ -81,9 +84,15 @@
 | 平台 | 状态 | 备注 |
 | --- | --- | --- |
 | QQ 个人号 | ✅ | QQ 个人号私聊、群聊 |
-| QQ 官方机器人 | ✅ | QQ 频道机器人，支持频道、私聊、群聊 |
+| QQ 官方机器人 | ✅ | QQ 官方机器人，支持频道、私聊、群聊 |
 | 企业微信 | ✅ |  |
-| 钉钉 | 🚧 |  |
+| 个人微信 | ✅ | 使用 [Gewechat](https://github.com/Devo919/Gewechat) 接入 |
+| 微信公众号 | ✅ |  |
+| 飞书 | ✅ |  |
+| 钉钉 | ✅ |  |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| WhatsApp | 🚧 |  |
 
 🚧: 正在开发中
 
@@ -98,5 +107,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/) | ✅ | 大模型聚合平台, LLMOps 平台 |
+
+## 😘 社区贡献
+
+LangBot 离不开以下贡献者和社区内所有人的贡献，我们欢迎任何形式的贡献和反馈。
+
+
+<a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
+</a>

README_EN.md

@@ -0,0 +1,123 @@
+<p align="center">
+<a href="https://langbot.app">
+<img src="https://docs.langbot.app/social.png" alt="LangBot"/>
+</a>
+
+<div align="center">
+
+<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://docs.langbot.app/insight/intro.htmll">Features</a> ｜
+<a href="https://docs.langbot.app/insight/guide.html">Deployment</a> ｜
+<a href="https://docs.langbot.app/usage/faq.html">FAQ</a> ｜
+<a href="https://docs.langbot.app/plugin/plugin-intro.html">Plugin</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">Submit Plugin</a>
+
+<div align="center">
+😎High Stability, 🧩Extension Supported, 🦄Multi-modal - LLM Native Instant Messaging Bot Platform🤖  
+</div>
+
+<br/>
+
+
+[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
+[![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=Usage(7days))
+<img src="https://img.shields.io/badge/python-3.10 | 3.11 | 3.12-blue.svg" alt="python">
+
+[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md)
+
+</div>
+
+</p>
+
+## ✨ Features
+
+- 💬 Chat with LLM / Agent: Supports multiple LLMs, adapt to group chats and private chats; Supports multi-round conversations, tool calls, and multi-modal capabilities. Deeply integrates with [Dify](https://dify.ai). Currently supports QQ, QQ Channel, WeCom, Lark, Discord, personal WeChat, and will support WhatsApp, Telegram, etc. in the future.
+- 🛠️ High Stability, Feature-rich: Native access control, rate limiting, sensitive word filtering, etc. mechanisms; Easy to use, supports multiple deployment methods.
+- 🧩 Plugin Extension, Active Community: Support event-driven, component extension, etc. plugin mechanisms; Rich ecology, currently has dozens of [plugins](https://docs.langbot.app/plugin/plugin-intro.html)
+- 😻 [New] Web UI: Support management LangBot instance through the browser, for details, see [documentation](https://docs.langbot.app/webui/intro.html)
+
+## 📦 Getting Started
+
+> [!IMPORTANT]
+>
+> - 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.
+
+#### Docker Compose Deployment
+
+Suitable for users familiar with Docker, see the [Docker Deployment](https://docs.langbot.app/deploy/langbot/docker.html) documentation.
+
+#### One-click Deployment on BTPanel
+
+LangBot has been listed on the BTPanel, if you have installed the BTPanel, you can use the [document](https://docs.langbot.app/deploy/langbot/one-click/bt.html) to use it.
+
+#### Zeabur Cloud Deployment
+
+Community contributed Zeabur template.
+
+[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/zh-CN/templates/ZKTBDH)
+
+#### Railway Cloud Deployment
+
+[![Deploy on Railway](https://railway.com/button.svg)](https://railway.app/template/yRrAyL?referralCode=vogKPF)
+
+#### Other Deployment Methods
+
+Directly use the released version to run, see the [Manual Deployment](https://docs.langbot.app/deploy/langbot/manual.html) documentation.
+
+## 📸 Demo
+
+<img alt="Reply Effect (with Internet Plugin)" src="https://docs.langbot.app/QChatGPT-0516.png" width="500px"/>
+
+- WebUI Demo: https://demo.langbot.dev/
+    - Login information: Email: `demo@langbot.app` Password: `langbot123456`
+    - Note: Only the WebUI effect is shown, please do not fill in any sensitive information in the public environment.
+
+## 🔌 Component Compatibility
+
+### Message Platform
+
+| Platform | Status | Remarks |
+| --- | --- | --- |
+| Personal QQ | ✅ |  |
+| QQ Official API | ✅ |  |
+| WeCom | ✅ |  |
+| Personal WeChat | ✅ | Use [Gewechat](https://github.com/Devo919/Gewechat) to access |
+| Lark | ✅ |  |
+| DingTalk | ✅ |  |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| WhatsApp | 🚧 |  |
+
+🚧: In development
+
+### LLMs
+
+| LLM | Status | Remarks |
+| --- | --- | --- |
+| [OpenAI](https://platform.openai.com/) | ✅ | Available for any OpenAI interface format model |
+| [DeepSeek](https://www.deepseek.com/) | ✅ |  |
+| [Moonshot](https://www.moonshot.cn/) | ✅ |  |
+| [Anthropic](https://www.anthropic.com/) | ✅ |  |
+| [xAI](https://x.ai/) | ✅ |  |
+| [Zhipu AI](https://open.bigmodel.cn/) | ✅ |  |
+| [Dify](https://dify.ai) | ✅ | LLMOps 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) |
+| [SiliconFlow](https://siliconflow.cn/) | ✅ | LLM gateway(MaaS) |
+| [Aliyun Bailian](https://bailian.console.aliyun.com/) | ✅ | LLM gateway(MaaS), LLMOps platform |
+
+## 🤝 Community Contribution
+
+Thanks to the following contributors and everyone in the community for their contributions.
+
+
+<a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
+</a>
+
+

README_JP.md

@@ -0,0 +1,122 @@
+<p align="center">
+<a href="https://langbot.app">
+<img src="https://docs.langbot.app/social.png" alt="LangBot"/>
+</a>
+
+<div align="center">
+
+<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://docs.langbot.app/insight/intro.htmll">機能</a> ｜
+<a href="https://docs.langbot.app/insight/guide.html">デプロイ</a> ｜
+<a href="https://docs.langbot.app/usage/faq.html">FAQ</a> ｜
+<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">
+😎高い安定性、🧩拡張サポート、🦄マルチモーダル - LLMネイティブインスタントメッセージングボットプラットフォーム🤖  
+</div>
+
+<br/>
+
+[![Discord](https://img.shields.io/discord/1335141740050649118?logo=discord&labelColor=%20%235462eb&logoColor=%20%23f5f5f5&color=%20%235462eb)](https://discord.gg/wdNEHETs87)
+[![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=Usage(7days))
+<img src="https://img.shields.io/badge/python-3.10 | 3.11 | 3.12-blue.svg" alt="python">
+
+[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md)
+
+</div>
+
+</p>
+
+## ✨ 機能
+
+- 💬 LLM / エージェントとのチャット: 複数のLLMをサポートし、グループチャットとプライベートチャットに対応。マルチラウンドの会話、ツールの呼び出し、マルチモーダル機能をサポート。 [Dify](https://dify.ai) と深く統合。現在、QQ、QQチャンネル、WeCom、Lark、Discord、個人WeChatをサポートし、将来的にはWhatsApp、Telegramなどもサポート予定。
+- 🛠️ 高い安定性、豊富な機能: ネイティブのアクセス制御、レート制限、敏感な単語のフィルタリングなどのメカニズムをサポート。使いやすく、複数のデプロイ方法をサポート。
+- 🧩 プラグイン拡張、活発なコミュニティ: イベント駆動、コンポーネント拡張などのプラグインメカニズムをサポート。豊富なエコシステム、現在数十の[プラグイン](https://docs.langbot.app/plugin/plugin-intro.html)が存在。
+- 😻 [新機能] Web UI: ブラウザを通じてLangBotインスタンスを管理することをサポート。詳細は[ドキュメント](https://docs.langbot.app/webui/intro.html)を参照。
+
+## 📦 始め方
+
+> [!IMPORTANT]
+>
+> - どのデプロイ方法を始める前に、必ず[新規ユーザーガイド](https://docs.langbot.app/insight/guide.html)をお読みください。  
+> - すべてのドキュメントは中国語で提供されています。近い将来、i18nバージョンを提供する予定です。
+
+#### Docker Compose デプロイ
+
+Dockerに慣れているユーザーに適しています。[Dockerデプロイ](https://docs.langbot.app/deploy/langbot/docker.html)のドキュメントを参照してください。
+
+#### BTPanelでのワンクリックデプロイ
+
+LangBotはBTPanelにリストされています。BTPanelをインストールしている場合は、[ドキュメント](https://docs.langbot.app/deploy/langbot/one-click/bt.html)を使用して使用できます。
+
+#### Zeaburクラウドデプロイ
+
+コミュニティが提供するZeaburテンプレート。
+
+[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/zh-CN/templates/ZKTBDH)
+
+#### Railwayクラウドデプロイ
+
+[![Deploy on Railway](https://railway.com/button.svg)](https://railway.app/template/yRrAyL?referralCode=vogKPF)
+
+#### その他のデプロイ方法
+
+リリースバージョンを直接使用して実行します。[手動デプロイ](https://docs.langbot.app/deploy/langbot/manual.html)のドキュメントを参照してください。
+
+## 📸 デモ
+
+<img alt="返信効果（インターネットプラグイン付き）" src="https://docs.langbot.app/QChatGPT-0516.png" width="500px"/>
+
+- WebUIデモ: https://demo.langbot.dev/
+    - ログイン情報: メール: `demo@langbot.app` パスワード: `langbot123456`
+    - 注意: WebUIの効果のみを示しています。公開環境では、機密情報を入力しないでください。
+
+## 🔌 コンポーネントの互換性
+
+### メッセージプラットフォーム
+
+| プラットフォーム | ステータス | 備考 |
+| --- | --- | --- |
+| 個人QQ | ✅ |  |
+| QQ公式API | ✅ |  |
+| WeCom | ✅ |  |
+| 個人WeChat | ✅ | [Gewechat](https://github.com/Devo919/Gewechat)を使用して接続 |
+| Lark | ✅ |  |
+| DingTalk | ✅ |  |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| WhatsApp | 🚧 |  |
+
+🚧: 開発中
+
+### LLMs
+
+| LLM | ステータス | 備考 |
+| --- | --- | --- |
+| [OpenAI](https://platform.openai.com/) | ✅ | 任意のOpenAIインターフェース形式モデルに対応 |
+| [DeepSeek](https://www.deepseek.com/) | ✅ |  |
+| [Moonshot](https://www.moonshot.cn/) | ✅ |  |
+| [Anthropic](https://www.anthropic.com/) | ✅ |  |
+| [xAI](https://x.ai/) | ✅ |  |
+| [Zhipu AI](https://open.bigmodel.cn/) | ✅ |  |
+| [Dify](https://dify.ai) | ✅ | LLMOpsプラットフォーム |
+| [Ollama](https://ollama.com/) | ✅ | ローカルLLM実行プラットフォーム |
+| [LMStudio](https://lmstudio.ai/) | ✅ | ローカルLLM実行プラットフォーム |
+| [GiteeAI](https://ai.gitee.com/) | ✅ | LLMインターフェースゲートウェイ(MaaS) |
+| [SiliconFlow](https://siliconflow.cn/) | ✅ | LLMゲートウェイ(MaaS) |
+| [Aliyun Bailian](https://bailian.console.aliyun.com/) | ✅ | LLMゲートウェイ(MaaS), LLMOpsプラットフォーム |
+
+## 🤝 コミュニティ貢献
+
+以下の貢献者とコミュニティの皆さんの貢献に感謝します。
+
+
+<a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
+</a>
+
+

libs/dingtalk_api/EchoHandler.py

@@ -0,0 +1,29 @@
+import asyncio
+import dingtalk_stream
+from dingtalk_stream import AckMessage
+
+class EchoTextHandler(dingtalk_stream.ChatbotHandler):
+    def __init__(self, client):
+        self.msg_id = ''
+        self.incoming_message = None
+        self.client = client  # 用于更新 DingTalkClient 中的 incoming_message
+
+    """处理钉钉消息"""
+    async def process(self, callback: dingtalk_stream.CallbackMessage):
+        incoming_message = dingtalk_stream.ChatbotMessage.from_dict(callback.data)
+        if incoming_message.message_id != self.msg_id:
+            self.msg_id = incoming_message.message_id
+
+        await self.client.update_incoming_message(incoming_message)
+
+        return AckMessage.STATUS_OK, 'OK'
+    
+    async def get_incoming_message(self):
+        """异步等待消息的到来"""
+        while self.incoming_message is None:
+            await asyncio.sleep(0.1)  # 异步等待，避免阻塞
+        return self.incoming_message
+
+async def get_dingtalk_client(client_id, client_secret):
+    from api import DingTalkClient  # 延迟导入，避免循环导入
+    return DingTalkClient(client_id, client_secret)

libs/dingtalk_api/api.py

@@ -0,0 +1,174 @@
+import base64
+import time
+from typing import Callable
+import dingtalk_stream
+from .EchoHandler import EchoTextHandler
+from .dingtalkevent import DingTalkEvent
+import httpx
+import traceback
+
+
+class DingTalkClient:
+    def __init__(self, client_id: str, client_secret: str,robot_name:str,robot_code:str):
+        """初始化 WebSocket 连接并自动启动"""
+        self.credential = dingtalk_stream.Credential(client_id, client_secret)
+        self.client = dingtalk_stream.DingTalkStreamClient(self.credential)
+        self.key = client_id
+        self.secret = client_secret
+        # 在 DingTalkClient 中传入自己作为参数，避免循环导入
+        self.EchoTextHandler = EchoTextHandler(self)
+        self.client.register_callback_handler(dingtalk_stream.chatbot.ChatbotMessage.TOPIC, self.EchoTextHandler)
+        self._message_handlers = {
+            "example":[],
+        }
+        self.access_token = ''
+        self.robot_name = robot_name
+        self.robot_code = robot_code
+        self.access_token_expiry_time = ''
+
+
+
+    async def get_access_token(self):
+        url = "https://api.dingtalk.com/v1.0/oauth2/accessToken"
+        headers = {
+            "Content-Type": "application/json"
+        }
+        data = {
+            "appKey": self.key,
+            "appSecret": self.secret
+        }
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(url,json=data,headers=headers)
+                if response.status_code == 200:
+                    response_data = response.json()
+                    self.access_token = response_data.get("accessToken")
+                    expires_in = int(response_data.get("expireIn",7200))
+                    self.access_token_expiry_time = time.time() + expires_in - 60
+            except Exception as e:
+                raise Exception(e)
+
+
+    async def is_token_expired(self):
+        """检查token是否过期"""
+        if self.access_token_expiry_time is None:
+            return True
+        return time.time() > self.access_token_expiry_time
+            
+    async def check_access_token(self):
+        if not self.access_token or await self.is_token_expired():
+            return False
+        return bool(self.access_token and self.access_token.strip())
+
+    async def download_image(self,download_code:str):
+        if not await self.check_access_token():
+            await self.get_access_token()
+        url = 'https://api.dingtalk.com/v1.0/robot/messageFiles/download'
+        params = {
+            "downloadCode":download_code,
+            "robotCode":self.robot_code
+        }
+        headers ={
+            "x-acs-dingtalk-access-token": self.access_token
+        }
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, headers=headers, json=params)
+            if response.status_code == 200:
+                result = response.json()
+                download_url = result.get("downloadUrl")
+            else:
+                raise Exception(f"Error: {response.status_code}, {response.text}")
+
+        if download_url:
+            return await self.download_url_to_base64(download_url)
+
+    async def download_url_to_base64(self,download_url):
+        async with httpx.AsyncClient() as client:
+            response = await client.get(download_url)
+            
+            if response.status_code == 200:
+                
+                file_bytes = response.content
+                base64_str = base64.b64encode(file_bytes).decode('utf-8')  # 返回字符串格式
+                return base64_str
+            else:
+                raise Exception("获取图片失败")
+
+    async def update_incoming_message(self, message):
+        """异步更新 DingTalkClient 中的 incoming_message"""
+        message_data = await self.get_message(message)
+        if message_data:
+            event = DingTalkEvent.from_payload(message_data)
+            if event:
+                await self._handle_message(event)
+        
+
+    async def send_message(self,content:str,incoming_message):
+        self.EchoTextHandler.reply_text(content,incoming_message)
+    
+
+    async def get_incoming_message(self):
+        """获取收到的消息"""
+        return await self.EchoTextHandler.get_incoming_message()
+
+
+
+    def on_message(self, msg_type: str):
+        def decorator(func: Callable[[DingTalkEvent], 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: DingTalkEvent):
+        """
+        处理消息事件。
+        """
+        msg_type = event.conversation
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+
+    async def get_message(self,incoming_message:dingtalk_stream.chatbot.ChatbotMessage):
+        try:
+            message_data = {
+                "IncomingMessage":incoming_message,
+            }
+            if str(incoming_message.conversation_type) == '1':
+                message_data["conversation_type"] = 'FriendMessage'
+            elif str(incoming_message.conversation_type) == '2':
+                message_data["conversation_type"] = 'GroupMessage'
+
+            
+            if incoming_message.message_type == 'richText':
+            
+                data = incoming_message.rich_text_content.to_dict()
+                for item in data['richText']:
+                    if 'text' in item:
+                        message_data["Content"] = item['text']
+                    if incoming_message.get_image_list()[0]:
+                        message_data["Picture"] = await self.download_image(incoming_message.get_image_list()[0])
+                message_data["Type"] = 'text'
+            
+            elif incoming_message.message_type == 'text':
+                message_data['Content'] = incoming_message.get_text_list()[0]
+
+                message_data["Type"] = 'text'
+            elif incoming_message.message_type == 'picture':
+                message_data['Picture'] = await self.download_image(incoming_message.get_image_list()[0])
+                
+                message_data['Type'] = 'image'
+
+            # 删掉开头的@消息
+            if message_data["Content"].startswith("@"+self.robot_name):
+                message_data["Content"][len("@"+self.robot_name):]
+        except Exception:
+            traceback.print_exc()
+            
+        return message_data
+    
+    async def start(self):
+        """启动 WebSocket 连接，监听消息"""
+        await self.client.start() 

libs/dingtalk_api/dingtalkevent.py

@@ -0,0 +1,64 @@
+from typing import Dict, Any, Optional
+
+class DingTalkEvent(dict):
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional["DingTalkEvent"]:
+        try:
+            event = DingTalkEvent(payload)
+            return event
+        except KeyError:
+            return None
+        
+    
+    @property
+    def content(self):
+        return self.get("Content","")
+
+    @property
+    def incoming_message(self):
+        return self.get("IncomingMessage")
+
+    @property
+    def type(self):
+        return self.get("Type","")
+    
+    @property
+    def picture(self):
+        return self.get("Picture","")
+
+    @property
+    def conversation(self):
+        return self.get("conversation_type","")
+    
+    
+
+    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__()}>"

libs/official_account_api/api.py

@@ -0,0 +1,176 @@
+# 微信公众号的加解密算法与企业微信一样，所以直接使用企业微信的加解密算法文件
+import time
+import traceback
+from ..wecom_api.WXBizMsgCrypt3 import WXBizMsgCrypt
+import xml.etree.ElementTree as ET
+from quart import Quart,request
+import hashlib
+from typing import Callable, Dict, Any
+from .oaevent import OAEvent
+import httpx
+
+import asyncio
+import time
+import xml.etree.ElementTree as ET
+
+
+
+xml_template = """
+<xml>
+    <ToUserName><![CDATA[{to_user}]]></ToUserName>
+    <FromUserName><![CDATA[{from_user}]]></FromUserName>
+    <CreateTime>{create_time}</CreateTime>
+    <MsgType><![CDATA[text]]></MsgType>
+    <Content><![CDATA[{content}]]></Content>
+</xml>
+"""
+
+class OAClient():
+
+    def __init__(self,token:str,EncodingAESKey:str,AppID:str,Appsecret:str):
+        self.token = token
+        self.aes = EncodingAESKey
+        self.appid = AppID
+        self.appsecret = Appsecret
+        self.base_url = 'https://api.weixin.qq.com'
+        self.access_token = ''
+        self.app = Quart(__name__)
+        self.app.add_url_rule('/callback/command', 'handle_callback', self.handle_callback_request, methods=['GET', 'POST'])
+        self._message_handlers = {
+            "example":[],
+        }
+        self.access_token_expiry_time = None
+        self.msg_id_map = {}
+
+    async def handle_callback_request(self):
+
+        try:
+            # 每隔100毫秒查询是否生成ai回答
+            start_time = time.time()
+            signature = request.args.get("signature", "")
+            timestamp = request.args.get("timestamp", "")
+            nonce = request.args.get("nonce", "")
+            echostr = request.args.get("echostr", "")
+            msg_signature = request.args.get("msg_signature","")
+            if msg_signature is None:
+                raise Exception("msg_signature不在请求体中")
+
+            if request.method == 'GET':
+                # 校验签名
+                check_str = "".join(sorted([self.token, timestamp, nonce]))
+                check_signature = hashlib.sha1(check_str.encode("utf-8")).hexdigest()
+                
+                if check_signature == signature:
+                    return echostr  # 验证成功返回echostr
+                else:
+                    raise Exception("拒绝请求")
+            elif request.method == "POST":
+                encryt_msg = await request.data
+                wxcpt =  WXBizMsgCrypt(self.token,self.aes,self.appid)
+                ret,xml_msg = wxcpt.DecryptMsg(encryt_msg,msg_signature,timestamp,nonce)
+                xml_msg = xml_msg.decode('utf-8')
+
+                if ret != 0:
+                    raise Exception("消息解密失败")
+
+                message_data = await self.get_message(xml_msg)
+                if message_data :
+                    event = OAEvent.from_payload(message_data)
+                    if event:
+                        await self._handle_message(event)
+
+                root = ET.fromstring(xml_msg)
+                from_user = root.find("FromUserName").text  # 发送者
+                to_user = root.find("ToUserName").text  # 机器人
+                
+                from pkg.platform.sources import officialaccount
+                
+                timeout = 4.80
+                interval = 0.1
+                while True:
+                    content = officialaccount.generated_content.pop(message_data["MsgId"], None)
+                    if content:
+                        response_xml = xml_template.format(
+                            to_user=from_user,
+                            from_user=to_user,
+                            create_time=int(time.time()),
+                            content = content
+                        )
+
+                        return response_xml
+                    
+                    if time.time() - start_time >= timeout:
+                        break
+                    
+                    await asyncio.sleep(interval)
+
+                if self.msg_id_map.get(message_data["MsgId"], 1) == 3:
+
+                    # response_xml = xml_template.format(
+                    #     to_user=from_user,
+                    #     from_user=to_user,
+                    #     create_time=int(time.time()),
+                    #     content = "请求失效：暂不支持公众号超过15秒的请求，如有需求，请联系 LangBot 团队。"
+                    # )
+                    print("请求失效：暂不支持公众号超过15秒的请求，如有需求，请联系 LangBot 团队。")
+                    return ''
+
+        except Exception as e:
+            traceback.print_exc()
+
+    
+    async def get_message(self, xml_msg: str):
+
+        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,
+        }
+
+        return message_data
+
+
+    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[[OAEvent], 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: OAEvent):
+        """
+        处理消息事件。
+        """
+        message_id = event.message_id
+        if message_id in self.msg_id_map.keys():
+            self.msg_id_map[message_id] += 1
+            return
+
+        self.msg_id_map[message_id] = 1
+        msg_type = event.type
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+
+            
+
+            
+
+

libs/official_account_api/oaevent.py

@@ -0,0 +1,167 @@
+from typing import Dict, Any, Optional
+
+
+class OAEvent(dict):
+    """
+    封装从微信公众号收到的事件数据对象（字典），提供属性以获取其中的字段。
+
+    除 `type` 和 `detail_type` 属性对于任何事件都有效外，其它属性是否存在（若不存在则返回 `None`）依事件类型不同而不同。
+    """
+
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional["OAEvent"]:
+        """
+        从微信公众号事件数据构造 `WecomEvent` 对象。
+
+        Args:
+            payload (Dict[str, Any]): 解密后的微信事件数据。
+
+        Returns:
+            Optional[OAEvent]: 如果事件数据合法，则返回 OAEvent 对象；否则返回 None。
+        """
+        try:
+            event = OAEvent(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]:
+        """
+        发送方账号
+        """
+        return self.get("FromUserName")
+
+
+    @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__()}>"

libs/qq_official_api/api.py

@@ -0,0 +1,274 @@
+import time
+from quart import request
+import base64
+import binascii
+import httpx
+from quart import Quart
+import xml.etree.ElementTree as ET
+from typing import Callable, Dict, Any
+from pkg.platform.types import events as platform_events, message as platform_message
+import aiofiles
+from .qqofficialevent import QQOfficialEvent
+import json
+import hmac
+import base64
+import hashlib
+import traceback
+from cryptography.hazmat.primitives.asymmetric import ed25519
+from .qqofficialevent import QQOfficialEvent
+
+def handle_validation(body: dict, bot_secret: str):
+    
+    # bot正确的secert是32位的，此处仅为了适配演示demo
+    while len(bot_secret) < 32:
+        bot_secret = bot_secret * 2
+    bot_secret = bot_secret[:32]
+    # 实际使用场景中以上三行内容可清除
+
+    seed_bytes = bot_secret.encode()
+
+    signing_key = ed25519.Ed25519PrivateKey.from_private_bytes(seed_bytes)
+
+    msg = body['d']['event_ts'] + body['d']['plain_token']
+    msg_bytes = msg.encode()
+
+    signature = signing_key.sign(msg_bytes)
+
+    signature_hex = signature.hex()
+
+    response = {
+        "plain_token": body['d']['plain_token'],
+        "signature": signature_hex
+    }
+
+    return response
+
+class QQOfficialClient:
+    def __init__(self, secret: str, token: str, app_id: str):
+        self.app = Quart(__name__)
+        self.app.add_url_rule(
+            "/callback/command",
+            "handle_callback",
+            self.handle_callback_request,
+            methods=["GET", "POST"],
+        )
+        self.secret = secret
+        self.token = token
+        self.app_id = app_id
+        self._message_handlers = {
+        }
+        self.base_url = "https://api.sgroup.qq.com"
+        self.access_token = ""
+        self.access_token_expiry_time = None
+
+    async def check_access_token(self):
+        """检查access_token是否存在"""
+        if not self.access_token or await self.is_token_expired():
+            return False
+        return bool(self.access_token and self.access_token.strip())
+    
+    async def get_access_token(self):
+        """获取access_token"""
+        url = "https://bots.qq.com/app/getAppAccessToken"
+        async with httpx.AsyncClient() as client:
+            params = {
+                "appId":self.app_id,
+                "clientSecret":self.secret,
+            }
+            headers = {
+                "content-type":"application/json",
+            }
+            try:
+                response = await client.post(url,json=params,headers=headers)
+                if response.status_code == 200:
+                    response_data = response.json()
+                access_token = response_data.get("access_token")
+                expires_in = int(response_data.get("expires_in",7200))
+                self.access_token_expiry_time = time.time() + expires_in - 60
+                if access_token:
+                    self.access_token = access_token
+            except Exception as e:
+                raise Exception(f"获取access_token失败: {e}")
+
+
+    async def handle_callback_request(self):
+        """处理回调请求"""
+        try:
+            # 读取请求数据
+            body = await request.get_data()
+            payload = json.loads(body)
+
+            
+            # 验证是否为回调验证请求
+            if payload.get("op") == 13:
+                # 生成签名
+                response = handle_validation(payload, self.secret)
+
+                return response
+
+            if payload.get("op") == 0:
+                    message_data = await self.get_message(payload)
+                    if message_data:
+                        event = QQOfficialEvent.from_payload(message_data)
+                        await self._handle_message(event)
+            
+            return {"code": 0, "message": "success"}
+
+        except Exception as e:
+            traceback.print_exc()
+            return {"error": 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[[platform_events.Event], 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:QQOfficialEvent):
+        """处理消息事件"""
+        msg_type = event.t
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+
+    async def get_message(self,msg:dict) -> Dict[str,Any]:
+        """获取消息"""
+        message_data = {
+            "t":  msg.get("t",{}),
+            "user_openid": msg.get("d",{}).get("author",{}).get("user_openid",{}),
+            "timestamp": msg.get("d",{}).get("timestamp",{}),
+            "d_author_id": msg.get("d",{}).get("author",{}).get("id",{}),
+            "content": msg.get("d",{}).get("content",{}),
+            "d_id": msg.get("d",{}).get("id",{}),
+            "id": msg.get("id",{}),
+            "channel_id": msg.get("d",{}).get("channel_id",{}),
+            "username": msg.get("d",{}).get("author",{}).get("username",{}),
+            "guild_id": msg.get("d",{}).get("guild_id",{}),
+            "member_openid": msg.get("d",{}).get("author",{}).get("openid",{}),
+            "group_openid": msg.get("d",{}).get("group_openid",{})
+        }
+        attachments = msg.get("d", {}).get("attachments", [])
+        image_attachments = [attachment['url'] for attachment in attachments if await self.is_image(attachment)]
+        image_attachments_type = [attachment['content_type'] for attachment in attachments if await self.is_image(attachment)]
+        if image_attachments:
+            message_data["image_attachments"] = image_attachments[0]
+            message_data["content_type"] = image_attachments_type[0]
+        else:
+            
+            message_data["image_attachments"] = None
+        
+        return message_data
+    
+
+    async def is_image(self,attachment:dict) -> bool:
+        """判断是否为图片附件"""
+        content_type = attachment.get("content_type","")
+        return content_type.startswith("image/")
+    
+    
+    async def send_private_text_msg(self,user_openid:str,content:str,msg_id:str):
+        """发送私聊消息"""
+        if not await self.check_access_token():
+             await self.get_access_token()
+
+        url = self.base_url + "/v2/users/" + user_openid + "/messages"
+        async with httpx.AsyncClient() as client:
+            headers = {
+                "Authorization": f"QQBot {self.access_token}",
+                "Content-Type": "application/json",
+            }
+            data = {
+                "content": content,
+                "msg_type": 0,
+                "msg_id": msg_id,
+            }
+            response = await client.post(url,headers=headers,json=data)
+            if response.status_code == 200:
+                return
+            else:
+                raise ValueError(response)
+    
+
+    async def send_group_text_msg(self,group_openid:str,content:str,msg_id:str):
+        """发送群聊消息"""
+        if not await self.check_access_token():
+            await self.get_access_token()
+
+        url = self.base_url + "/v2/groups/" + group_openid + "/messages"
+        async with httpx.AsyncClient() as client:
+            headers = {
+                "Authorization": f"QQBot {self.access_token}",
+                "Content-Type": "application/json",
+            }
+            data = {
+                "content": content,
+                "msg_type": 0,
+                "msg_id": msg_id,
+            }
+            response = await client.post(url,headers=headers,json=data)
+            if response.status_code == 200:
+                return
+            else:
+                raise Exception(response.read().decode())
+
+    async def send_channle_group_text_msg(self,channel_id:str,content:str,msg_id:str):
+        """发送频道群聊消息"""
+        if not await self.check_access_token():
+             await self.get_access_token()
+
+        url = self.base_url + "/channels/" + channel_id + "/messages"
+        async with httpx.AsyncClient() as client:
+            headers = {
+                "Authorization": f"QQBot {self.access_token}",
+                "Content-Type": "application/json",
+            }
+            params = {
+                "content": content,
+                "msg_type": 0,
+                "msg_id": msg_id,
+            }
+            response = await client.post(url,headers=headers,json=params)
+            if response.status_code == 200:
+                return True
+            else:
+                raise Exception(response)
+
+    async def send_channle_private_text_msg(self,guild_id:str,content:str,msg_id:str):
+        """发送频道私聊消息"""
+        if not await self.check_access_token():
+             await self.get_access_token()
+
+        url = self.base_url + "/dms/" + guild_id + "/messages"
+        async with httpx.AsyncClient() as client:
+            headers = {
+                "Authorization": f"QQBot {self.access_token}",
+                "Content-Type": "application/json",
+            }
+            params = {
+                "content": content,
+                "msg_type": 0,
+                "msg_id": msg_id,
+            }
+            response = await client.post(url,headers=headers,json=params)
+            if response.status_code == 200:
+                return True
+            else:
+                raise Exception(response)
+
+    async def is_token_expired(self):
+        """检查token是否过期"""
+        if self.access_token_expiry_time is None:
+            return True
+        return time.time() > self.access_token_expiry_time

libs/qq_official_api/qqofficialevent.py

@@ -0,0 +1,114 @@
+from typing import Dict, Any, Optional
+
+class QQOfficialEvent(dict):
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional["QQOfficialEvent"]:
+        try:
+            event = QQOfficialEvent(payload)
+            return event
+        except KeyError:
+            return None
+        
+
+    @property
+    def t(self) -> str:
+        """
+        事件类型
+        """
+        return self.get("t", "")
+    
+    @property
+    def user_openid(self) -> str:
+        """
+        用户openid
+        """
+        return self.get("user_openid",{})
+    
+    @property
+    def timestamp(self) -> str:
+        """
+        时间戳
+        """
+        return self.get("timestamp",{})
+    
+    
+    @property
+    def d_author_id(self) -> str:
+        """
+        作者id
+        """
+        return self.get("id",{})
+    
+    @property
+    def content(self) -> str:
+        """
+        内容
+        """
+        return self.get("content",'')
+    
+    @property
+    def d_id(self) -> str:
+        """
+        d_id
+        """
+        return self.get("d_id",{})
+    
+    @property
+    def id(self) -> str:
+        """
+        消息id，msg_id
+        """
+        return self.get("id",{})
+    
+    @property
+    def channel_id(self) -> str:
+        """
+        频道id
+        """
+        return self.get("channel_id",{})
+    
+    @property
+    def username(self) -> str:
+        """
+        用户名
+        """
+        return self.get("username",{})
+    
+    @property
+    def guild_id(self) -> str:
+        """
+        频道id
+        """
+        return self.get("guild_id",{})
+    
+    @property
+    def member_openid(self) -> str:
+        """
+        成员openid
+        """
+        return self.get("openid",{})
+    
+    @property
+    def attachments(self) -> str:
+        """
+        附件url
+        """
+        url = self.get("image_attachments", "")
+        if url and not url.startswith("https://"):
+            url = "https://" + url
+        return url
+    
+    @property
+    def group_openid(self) -> str:
+        """
+        群组id
+        """
+        return self.get("group_openid",{})
+    
+    @property
+    def content_type(self) -> str:
+        """
+        文件类型
+        """
+        return self.get("content_type","")
+    

libs/wecom_api/api.py

@@ -110,8 +110,17 @@ class WecomClient():
                 "enable_duplicate_check": 0,
                 "duplicate_check_interval": 1800
             }
-            response = await client.post(url,json=params)
-            data = response.json()
+            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))
             
@@ -120,7 +129,6 @@ class WecomClient():
             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,
@@ -136,7 +144,9 @@ class WecomClient():
             }
             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))
 
@@ -217,7 +227,7 @@ class WecomClient():
         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
@@ -286,11 +296,14 @@ class WecomClient():
         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")
 
-            return data.get('media_id')
-
+            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:

pkg/core/bootutils/deps.py

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

pkg/core/migrations/m020_wecom_config.py

@@ -10,11 +10,12 @@ 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
+        # for adapter in self.ap.platform_cfg.data['platform-adapters']:
+        #     if adapter['adapter'] == 'wecom':
+        #         return False
 
-        return True
+        # return True
+        return False
 
     async def run(self):
         """执行迁移"""

pkg/core/migrations/m021_lark_config.py

@@ -0,0 +1,33 @@
+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
+        return False
+
+    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",
+            "enable-webhook": False,
+            "port": 2285,
+            "encrypt-key": "xxxxxxxxx"
+        })
+
+        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,29 @@
+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
+        return False
+
+    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/migrations/m025_gewechat_config.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("gewechat-config", 25)
+class GewechatConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        
+        # for adapter in self.ap.platform_cfg.data['platform-adapters']:
+        #     if adapter['adapter'] == 'gewechat':
+        #         return False
+
+        # return True
+        return False
+
+    async def run(self):
+        """执行迁移"""
+        self.ap.platform_cfg.data['platform-adapters'].append({
+            "adapter": "gewechat",
+            "enable": False,
+            "gewechat_url": "http://your-gewechat-server:2531",
+            "port": 2286,
+            "callback_url": "http://your-callback-url:2286/gewechat/callback",
+            "app_id": "",
+            "token": ""
+        })
+
+        await self.ap.platform_cfg.dump_config()

pkg/core/migrations/m026_qqofficial_config.py

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

pkg/core/migrations/m027_wx_official_account_config.py

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

pkg/core/migrations/m028_aliyun_requester_config.py

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

pkg/core/migrations/m029_dashscope_app_api_config.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("dashscope-app-api-config", 29)
+class DashscopeAppAPICfgMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return 'dashscope-app-api' not in self.ap.provider_cfg.data
+
+    async def run(self):
+        """执行迁移"""
+        self.ap.provider_cfg.data['dashscope-app-api'] = {
+            "app-type": "agent",
+            "api-key": "sk-1234567890",
+            "agent": {
+                "app-id": "Your_app_id",
+                "references_quote": "参考资料来自:"
+            },
+            "workflow": {
+                "app-id": "Your_app_id",
+                "references_quote": "参考资料来自:",
+                "biz_params": {  
+                    "city": "北京",
+                    "date": "2023-08-10"
+                }
+            }
+        }
+
+        await self.ap.provider_cfg.dump_config()

pkg/core/migrations/m030_lark_config_cmpl.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("lark-config-cmpl", 30)
+class LarkConfigCmplMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] == 'lark':
+                if 'enable-webhook' not in adapter:
+                    return True
+
+        return False
+
+    async def run(self):
+        """执行迁移"""
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] == 'lark':
+                if 'enable-webhook' not in adapter:
+                    adapter['enable-webhook'] = False
+                if 'port' not in adapter:
+                    adapter['port'] = 2285
+                if 'encrypt-key' not in adapter:
+                    adapter['encrypt-key'] = "xxxxxxxxx"
+
+        await self.ap.platform_cfg.dump_config()

pkg/core/migrations/m031_dingtalk_config.py

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

pkg/core/notes/n003_print_version.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import typing
+import os
+import sys
+import logging
+
+from .. import note, app
+
+
+@note.note_class("PrintVersion", 3)
+class PrintVersion(note.LaunchNote):
+    """打印版本信息
+    """
+
+    async def need_show(self) -> bool:
+        return True
+
+    async def yield_note(self) -> typing.AsyncGenerator[typing.Tuple[str, int], None]:
+
+        yield f"当前版本：{self.ap.ver_mgr.get_current_version()}", logging.INFO

pkg/core/stages/migrate.py

@@ -8,7 +8,9 @@ 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
+from ..migrations import m020_wecom_config, m021_lark_config, m022_lmstudio_config, m023_siliconflow_config, m024_discord_config, m025_gewechat_config
+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
 
 
 @stage.stage_class("MigrationStage")

pkg/core/stages/show_notes.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from .. import stage, app, note
-from ..notes import n001_classic_msgs, n002_selection_mode_on_windows
+from ..notes import n001_classic_msgs, n002_selection_mode_on_windows, n003_print_version
 
 
 @stage.stage_class("ShowNotesStage")

pkg/pipeline/longtext/strategies/forward.py

@@ -9,30 +9,8 @@ from ....core import entities as core_entities
 from ....platform.types import message as platform_message
 
 
-class ForwardMessageDiaplay(pydantic.BaseModel):
-    title: str = "群聊的聊天记录"
-    brief: str = "[聊天记录]"
-    source: str = "聊天记录"
-    preview: typing.List[str] = []
-    summary: str = "查看x条转发消息"
-
-
-class Forward(platform_message.MessageComponent):
-    """合并转发。"""
-    type: str = "Forward"
-    """消息组件类型。"""
-    display: ForwardMessageDiaplay
-    """显示信息"""
-    node_list: typing.List[platform_message.ForwardMessageNode]
-    """转发消息节点列表。"""
-    def __init__(self, *args, **kwargs):
-        if len(args) == 1:
-            self.node_list = args[0]
-            super().__init__(**kwargs)
-        super().__init__(*args, **kwargs)
-
-    def __str__(self):
-        return '[聊天记录]'
+ForwardMessageDiaplay = platform_message.ForwardMessageDiaplay
+Forward = platform_message.Forward
 
 
 @strategy_model.strategy_class("forward")

pkg/pipeline/wrapper/wrapper.py

@@ -102,7 +102,7 @@ class ResponseWrapper(stage.PipelineStage):
                                 new_query=query
                             )
 
-                    if result.tool_calls is not None:  # 有函数调用
+                    if result.tool_calls is not None and len(result.tool_calls) > 0:  # 有函数调用
                         
                         function_names = [tc.function.name for tc in result.tool_calls]
 

pkg/platform/manager.py

@@ -7,6 +7,8 @@ import logging
 import asyncio
 import traceback
 
+from .sources import qqofficial
+
 #     FriendMessage, Image, MessageChain, Plain
 from ..platform import adapter as msadapter
 
@@ -37,7 +39,7 @@ class PlatformManager:
     
     async def initialize(self):
 
-        from .sources import nakuru, aiocqhttp, qqbotpy,wecom
+        from .sources import nakuru, aiocqhttp, qqbotpy, qqofficial, wecom, lark, discord, gewechat, officialaccount, telegram, dingtalk
 
         async def on_friend_message(event: platform_events.FriendMessage, adapter: msadapter.MessageSourceAdapter):
 
@@ -100,6 +102,35 @@ class PlatformManager:
         if len(self.adapters) == 0:
             self.ap.logger.warning('未运行平台适配器，请根据文档配置并启用平台适配器。')
 
+    async def write_back_config(self, adapter_inst: msadapter.MessageSourceAdapter, config: dict):
+        index = -2
+
+        for i, adapter in enumerate(self.adapters):
+            if adapter == adapter_inst:
+                index = i
+                break
+
+        if index == -2:
+            raise Exception('平台适配器未找到')
+
+        # 只修改启用的适配器
+        real_index = -1
+
+        for i, adapter in enumerate(self.ap.platform_cfg.data['platform-adapters']):
+            if adapter['enable']:
+                index -= 1
+                if index == -1:
+                    real_index = i
+                    break
+
+        new_cfg = {
+            'adapter': adapter_inst.name,
+            'enable': True,
+            **config
+        }
+        self.ap.platform_cfg.data['platform-adapters'][real_index] = new_cfg
+        await self.ap.platform_cfg.dump_config()
+
     async def send(self, event: platform_events.MessageEvent, msg: platform_message.MessageChain, adapter: msadapter.MessageSourceAdapter):
         
         if self.ap.platform_cfg.data['at-sender'] and isinstance(event, platform_events.GroupMessage):

pkg/platform/sources/dingtalk.py

@@ -0,0 +1,182 @@
+
+import traceback
+import typing
+from libs.dingtalk_api.dingtalkevent import DingTalkEvent
+from pkg.platform.types import message as platform_message
+from pkg.platform.adapter import MessageSourceAdapter
+from pkg.platform.types import events as platform_events, message as platform_message
+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 libs.dingtalk_api.api import DingTalkClient
+import datetime
+
+
+class DingTalkMessageConverter(adapter.MessageConverter):
+
+    @staticmethod
+    async def yiri2target(
+        message_chain:platform_message.MessageChain
+    ):
+        for msg in message_chain:
+            if type(msg) is platform_message.Plain:
+                return msg.text
+
+    @staticmethod
+    async def target2yiri(event:DingTalkEvent):
+        yiri_msg_list = []
+        yiri_msg_list.append(
+            platform_message.Source(id = '0',time=datetime.datetime.now())
+        )
+
+        if event.content:
+            yiri_msg_list.append(platform_message.Plain(text=event.content))
+        if event.picture:
+            yiri_msg_list.append(platform_message.Image(base64=event.picture))
+
+        chain = platform_message.MessageChain(yiri_msg_list)
+        
+        return chain
+
+
+class DingTalkEventConverter(adapter.EventConverter):
+
+    @staticmethod
+    async def yiri2target(
+        event:platform_events.MessageEvent
+    ):
+        return event.source_platform_object
+
+    @staticmethod
+    async def target2yiri(
+        event:DingTalkEvent
+    ):
+        
+        message_chain = await DingTalkMessageConverter.target2yiri(event)
+
+
+        if event.conversation == 'FriendMessage':
+
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id= 0,
+                    nickname ='nickname',
+                    remark=""
+                ),
+                message_chain = message_chain,
+                time = datetime.datetime.now(),
+                source_platform_object=event,
+            )
+        elif event.conversation == 'GroupMessage':
+            message_chain.insert(0, platform_message.At(target="justbot"))
+            sender = platform_entities.GroupMember(
+                id = 111,
+                member_name="name",
+                permission= 'MEMBER',
+                group = platform_entities.Group(
+                    id = 111,
+                    name = 'MEMBER',
+                    permission=platform_entities.Permission.Member
+                ),
+                special_title='',
+                join_timestamp=0,
+                last_speak_timestamp=0,
+                mute_time_remaining=0
+            )
+            time = datetime.datetime.now(),
+            return platform_events.GroupMessage(
+                sender =sender,
+                message_chain = message_chain,
+                time = time,
+                source_platform_object=event
+            )
+
+@adapter.adapter_class("dingtalk")
+class DingTalkAdapter(adapter.MessageSourceAdapter):
+    bot: DingTalkClient
+    ap: app.Application
+    bot_account_id: str
+    message_converter: DingTalkMessageConverter = DingTalkMessageConverter()
+    event_converter: DingTalkEventConverter = DingTalkEventConverter()
+    config: dict
+
+    def __init__(self,config:dict,ap:app.Application):
+        self.config = config
+        self.ap = ap
+        required_keys = [
+            "client_id",
+            "client_secret",
+            "robot_name",
+            "robot_code",
+        ]
+        missing_keys = [key for key in required_keys if key not in config]
+        if missing_keys:
+            raise ParamNotEnoughError("钉钉缺少相关配置项，请查看文档或联系管理员")
+        
+        self.bot = DingTalkClient(
+            client_id=config["client_id"],
+            client_secret=config["client_secret"],
+            robot_name = config["robot_name"],
+            robot_code=config["robot_code"]
+        )
+    
+    async def reply_message(
+        self,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
+        quote_origin: bool = False,
+    ):
+        event = await DingTalkEventConverter.yiri2target(
+            message_source,
+        )
+        incoming_message = event.incoming_message
+
+        content = await DingTalkMessageConverter.yiri2target(message)
+        await self.bot.send_message(content,incoming_message)
+
+
+    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: DingTalkEvent):
+            self.bot_account_id = 'justbot'
+            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("FriendMessage")(on_message)
+        elif event_type == platform_events.GroupMessage:
+            self.bot.on_message("GroupMessage")(on_message)
+
+    async def run_async(self):
+
+        await self.bot.start()
+
+    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/sources/discord.py

@@ -0,0 +1,269 @@
+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
+            elif isinstance(ele, platform_message.Forward):
+                for node in ele.node_list:
+                    text_string, image_files = await DiscordMessageConverter.yiri2target(node.message_chain)
+                    text_string += text_string
+                    image_files.extend(image_files)
+
+        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/gewechat.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import gewechat_client
+
+import typing
+import asyncio
+import traceback
+import time
+import re
+import base64
+import uuid
+import json
+import os
+import copy
+import datetime
+import threading
+
+import quart
+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 GewechatMessageConverter(adapter.MessageConverter):
+    
+    @staticmethod
+    async def yiri2target(
+        message_chain: platform_message.MessageChain
+    ) -> list[dict]:
+        content_list = []
+        for component in message_chain:
+            if isinstance(component, platform_message.At):
+                content_list.append({"type": "at", "target": component.target})
+            elif isinstance(component, platform_message.Plain):
+                content_list.append({"type": "text", "content": component.text})
+            elif isinstance(component, platform_message.Image):
+                # content_list.append({"type": "image", "image_id": component.image_id})
+                pass
+            elif isinstance(component, platform_message.Forward):
+                for node in component.node_list:
+                    content_list.extend(await GewechatMessageConverter.yiri2target(node.message_chain))
+
+        return content_list
+
+    @staticmethod
+    async def target2yiri(
+        message: dict,
+        bot_account_id: str
+    ) -> platform_message.MessageChain:
+        
+        if message["Data"]["MsgType"] == 1:
+            # 检查消息开头，如果有 wxid_sbitaz0mt65n22:\n 则删掉
+            regex = re.compile(r"^wxid_.*:")
+
+            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:])
+
+            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)))
+            else:
+                content_list = [platform_message.Plain(message["Data"]["Content"]["string"])]
+
+            return platform_message.MessageChain(content_list)
+                    
+        elif message["Data"]["MsgType"] == 3:
+            image_base64 = message["Data"]["ImgBuf"]["buffer"]
+            return platform_message.MessageChain(
+                [platform_message.Image(base64=f"data:image/jpeg;base64,{image_base64}")]
+            )
+
+class GewechatEventConverter(adapter.EventConverter):
+    
+    @staticmethod
+    async def yiri2target(
+        event: platform_events.MessageEvent
+    ) -> dict:
+        pass
+
+    @staticmethod
+    async def target2yiri(
+        event: dict,
+        bot_account_id: str
+    ) -> platform_events.MessageEvent:
+        message_chain = await GewechatMessageConverter.target2yiri(copy.deepcopy(event), bot_account_id)
+
+        if not message_chain:
+            return None
+        
+        if '@chatroom' in event["Data"]["FromUserName"]["string"]:
+            # 找出开头的 wxid_ 字符串，以:结尾
+            sender_wxid = event["Data"]["Content"]["string"].split(":")[0]
+
+            return platform_events.GroupMessage(
+                sender=platform_entities.GroupMember(
+                    id=sender_wxid,
+                    member_name=event["Data"]["FromUserName"]["string"],
+                    permission=platform_entities.Permission.Member,
+                    group=platform_entities.Group(
+                        id=event["Data"]["FromUserName"]["string"],
+                        name=event["Data"]["FromUserName"]["string"],
+                        permission=platform_entities.Permission.Member,
+                    ),
+                    special_title="",
+                    join_timestamp=0,
+                    last_speak_timestamp=0,
+                    mute_time_remaining=0,
+                ),
+                message_chain=message_chain,
+                time=event["Data"]["CreateTime"],
+                source_platform_object=event,
+            )
+        elif 'wxid_' in event["Data"]["FromUserName"]["string"]:
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id=event["Data"]["FromUserName"]["string"],
+                    nickname=event["Data"]["FromUserName"]["string"],
+                    remark='',
+                ),
+                message_chain=message_chain,
+                time=event["Data"]["CreateTime"],
+                source_platform_object=event,
+            )
+
+
+@adapter.adapter_class("gewechat")
+class GewechatMessageSourceAdapter(adapter.MessageSourceAdapter):
+    
+    bot: gewechat_client.GewechatClient
+    quart_app: quart.Quart
+
+    bot_account_id: str
+
+    config: dict
+
+    ap: app.Application
+
+    message_converter: GewechatMessageConverter = GewechatMessageConverter()
+    event_converter: GewechatEventConverter = GewechatEventConverter()
+
+    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.quart_app = quart.Quart(__name__)
+
+        @self.quart_app.route('/gewechat/callback', methods=['POST'])
+        async def gewechat_callback():
+            data = await quart.request.json
+            # print(json.dumps(data, indent=4, ensure_ascii=False))
+
+            if 'testMsg' in data:
+                return 'ok'
+            elif 'TypeName' in data and data['TypeName'] == 'AddMsg':
+                try:
+
+                    event = await self.event_converter.target2yiri(data.copy(), self.bot_account_id)
+                except Exception as e:
+                    traceback.print_exc()
+
+                if event.__class__ in self.listeners:
+                    await self.listeners[event.__class__](event, self)
+
+                return 'ok'
+
+    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
+    ):
+        content_list = await self.message_converter.yiri2target(message)
+
+        ats = [item["target"] for item in content_list if item["type"] == "at"]
+
+        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)
+                )
+
+    async def is_muted(self, group_id: int) -> bool:
+        pass
+
+    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]
+    ):
+        pass
+
+    async def run_async(self):
+        
+        if not self.config["token"]:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    f"{self.config['gewechat_url']}/v2/api/tools/getTokenId",
+                    json={"app_id": self.config["app_id"]}
+                ) as response:
+                    if response.status != 200:
+                        raise Exception(f"获取gewechat token失败: {await response.text()}")
+                    self.config["token"] = (await response.json())["data"]
+
+        self.bot = gewechat_client.GewechatClient(
+            f"{self.config['gewechat_url']}/v2/api",
+            self.config["token"]
+        )
+
+        app_id, error_msg = self.bot.login(self.config["app_id"])
+        if error_msg:
+            raise Exception(f"Gewechat 登录失败: {error_msg}")
+
+        self.config["app_id"] = app_id
+
+        self.ap.logger.info(f"Gewechat 登录成功，app_id: {app_id}")
+
+        await self.ap.platform_mgr.write_back_config(self, self.config)
+
+        # 获取 nickname
+        profile = self.bot.get_profile(self.config["app_id"])
+        self.bot_account_id = profile["data"]["nickName"]
+
+        def thread_set_callback():
+            time.sleep(3)
+            ret = self.bot.set_callback(self.config["token"], self.config["callback_url"])
+            print('设置 Gewechat 回调：', ret)
+
+        threading.Thread(target=thread_set_callback).start()
+
+        async def shutdown_trigger_placeholder():
+            while True:
+                await asyncio.sleep(1)
+
+        await self.quart_app.run_task(
+            host='0.0.0.0',
+            port=self.config["port"],
+            shutdown_trigger=shutdown_trigger_placeholder,
+        )
+
+    async def kill(self) -> bool:
+        pass

pkg/platform/sources/lark.py

@@ -0,0 +1,493 @@
+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 hashlib
+import base64
+from Crypto.Cipher import AES
+
+import aiohttp
+import lark_oapi.ws.exception
+import quart
+from flask import jsonify
+from lark_oapi.api.im.v1 import *
+from lark_oapi.api.verification.v1 import GetVerificationRequest
+
+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  AESCipher(object):
+    def __init__(self, key):
+        self.bs = AES.block_size
+        self.key=hashlib.sha256(AESCipher.str_to_bytes(key)).digest()
+    @staticmethod
+    def str_to_bytes(data):
+        u_type = type(b"".decode('utf8'))
+        if isinstance(data, u_type):
+            return data.encode('utf8')
+        return data
+    @staticmethod
+    def _unpad(s):
+        return s[:-ord(s[len(s) - 1:])]
+    def decrypt(self, enc):
+        iv = enc[:AES.block_size]
+        cipher = AES.new(self.key, AES.MODE_CBC, iv)
+        return  self._unpad(cipher.decrypt(enc[AES.block_size:]))
+    def decrypt_string(self, enc):
+        enc = base64.b64decode(enc)
+        return  self.decrypt(enc).decode('utf8')
+
+
+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 = []
+            elif isinstance(msg, platform_message.Forward):
+                for node in msg.node_list:
+                    message_elements.extend(await LarkMessageConverter.yiri2target(node.message_chain, api_client))
+
+        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
+    quart_app: quart.Quart
+    ap: app.Application
+
+    def __init__(self, config: dict, ap: app.Application):
+        self.config = config
+        self.ap = ap
+        self.quart_app = quart.Quart(__name__)
+
+        @self.quart_app.route('/lark/callback', methods=['POST'])
+        async def lark_callback():
+            try:
+                data = await quart.request.json
+
+                if 'encrypt' in data:
+                    cipher = AESCipher(self.config['encrypt-key'])
+                    data = cipher.decrypt_string(data['encrypt'])
+                    data = json.loads(data)
+
+                type =  data.get("type")
+                if type is None :
+                    context = EventContext(data)
+                    type = context.header.event_type
+                
+                if 'url_verification' == type:
+                    print(data.get("challenge"))
+                    # todo 验证verification token
+                    return {
+                        "challenge": data.get("challenge")
+                    }
+                context = EventContext(data)
+                type = context.header.event_type
+                p2v1 = P2ImMessageReceiveV1()
+                p2v1.header = context.header
+                event = P2ImMessageReceiveV1Data()
+                event.message = EventMessage(context.event['message'])
+                event.sender = EventSender(context.event['sender'])
+                p2v1.event = event
+                p2v1.schema = context.schema
+                if 'im.message.receive_v1' == type:
+                    try:
+                        event = await self.event_converter.target2yiri(p2v1, self.api_client)
+                    except Exception as e:
+                        traceback.print_exc()
+
+                    if event.__class__ in self.listeners:
+                        await self.listeners[event.__class__](event, self)
+
+                return {"code": 200, "message": "ok"}
+            except Exception as e:
+                traceback.print_exc()
+                return {"code": 500, "message": "error"}
+
+        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):
+        port = self.config['port']
+        enable_webhook = self.config['enable-webhook']
+
+        if not enable_webhook:
+            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
+        else:
+            async def shutdown_trigger_placeholder():
+                while True:
+                    await asyncio.sleep(1)
+
+            await self.quart_app.run_task(
+                host='0.0.0.0',
+                port=port,
+                shutdown_trigger=shutdown_trigger_placeholder,
+            )
+    async def kill(self) -> bool:
+        return False

pkg/platform/sources/officialaccount.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+import typing
+import asyncio
+import traceback
+import time
+import datetime
+from pkg.core import app
+from pkg.platform.adapter import MessageSourceAdapter
+from pkg.platform.types import events as platform_events, message as platform_message
+
+import aiocqhttp
+import aiohttp
+from libs.official_account_api.oaevent import OAEvent
+from pkg.platform.adapter import MessageSourceAdapter
+from pkg.platform.types import events as platform_events, message as platform_message
+from libs.official_account_api.api import OAClient
+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
+
+
+# 生成的ai回答
+generated_content = {}
+
+class OAMessageConverter(adapter.MessageConverter):
+    @staticmethod
+    async def yiri2target(message_chain: platform_message.MessageChain):
+        for msg in message_chain:
+            if type(msg) is platform_message.Plain:
+                return msg.text
+            
+
+    @staticmethod
+    async def target2yiri(message:str,message_id =-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
+        
+
+class OAEventConverter(adapter.EventConverter):
+    @staticmethod
+    async def target2yiri(event:OAEvent):
+        if event.type == "text":
+            yiri_chain = await OAMessageConverter.target2yiri(
+                event.message, event.message_id
+            )
+
+            friend = platform_entities.Friend(
+                id=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
+            )
+        else:
+            return None
+
+@adapter.adapter_class("officialaccount")
+class OfficialAccountAdapter(adapter.MessageSourceAdapter):
+
+    bot : OAClient
+    ap : app.Application
+    bot_account_id: str
+    message_converter: OAMessageConverter = OAMessageConverter()
+    event_converter: OAEventConverter = OAEventConverter()
+    config: dict
+
+
+    def __init__(self, config: dict, ap: app.Application):
+        self.config = config
+        
+        self.ap = ap
+
+        required_keys = [
+            "token",
+            "EncodingAESKey",
+            "AppSecret",
+            "AppID",
+        ]
+        missing_keys = [key for key in required_keys if key not in config]
+        if missing_keys:
+            raise ParamNotEnoughError("企业微信缺少相关配置项，请查看文档或联系管理员")
+        
+        self.bot = OAClient(
+            token=config['token'],
+            EncodingAESKey=config['EncodingAESKey'],
+            Appsecret=config['AppSecret'],
+            AppID=config['AppID'], 
+        )
+
+    async def reply_message(self, message_source: platform_events.FriendMessage, message: platform_message.MessageChain, quote_origin: bool = False):
+        global generated_content
+
+        content = await OAMessageConverter.yiri2target(
+            message
+        )
+
+        generated_content[message_source.message_chain.message_id] = content
+        
+    async def send_message(
+        self, target_type: str, target_id: str, message: platform_message.MessageChain
+    ):
+        pass
+
+
+    def register_listener(self, event_type: type, callback: typing.Callable[[platform_events.Event, MessageSourceAdapter], None]):
+        async def on_message(event: OAEvent):
+            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)
+        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/sources/qqofficial.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+import typing
+import asyncio
+import traceback
+import time
+import datetime
+import aiocqhttp
+import aiohttp
+from pkg.platform.adapter import MessageSourceAdapter
+from pkg.platform.types import events as platform_events, message as platform_message
+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 libs.qq_official_api.api import QQOfficialClient
+from libs.qq_official_api.qqofficialevent import QQOfficialEvent
+from ...utils import image
+
+
+class QQOfficialMessageConverter(adapter.MessageConverter):
+    
+    @staticmethod
+    async def yiri2target(message_chain: platform_message.MessageChain):
+        content_list = []
+        #只实现了发文字
+        for msg in message_chain:
+            if type(msg) is platform_message.Plain:
+                content_list.append({
+                    "type":"text",
+                    "content":msg.text,
+                })
+        
+        return content_list
+    
+    @staticmethod
+    async def target2yiri(message:str,message_id:str,pic_url:str,content_type):
+        yiri_msg_list = []
+        yiri_msg_list.append(
+            platform_message.Source(id=message_id,time=datetime.datetime.now())
+        )
+        if pic_url is not None:
+            base64_url = await image.get_qq_official_image_base64(pic_url=pic_url,content_type=content_type)
+            yiri_msg_list.append(
+                platform_message.Image(base64=base64_url)
+            )
+
+        yiri_msg_list.append(platform_message.Plain(text=message))
+        chain = platform_message.MessageChain(yiri_msg_list)
+        return chain
+
+class QQOfficialEventConverter(adapter.EventConverter):
+
+    @staticmethod
+    async def yiri2target(event:platform_events.MessageEvent) -> QQOfficialEvent:
+        return event.source_platform_object
+    
+    @staticmethod
+    async def target2yiri(event:QQOfficialEvent):
+        """
+        QQ官方消息转换为LB对象
+        """
+        yiri_chain = await QQOfficialMessageConverter.target2yiri(
+            message=event.content,message_id=event.d_id,pic_url=event.attachments,content_type=event.content_type
+        )
+        
+        if event.t == 'C2C_MESSAGE_CREATE':
+            friend = platform_entities.Friend(
+                id = event.user_openid,
+                nickname = event.t,
+                remark = "",
+            )
+            return platform_events.FriendMessage(
+                sender = friend,message_chain = yiri_chain,time = event.timestamp,
+                source_platform_object=event
+            )
+        
+        if event.t == 'DIRECT_MESSAGE_CREATE':
+            friend = platform_entities.Friend(
+                id = event.guild_id,
+                nickname = event.t,
+                remark = "",
+            )
+            return platform_events.FriendMessage(
+                sender = friend,message_chain = yiri_chain,
+                source_platform_object=event
+            )
+        if event.t == 'GROUP_AT_MESSAGE_CREATE':
+            yiri_chain.insert(0, platform_message.At(target="justbot"))
+
+            sender = platform_entities.GroupMember(
+                id = event.group_openid,
+                member_name= event.t,
+                permission= 'MEMBER',
+                group = platform_entities.Group(
+                    id = 0,
+                    name = 'MEMBER',
+                    permission= platform_entities.Permission.Member
+                ),
+                special_title='',
+                join_timestamp=0,
+                last_speak_timestamp=0,
+                mute_time_remaining=0
+            )
+            time = event.timestamp
+            return platform_events.GroupMessage(
+                sender = sender,
+                message_chain=yiri_chain,
+                time = time,
+                source_platform_object=event
+            )
+        if event.t =='AT_MESSAGE_CREATE':
+            yiri_chain.insert(0, platform_message.At(target="justbot"))
+            sender = platform_entities.GroupMember(
+                id = event.channel_id,
+                member_name=event.t,
+                permission= 'MEMBER',
+                group = platform_entities.Group(
+                    id = 0,
+                    name = 'MEMBER',
+                    permission=platform_entities.Permission.Member
+                ),
+                special_title='',
+                join_timestamp=0,
+                last_speak_timestamp=0,
+                mute_time_remaining=0
+            )
+            time = event.timestamp,
+            return platform_events.GroupMessage(
+                sender  =sender,
+                message_chain = yiri_chain,
+                time = time,
+                source_platform_object=event
+            )
+
+
+        
+
+@adapter.adapter_class("qqofficial")
+class QQOfficialAdapter(adapter.MessageSourceAdapter):
+    bot:QQOfficialClient
+    ap:app.Application
+    config:dict
+    bot_account_id:str
+    message_converter: QQOfficialMessageConverter = QQOfficialMessageConverter()
+    event_converter: QQOfficialEventConverter = QQOfficialEventConverter()
+
+    def __init__(self, config:dict, ap:app.Application):
+        self.config = config
+        self.ap = ap
+
+        required_keys = [
+            "appid",
+            "secret",
+        ]
+        missing_keys = [key for key in required_keys if key not in config]
+        if missing_keys:
+            raise ParamNotEnoughError("QQ官方机器人缺少相关配置项，请查看文档或联系管理员")
+        
+        self.bot = QQOfficialClient(
+            app_id=config["appid"],
+            secret=config["secret"],
+            token=config["token"],
+        )
+
+    async def reply_message(
+        self,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
+        quote_origin: bool = False,
+    ):
+        qq_official_event = await QQOfficialEventConverter.yiri2target(
+            message_source,
+        )
+
+        content_list = await QQOfficialMessageConverter.yiri2target(message)
+
+        #私聊消息
+        if qq_official_event.t == 'C2C_MESSAGE_CREATE':
+            for content in content_list:
+                if content["type"] == 'text':
+                    await self.bot.send_private_text_msg(qq_official_event.user_openid,content['content'],qq_official_event.d_id)
+
+        #群聊消息
+        if qq_official_event.t == 'GROUP_AT_MESSAGE_CREATE':
+            for content in content_list:
+                if content["type"] == 'text':
+                    await self.bot.send_group_text_msg(qq_official_event.group_openid,content['content'],qq_official_event.d_id)
+        
+        #频道群聊
+        if qq_official_event.t == 'AT_MESSAGE_CREATE':
+            for content in content_list:
+                if content["type"] == 'text':
+                    await self.bot.send_channle_group_text_msg(qq_official_event.channel_id,content['content'],qq_official_event.d_id)
+
+        #频道私聊
+        if qq_official_event.t == 'DIRECT_MESSAGE_CREATE':
+            for content in content_list:
+                if content["type"] == 'text':
+                    await self.bot.send_channle_private_text_msg(qq_official_event.guild_id,content['content'],qq_official_event.d_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:QQOfficialEvent):
+            self.bot_account_id = "justbot"
+            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("DIRECT_MESSAGE_CREATE")(on_message)
+            self.bot.on_message("C2C_MESSAGE_CREATE")(on_message)
+        elif event_type == platform_events.GroupMessage:
+            self.bot.on_message("GROUP_AT_MESSAGE_CREATE")(on_message)
+            self.bot.on_message("AT_MESSAGE_CREATE")(on_message)
+
+
+    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
+    
+    def unregister_listener(
+        self,
+        event_type: type,
+        callback: typing.Callable[[platform_events.Event, MessageSourceAdapter], None],
+    ):
+        return super().unregister_listener(event_type, callback)
+

pkg/platform/sources/telegram.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import telegram
+import telegram.ext
+from telegram import Update
+from telegram.ext import ApplicationBuilder, ContextTypes, CommandHandler, MessageHandler, filters
+
+import typing
+import asyncio
+import traceback
+import time
+import re
+import base64
+import uuid
+import json
+import datetime
+import hashlib
+import base64
+import aiohttp
+from Crypto.Cipher import AES
+
+from flask import jsonify
+from lark_oapi.api.im.v1 import *
+from lark_oapi.api.verification.v1 import GetVerificationRequest
+
+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 TelegramMessageConverter(adapter.MessageConverter):
+    @staticmethod
+    async def yiri2target(message_chain: platform_message.MessageChain, bot: telegram.Bot) -> list[dict]:
+        components = []
+
+        for component in message_chain:
+            if isinstance(component, platform_message.Plain):
+                components.append({
+                    "type": "text",
+                    "text": component.text
+                })
+            elif isinstance(component, platform_message.Image):
+
+                photo_bytes = None
+
+                if component.base64:
+                    photo_bytes = base64.b64decode(component.base64)
+                elif component.url:
+                    async with aiohttp.ClientSession() as session:
+                        async with session.get(component.url) as response:
+                            photo_bytes = await response.read()
+                elif component.path:
+                    with open(component.path, "rb") as f:
+                        photo_bytes = f.read()
+                
+                components.append({
+                    "type": "photo",
+                    "photo": photo_bytes
+                })
+            elif isinstance(component, platform_message.Forward):
+                for node in component.node_list:
+                    components.extend(await TelegramMessageConverter.yiri2target(node.message_chain, bot))
+
+        return components
+    
+    @staticmethod
+    async def target2yiri(message: telegram.Message, bot: telegram.Bot, bot_account_id: str):
+        
+        message_components = []
+
+
+        def parse_message_text(text: str) -> list[platform_message.MessageComponent]:
+            msg_components = []
+
+            if f'@{bot_account_id}' in text:
+                msg_components.append(platform_message.At(target=bot_account_id))
+                text = text.replace(f'@{bot_account_id}', '')
+            msg_components.append(platform_message.Plain(text=text))
+
+            return msg_components
+
+        if message.text:
+            message_text = message.text
+            message_components.extend(parse_message_text(message_text))
+        
+        if message.photo:
+            message_components.extend(parse_message_text(message.caption))
+
+            file = await message.photo[-1].get_file()
+
+            file_bytes = None
+            file_format = ''
+
+            async with aiohttp.ClientSession(trust_env=True) as session:
+                async with session.get(file.file_path) as response:
+                    file_bytes = await response.read()
+                    file_format = 'image/jpeg'
+
+            message_components.append(platform_message.Image(base64=f"data:{file_format};base64,{base64.b64encode(file_bytes).decode('utf-8')}"))
+        
+        return platform_message.MessageChain(message_components)
+    
+
+class TelegramEventConverter(adapter.EventConverter):
+    @staticmethod
+    async def yiri2target(event: platform_events.MessageEvent, bot: telegram.Bot):
+        return event.source_platform_object
+    
+    @staticmethod
+    async def target2yiri(event: Update, bot: telegram.Bot, bot_account_id: str):
+
+        lb_message = await TelegramMessageConverter.target2yiri(event.message, bot, bot_account_id)
+        
+        if event.effective_chat.type == 'private':
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id=event.effective_chat.id,
+                    nickname=event.effective_chat.first_name,
+                    remark=event.effective_chat.id,
+                ),
+                message_chain=lb_message,
+                time=event.message.date.timestamp(),
+                source_platform_object=event
+            )
+        elif event.effective_chat.type == 'group':
+            return platform_events.GroupMessage(
+                sender=platform_entities.GroupMember(
+                    id=event.effective_chat.id,
+                    member_name=event.effective_chat.title,
+                    permission=platform_entities.Permission.Member,
+                    group=platform_entities.Group(
+                        id=event.effective_chat.id,
+                        name=event.effective_chat.title,
+                        permission=platform_entities.Permission.Member,
+                    ),
+                    special_title="",
+                    join_timestamp=0,
+                    last_speak_timestamp=0,
+                    mute_time_remaining=0,
+                ),
+                message_chain=lb_message,
+                time=event.message.date.timestamp(),
+                source_platform_object=event
+            )
+    
+@adapter.adapter_class("telegram")
+class TelegramMessageSourceAdapter(adapter.MessageSourceAdapter):
+    
+    bot: telegram.Bot
+    application: telegram.ext.Application
+
+    bot_account_id: str
+
+    message_converter: TelegramMessageConverter = TelegramMessageConverter()
+    event_converter: TelegramEventConverter = TelegramEventConverter()
+
+    config: dict
+    ap: app.Application
+
+    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
+        
+        async def telegram_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
+
+            if update.message.from_user.is_bot:
+                return
+
+            try:
+                lb_event = await self.event_converter.target2yiri(update, self.bot, self.bot_account_id)
+                await self.listeners[type(lb_event)](lb_event, self)
+            except Exception as e:
+                print(traceback.format_exc())
+        
+        self.application = ApplicationBuilder().token(self.config['token']).build()
+        self.bot = self.application.bot
+        self.application.add_handler(MessageHandler(filters.TEXT | (filters.COMMAND) | filters.PHOTO , telegram_callback))
+        
+    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,
+    ):
+        assert isinstance(message_source.source_platform_object, Update)
+        components = await TelegramMessageConverter.yiri2target(message, self.bot)
+        
+        for component in components:
+            if component['type'] == 'text':
+
+                args = {
+                    "chat_id": message_source.source_platform_object.effective_chat.id,
+                    "text": component['text'],
+                }
+
+                if quote_origin:
+                    args['reply_to_message_id'] = message_source.source_platform_object.message.id
+
+                await self.bot.send_message(**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):
+        await self.application.initialize()
+        self.bot_account_id = (await self.bot.get_me()).username
+        await self.application.updater.start_polling(
+            allowed_updates=Update.ALL_TYPES
+        )
+        await self.application.start()
+    
+    async def kill(self) -> bool:
+        await self.application.stop()
+        return True

pkg/platform/sources/wecom.py

@@ -29,17 +29,6 @@ class WecomMessageConverter(adapter.MessageConverter):
     ):
         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({
@@ -83,7 +72,7 @@ class WecomMessageConverter(adapter.MessageConverter):
         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
 
 
@@ -130,9 +119,8 @@ class WecomEventConverter:
             yiri_chain = await WecomMessageConverter.target2yiri(
                 event.message, event.message_id
             )
-
             friend = platform_entities.Friend(
-                id=event.user_id,
+                id=f"u{event.user_id}",
                 nickname=str(event.agent_id),
                 remark="",
             )
@@ -142,7 +130,7 @@ class WecomEventConverter:
             )
         elif event.type == "image":
             friend = platform_entities.Friend(
-                id=event.user_id,
+                id=f"u{event.user_id}",
                 nickname=str(event.agent_id),
                 remark="",
             )
@@ -165,7 +153,6 @@ class WecomeAdapter(adapter.MessageSourceAdapter):
     message_converter: WecomMessageConverter = WecomMessageConverter()
     event_converter: WecomEventConverter = WecomEventConverter()
     config: dict
-    ap: app.Application
 
     def __init__(self, config: dict, ap: app.Application):
         self.config = config
@@ -202,13 +189,15 @@ class WecomeAdapter(adapter.MessageSourceAdapter):
             message_source, self.bot_account_id, self.bot
         )
         content_list = await WecomMessageConverter.yiri2target(message, self.bot)
-
+        fixed_user_id = Wecom_event.user_id
+        # 删掉开头的u
+        fixed_user_id = fixed_user_id[1:]
         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"])
+                await self.bot.send_private_msg(fixed_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"])
-
+                await self.bot.send_image(fixed_user_id, Wecom_event.agent_id, content["media_id"])
+  
     async def send_message(
         self, target_type: str, target_id: str, message: platform_message.MessageChain
     ):

pkg/platform/types/entities.py

@@ -38,6 +38,7 @@ class Friend(Entity):
         return self.nickname or self.remark or ''
 
 
+
 class Permission(str, Enum):
     """群成员身份权限。"""
     Member = "MEMBER"

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
     """消息时间。"""
@@ -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时显示的文字，发送消息时无效，自动使用群名片。"""
@@ -785,10 +785,20 @@ class ForwardMessageNode(pydantic.BaseModel):
         )
 
 
+class ForwardMessageDiaplay(pydantic.BaseModel):
+    title: str = "群聊的聊天记录"
+    brief: str = "[聊天记录]"
+    source: str = "聊天记录"
+    preview: typing.List[str] = []
+    summary: str = "查看x条转发消息"
+
+
 class Forward(MessageComponent):
     """合并转发。"""
     type: str = "Forward"
     """消息组件类型。"""
+    display: ForwardMessageDiaplay
+    """显示信息"""
     node_list: typing.List[ForwardMessageNode]
     """转发消息节点列表。"""
     def __init__(self, *args, **kwargs):

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 bailianchatcmpl, 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/bailianchatcmpl.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import openai
+
+from . import chatcmpl
+from .. import requester
+from ....core import app
+
+
+@requester.requester_class("bailian-chat-completions")
+class BailianChatCompletions(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']['bailian-chat-completions']

pkg/provider/modelmgr/requesters/chatcmpl.py

@@ -8,6 +8,7 @@ from typing import AsyncGenerator
 
 import openai
 import openai.types.chat.chat_completion as chat_completion
+import openai.types.chat.chat_completion_message_tool_call as chat_completion_message_tool_call
 import httpx
 import aiohttp
 import async_lru
@@ -40,6 +41,7 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
             timeout=self.requester_cfg['timeout'],
             http_client=httpx.AsyncClient(
                 trust_env=True,
+                timeout=self.requester_cfg['timeout']
             )
         )
 
@@ -47,7 +49,70 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
         self,
         args: dict,
     ) -> chat_completion.ChatCompletion:
-        return await self.client.chat.completions.create(**args)
+        args["stream"] = True
+
+        chunk = None
+
+        pending_content = ""
+
+        tool_calls = []
+
+        resp_gen: openai.AsyncStream = await self.client.chat.completions.create(**args)
+
+        async for chunk in resp_gen:
+            # print(chunk)
+            if not chunk or not chunk.id or not chunk.choices or not chunk.choices[0] or not chunk.choices[0].delta:
+                continue
+
+            if chunk.choices[0].delta.content is not None:
+                pending_content += chunk.choices[0].delta.content
+
+            if chunk.choices[0].delta.tool_calls is not None:
+                for tool_call in chunk.choices[0].delta.tool_calls:
+                    for tc in tool_calls:
+                        if tc.index == tool_call.index:
+                            tc.function.arguments += tool_call.function.arguments
+                            break
+                    else:
+                        tool_calls.append(tool_call)
+            
+            if chunk.choices[0].finish_reason is not None:
+                break
+
+        real_tool_calls = []
+
+        for tc in tool_calls:
+            function = chat_completion_message_tool_call.Function(
+                name=tc.function.name,
+                arguments=tc.function.arguments
+            )
+            real_tool_calls.append(chat_completion_message_tool_call.ChatCompletionMessageToolCall(
+                id=tc.id,
+                function=function,
+                type="function"
+            ))
+
+        return chat_completion.ChatCompletion(
+            id=chunk.id,
+            object="chat.completion",
+            created=chunk.created,
+            choices=[
+                chat_completion.Choice(
+                    index=0,
+                    message=chat_completion.ChatCompletionMessage(
+                        role="assistant",
+                        content=pending_content,
+                        tool_calls=real_tool_calls if len(real_tool_calls) > 0 else None
+                    ),
+                    finish_reason=chunk.choices[0].finish_reason if hasattr(chunk.choices[0], 'finish_reason') and chunk.choices[0].finish_reason is not None else 'stop',
+                    logprobs=chunk.choices[0].logprobs,
+                )
+            ],
+            model=chunk.model,
+            service_tier=chunk.service_tier if hasattr(chunk, 'service_tier') else None,
+            system_fingerprint=chunk.system_fingerprint if hasattr(chunk, 'system_fingerprint') else None,
+            usage=chunk.usage if hasattr(chunk, 'usage') else None
+        ) if chunk else None
 
     async def _make_msg(
         self,

pkg/provider/modelmgr/requesters/deepseekchatcmpl.py

@@ -46,6 +46,9 @@ class DeepseekChatCompletions(chatcmpl.OpenAIChatCompletions):
         # 发送请求
         resp = await self._req(args)
 
+        if resp is None:
+            raise errors.RequesterError('接口返回为空，请确定模型提供商服务是否正常')
+
         # 处理请求结果
         message = await self._make_msg(resp)
 

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/provider/runnermgr.py

@@ -5,6 +5,7 @@ from ..core import app
 
 from .runners import localagent
 from .runners import difysvapi
+from .runners import dashscopeapi
 
 class RunnerManager:
 
@@ -22,6 +23,8 @@ class RunnerManager:
                 self.using_runner = r(self.ap)
                 await self.using_runner.initialize()
                 break
+        else:
+            raise ValueError(f"未找到请求运行器: {self.ap.provider_cfg.data['runner']}")
 
     def get_runner(self) -> runner.RequestRunner:
         return self.using_runner

pkg/provider/runners/dashscopeapi.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import typing
+import json
+import base64
+import re
+
+import dashscope
+
+from .. import runner
+from ...core import entities as core_entities
+from .. import entities as llm_entities
+from ...utils import image
+
+class DashscopeAPIError(Exception):
+    """Dashscope API 请求失败"""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
+@runner.runner_class("dashscope-app-api")
+class DashScopeAPIRunner(runner.RequestRunner):
+    "阿里云百炼DashsscopeAPI对话请求器"
+    
+    # 运行器内部使用的配置
+    app_type: str                   # 应用类型
+    app_id: str                     # 应用ID
+    api_key: str                    # API Key
+    references_quote: str           # 引用资料提示（当展示回答来源功能开启时，这个变量会作为引用资料名前的提示，可在provider.json中配置）
+    biz_params: dict = {}           # 工作流应用参数（仅在工作流应用中生效）
+
+    async def initialize(self):
+        """初始化"""
+        valid_app_types = ["agent", "workflow"]
+        self.app_type = self.ap.provider_cfg.data["dashscope-app-api"]["app-type"]
+        #检查配置文件中使用的应用类型是否支持
+        if (self.app_type not in valid_app_types):
+            raise DashscopeAPIError(
+                f"不支持的 Dashscope 应用类型: {self.app_type}"
+            )
+        
+        #初始化Dashscope 参数配置
+        self.app_id = self.ap.provider_cfg.data["dashscope-app-api"][self.app_type]["app-id"]
+        self.api_key = self.ap.provider_cfg.data["dashscope-app-api"]["api-key"]
+        self.references_quote = self.ap.provider_cfg.data["dashscope-app-api"][self.app_type]["references_quote"]
+        self.biz_params = self.ap.provider_cfg.data["dashscope-app-api"]["workflow"]["biz_params"]
+     
+    def _replace_references(self, text, references_dict):
+        """阿里云百炼平台的自定义应用支持资料引用，此函数可以将引用标签替换为参考资料"""
+        
+        # 匹配 <ref>[index_id]</ref> 形式的字符串
+        pattern = re.compile(r'<ref>\[(.*?)\]</ref>')
+
+        def replacement(match):
+            # 获取引用编号
+            ref_key = match.group(1)  
+            if ref_key in references_dict:
+                # 如果有对应的参考资料按照provider.json中的reference_quote返回提示，来自哪个参考资料文件
+                return f"({self.references_quote} {references_dict[ref_key]})"
+            else:
+                # 如果没有对应的参考资料，保留原样
+                return match.group(0)  
+
+        # 使用 re.sub() 进行替换
+        return pattern.sub(replacement, text)
+
+    async def _preprocess_user_message(
+        self, query: core_entities.Query
+    ) -> tuple[str, list[str]]:
+        """预处理用户消息，提取纯文本，阿里云提供的上传文件方法过于复杂，暂不支持上传文件（包括图片）"""
+        plain_text = ""
+        image_ids = []
+        if isinstance(query.user_message.content, list):
+            for ce in query.user_message.content:
+                if ce.type == "text":
+                    plain_text += ce.text
+                # 暂时不支持上传图片，保留代码以便后续扩展
+                # elif ce.type == "image_base64":       
+                #     image_b64, image_format = await image.extract_b64_and_format(ce.image_base64)
+                #     file_bytes = base64.b64decode(image_b64)
+                #     file = ("img.png", file_bytes, f"image/{image_format}")
+                #     file_upload_resp = await self.dify_client.upload_file(
+                #         file,
+                #         f"{query.session.launcher_type.value}_{query.session.launcher_id}",
+                #     )
+                #     image_id = file_upload_resp["id"]
+                #     image_ids.append(image_id)
+        elif isinstance(query.user_message.content, str):
+            plain_text = query.user_message.content
+
+        return plain_text, image_ids
+    
+    
+    async def _agent_messages(
+        self, query: core_entities.Query
+    ) -> typing.AsyncGenerator[llm_entities.Message, None]:
+        """Dashscope 智能体对话请求"""
+        
+        #局部变量
+        chunk = None            # 流式传输的块
+        pending_content = ""    # 待处理的Agent输出内容
+        references_dict = {}    # 用于存储引用编号和对应的参考资料
+        plain_text = ""         # 用户输入的纯文本信息
+        image_ids = []          # 用户输入的图片ID列表 （暂不支持）
+        
+        plain_text, image_ids = await self._preprocess_user_message(query)
+        
+        #发送对话请求
+        response = dashscope.Application.call(
+            api_key=self.api_key,                               # 智能体应用的API Key
+            app_id=self.app_id,                                 # 智能体应用的ID
+            prompt=plain_text,                                  # 用户输入的文本信息
+            stream=True,                                        # 流式输出
+            incremental_output=True,                            # 增量输出，使用流式输出需要开启增量输出
+            session_id=query.session.using_conversation.uuid,   # 会话ID用于，多轮对话
+            # rag_options={                                     # 主要用于文件交互，暂不支持
+            #     "session_file_ids": ["FILE_ID1"],             # FILE_ID1 替换为实际的临时文件ID,逗号隔开多个
+            # }
+        )
+
+        for chunk in response:
+            if chunk.get("status_code") != 200:
+                raise DashscopeAPIError(
+                    f"Dashscope API 请求失败: status_code={chunk.get('status_code')} message={chunk.get('message')} request_id={chunk.get('request_id')} "
+                )
+            if not chunk:
+                continue
+            
+            #获取流式传输的output
+            stream_output = chunk.get("output", {})
+            if stream_output.get("text") is not None:
+                pending_content += stream_output.get("text")
+        
+        #保存当前会话的session_id用于下次对话的语境
+        query.session.using_conversation.uuid = stream_output.get("session_id")
+        
+        #获取模型传出的参考资料列表
+        references_dict_list = stream_output.get("doc_references", [])
+        
+        #从模型传出的参考资料信息中提取用于替换的字典
+        if references_dict_list is not None:
+            for doc in references_dict_list:
+                if doc.get("index_id") is not None:
+                    references_dict[doc.get("index_id")] = doc.get("doc_name")
+                    
+            #将参考资料替换到文本中
+            pending_content = self._replace_references(pending_content, references_dict)
+        
+        yield llm_entities.Message(
+            role="assistant",
+            content=pending_content,
+        )
+    
+    
+    async def _workflow_messages(
+        self, query: core_entities.Query
+    ) -> typing.AsyncGenerator[llm_entities.Message, None]:
+        """Dashscope 工作流对话请求"""
+        
+        #局部变量
+        chunk = None            # 流式传输的块
+        pending_content = ""    # 待处理的Agent输出内容
+        references_dict = {}    # 用于存储引用编号和对应的参考资料
+        plain_text = ""         # 用户输入的纯文本信息
+        image_ids = []          # 用户输入的图片ID列表 （暂不支持）
+        
+        plain_text, image_ids = await self._preprocess_user_message(query)
+        
+        #发送对话请求
+        response = dashscope.Application.call(
+            api_key=self.api_key,                               # 智能体应用的API Key
+            app_id=self.app_id,                                 # 智能体应用的ID
+            prompt=plain_text,                                  # 用户输入的文本信息
+            stream=True,                                        # 流式输出
+            incremental_output=True,                            # 增量输出，使用流式输出需要开启增量输出
+            session_id=query.session.using_conversation.uuid,   # 会话ID用于，多轮对话
+            biz_params=self.biz_params                          # 工作流应用的自定义输入参数传递
+            # rag_options={                                     # 主要用于文件交互，暂不支持
+            #     "session_file_ids": ["FILE_ID1"],             # FILE_ID1 替换为实际的临时文件ID,逗号隔开多个
+            # }
+        )
+        
+        #处理API返回的流式输出
+        for chunk in response:
+            if chunk.get("status_code") != 200:
+                raise DashscopeAPIError(
+                    f"Dashscope API 请求失败: status_code={chunk.get('status_code')} message={chunk.get('message')} request_id={chunk.get('request_id')} "
+                )
+            if not chunk:
+                continue
+            
+            #获取流式传输的output
+            stream_output = chunk.get("output", {})
+            if stream_output.get("text") is not None:
+                pending_content += stream_output.get("text")
+        
+        #保存当前会话的session_id用于下次对话的语境
+        query.session.using_conversation.uuid = stream_output.get("session_id")
+        
+        #获取模型传出的参考资料列表
+        references_dict_list = stream_output.get("doc_references", [])
+        
+        #从模型传出的参考资料信息中提取用于替换的字典
+        if references_dict_list is not None:
+            for doc in references_dict_list:
+                if doc.get("index_id") is not None:
+                    references_dict[doc.get("index_id")] = doc.get("doc_name")
+                    
+            #将参考资料替换到文本中
+            pending_content = self._replace_references(pending_content, references_dict)
+        
+        yield llm_entities.Message(
+            role="assistant",
+            content=pending_content,
+        )
+    
+    
+    
+    async def run(
+        self, query: core_entities.Query
+    ) -> typing.AsyncGenerator[llm_entities.Message, None]:
+        """运行"""
+        if self.ap.provider_cfg.data["dashscope-app-api"]["app-type"] == "agent":
+            async for msg in self._agent_messages(query):
+                yield msg
+        elif self.ap.provider_cfg.data["dashscope-app-api"]["app-type"] == "workflow":
+            async for msg in self._workflow_messages(query):
+                yield msg
+        else:
+            raise DashscopeAPIError(
+                f"不支持的 Dashscope 应用类型: {self.ap.provider_cfg.data['dashscope-app-api']['app-type']}"
+            )
+
+

pkg/utils/constants.py

@@ -1,4 +1,4 @@
-semantic_version = "v3.4.3.1"
+semantic_version = "v3.4.8"
 
 debug_mode = False
 

pkg/utils/image.py

@@ -6,6 +6,7 @@ import ssl
 
 import aiohttp
 import PIL.Image
+import httpx
 
 async def get_wecom_image_base64(pic_url: str) -> tuple[str, str]:
     """
@@ -30,7 +31,19 @@ async def get_wecom_image_base64(pic_url: str) -> tuple[str, str]:
             image_base64 = base64.b64encode(image_data).decode('utf-8')
             
             return image_base64, image_format
-
+        
+async def get_qq_official_image_base64(pic_url:str,content_type:str) -> tuple[str,str]:
+    """
+    下载QQ官方图片，
+    并且转换为base64格式
+    """
+    async with httpx.AsyncClient() as client:
+        response = await client.get(pic_url)
+        response.raise_for_status()  # 确保请求成功
+        image_data = response.content
+        base64_data = base64.b64encode(image_data).decode('utf-8')
+        
+        return f"data:{content_type};base64,{base64_data}"
 
 
 def get_qq_image_downloadable_url(image_url: str) -> tuple[str, dict]:

requirements.txt

@@ -25,6 +25,13 @@ aioshutil
 argon2-cffi
 pyjwt
 pycryptodome
+lark-oapi
+discord.py
+cryptography
+gewechat-client
+dingtalk_stream
+dashscope
+python-telegram-bot
 
 # indirect
 taskgroup==0.0.0a4

res/announcement_saved.json

@@ -0,0 +1 @@
+[]

res/instance_id.json

@@ -0,0 +1 @@
+{"host_id": "host_9b4a220d-3bb6-42fc-aec3-41188ce0a41c", "instance_id": "instance_61d8f262-b98a-4165-8e77-85fb6262529e", "instance_create_ts": 1736824678}

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

@@ -25,6 +25,14 @@
                 "direct_message"
             ]
         },
+        {
+            "adapter": "qqofficial",
+            "enable": false,
+            "appid": "1234567890",
+            "secret": "xxxxxxx",
+            "port": 2284,
+            "token": "abcdefg"
+        },
         {
             "adapter": "wecom",
             "enable": false,
@@ -35,6 +43,54 @@
             "token": "",
             "EncodingAESKey": "",
             "contacts_secret": ""
+        },
+        {
+            "adapter": "lark",
+            "enable": false,
+            "app_id": "cli_abcdefgh",
+            "app_secret": "XXXXXXXXXX",
+            "bot_name": "LangBot",
+            "enable-webhook": false,
+            "port": 2285,
+            "encrypt-key": "xxxxxxxxx"
+        },
+        {
+            "adapter": "discord",
+            "enable": false,
+            "client_id": "1234567890",
+            "token": "XXXXXXXXXX"
+        },
+        {
+            "adapter": "gewechat",
+            "enable": false,
+            "gewechat_url": "http://your-gewechat-server:2531",
+            "port": 2286,
+            "callback_url": "http://your-callback-url:2286/gewechat/callback",
+            "app_id": "",
+            "token": ""
+        },
+        {
+            "adapter":"officialaccount",
+            "enable": false,
+            "token": "",
+            "EncodingAESKey":"",
+            "AppID":"",
+            "AppSecret":"",
+            "host": "0.0.0.0",
+            "port": 2287
+        },
+        {
+            "adapter":"dingtalk",
+            "enable": false,
+            "client_id":"",
+            "client_secret":"",
+            "robot_code":"",
+            "robot_name":""
+        },
+        {
+            "adapter":"telegram",
+            "enable": false,
+            "token":""
         }
     ],
     "track-function-calls": true,
@@ -45,7 +101,7 @@
         "max": 0
     },
     "long-text-process": {
-        "threshold": 256,
+        "threshold": 2560,
         "strategy": "forward",
         "font-path": ""
     },

templates/provider.json

@@ -22,6 +22,12 @@
         ],
         "zhipuai": [
             "xxxxxxx"
+        ],
+        "siliconflow": [
+            "xxxxxxx"
+        ],
+        "bailian": [
+            "sk-xxxxxxx"
         ]
     },
     "requester": {
@@ -66,12 +72,27 @@
             "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
+        },
+        "bailian-chat-completions": {
+            "args": {},
+            "base-url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
+            "timeout": 120
         }
     },
     "model": "gpt-4o",
     "prompt-mode": "normal",
     "prompt": {
-        "default": "" 
+        "default": ""
     },
     "runner": "local-agent",
     "dify-service-api": {
@@ -90,5 +111,21 @@
             "output-key": "summary",
             "timeout": 120
         }
+    },
+    "dashscope-app-api": {
+        "app-type": "agent",
+        "api-key": "sk-1234567890",
+        "agent": {
+            "app-id": "Your_app_id",
+            "references_quote": "参考资料来自:"
+        },
+        "workflow": {
+            "app-id": "Your_app_id",
+            "references_quote": "参考资料来自:",
+            "biz_params": {  
+                "city": "北京",
+                "date": "2023-08-10"
+            }
+        }
     }
 }

templates/schema/platform.json

@@ -83,7 +83,7 @@
                         }
                     },
                     {
-                        "title": "qq-botpy 适配器",
+                        "title": "qq-botpy 适配器（WebSocket）",
                         "description": "用于接入 QQ 官方机器人 API",
                         "properties": {
                             "adapter": {
@@ -121,6 +121,337 @@
                                 ]
                             }
                         }
+                    },
+                    {
+                        "title": "QQ 官方适配器（WebHook）",
+                        "description": "用于接入 QQ 官方机器人 API",
+                        "properties": {
+                            "adapter": {
+                                "type": "string",
+                                "const": "qqofficial"
+                            },
+                            "enable": {
+                                "type": "boolean",
+                                "default": false,
+                                "description": "是否启用此适配器",
+                                "layout": {
+                                    "comp": "switch",
+                                    "props": {
+                                        "color": "primary"
+                                    }
+                                }
+                            },
+                            "appid": {
+                                "type": "string",
+                                "default": "",
+                                "description": "申请到的QQ官方机器人的appid"
+                            },
+                            "secret": {
+                                "type": "string",
+                                "default": "",
+                                "description": "申请到的QQ官方机器人的secret"
+                            },
+                            "port": {
+                                "type": "integer",
+                                "default": 2284,
+                                "description": "监听的端口"
+                            },
+                            "token": {
+                                "type": "string",
+                                "default": "",
+                                "description": "申请到的QQ官方机器人的token"
+                            }
+                        }
+                    },
+                    {
+                        "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"
+                            },
+                            "enable-webhook": {
+                                "type": "boolean",
+                                "default": false,
+                                "description": "是否启用webhook模式"
+                            },
+                            "port": {
+                                "type": "integer",
+                                "description": "设置监听的端口,开启callback event时需要设置",
+                                "default": 2285
+                            },
+                            "encrypt-key": {
+                                "type": "string",
+                                "default": "",
+                                "description": "设置加密密钥"
+                            }
+                        }
+                    },
+                    {
+                        "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"
+                            }
+                        }
+                    },
+                    {
+                        "title": "gewechat 适配器",
+                        "description": "用于接入个人微信",
+                        "properties": {
+                            "adapter": {
+                                "type": "string",
+                                "const": "gewechat"
+                            },
+                            "enable": {
+                                "type": "boolean",
+                                "default": false,
+                                "description": "是否启用此适配器",
+                                "layout": {
+                                    "comp": "switch",
+                                    "props": {
+                                        "color": "primary"
+                                    }
+                                }
+                            },
+                            "gewechat_url": {
+                                "type": "string",
+                                "default": "",
+                                "description": "gewechat 的 url"
+                            },
+                            "port": {
+                                "type": "integer",
+                                "default": 2286,
+                                "description": "gewechat 的端口"
+                            },
+                            "callback_url": {
+                                "type": "string",
+                                "default": "",
+                                "description": "回调地址（LangBot主机相对于gewechat服务器的地址）"
+                            },
+                            "app_id": {
+                                "type": "string",
+                                "default": "",
+                                "description": "gewechat 的 app_id"
+                            },
+                            "token": {
+                                "type": "string",
+                                "default": "",
+                                "description": "gewechat 的 token"
+                            }
+                        }
+                    },
+                    {
+                        "title": "微信公众号适配器",
+                        "description": "用于接入微信公众号",
+                        "properties": {
+                            "adapter": {
+                                "type": "string",
+                                "const": "officialaccount"
+                            },
+                            "enable": {
+                                "type": "boolean",
+                                "default": false,
+                                "description": "是否启用此适配器"
+                            },
+                            "token": {
+                                "type": "string",
+                                "default": "",
+                                "description": "微信公众号的token"
+                            },
+                            "EncodingAESKey": {
+                                "type": "string",
+                                "default": "",
+                                "description": "微信公众号的EncodingAESKey"
+                            },
+                            "AppID": {
+                                "type": "string",
+                                "default": "",
+                                "description": "微信公众号的AppID"
+                            },
+                            "AppSecret": {
+                                "type": "string",
+                                "default": "",
+                                "description": "微信公众号的AppSecret"
+                            },
+                            "host": {
+                                "type": "string",
+                                "default": "0.0.0.0",
+                                "description": "监听的IP地址"
+                            },
+                            "port": {
+                                "type": "integer",
+                                "default": 2287,
+                                "description": "监听的端口"
+                            }
+                        }
+                    },
+                    {
+                        "title": "钉钉适配器",
+                        "description": "用于接入钉钉",
+                        "properties": {
+                            "adapter": {
+                                "type": "string",
+                                "const": "dingtalk"
+                            },
+                            "enable": {
+                                "type": "boolean",
+                                "default": false,
+                                "description": "是否启用此适配器",
+                                "layout": {
+                                    "comp": "switch",
+                                    "props": {
+                                        "color": "primary"
+                                    }
+                                }
+                            },
+                            "client_id": {
+                                "type": "string",
+                                "default": "",
+                                "description": "钉钉的client_id"
+                            },
+                            "client_secret": {
+                                "type": "string",
+                                "default": "",
+                                "description": "钉钉的client_secret"
+                            },
+                            "robot_code": {
+                                "type": "string",
+                                "default": "",
+                                "description": "钉钉的robot_code"
+                            },
+                            "robot_name": {
+                                "type": "string",
+                                "default": "",
+                                "description": "钉钉的robot_name"
+                            }
+                        }
+                    },
+                    {
+                        "title": "Telegram 适配器",
+                        "description": "用于接入 Telegram",
+                        "properties": {
+                            "adapter": {
+                                "type": "string",
+                                "const": "telegram"
+                            },
+                            "enable": {
+                                "type": "boolean",
+                                "default": false,
+                                "description": "是否启用此适配器"
+                            },
+                            "token": {
+                                "type": "string",
+                                "default": "",
+                                "description": "Telegram 的 token"
+                            }
+                        }
                     }
                 ]
             }

templates/schema/provider.json

@@ -74,6 +74,22 @@
                         "type": "string"
                     },
                     "default": []
+                },
+                "siliconflow": {
+                    "type": "array",
+                    "title": "SiliconFlow API 密钥",
+                    "items": {
+                        "type": "string"
+                    },
+                    "default": []
+                },
+                "bailian": {
+                    "type": "array",
+                    "title": "阿里云百炼大模型平台 API 密钥",
+                    "items": {
+                        "type": "string"
+                    },
+                    "default": []
                 }
             }
         },
@@ -172,7 +188,8 @@
                             "title": "API URL"
                         },
                         "args": {
-                            "type": "object"
+                            "type": "object",
+                            "default": {}
                         },
                         "timeout": {
                             "type": "number",
@@ -191,7 +208,8 @@
                             "title": "API URL"
                         },
                         "args": {
-                            "type": "object"
+                            "type": "object",
+                            "default": {}
                         },
                         "timeout": {
                             "type": "number",
@@ -210,7 +228,8 @@
                             "title": "API URL"
                         },
                         "args": {
-                            "type": "object"
+                            "type": "object",
+                            "default": {}
                         },
                         "timeout": {
                             "type": "number",
@@ -229,10 +248,72 @@
                             "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
+                        }
+                    }
+                },
+                "bailian-chat-completions": {
+                    "type": "object",
+                    "title": "阿里云百炼大模型平台 API 请求配置",
+                    "description": "仅可编辑 URL 和 超时时间，额外请求参数不支持可视化编辑，请到编辑器编辑",
+                    "properties": {
+                        "base-url": {
+                            "type": "string",
+                            "title": "API URL"
+                        },
+                        "args": {
+                            "type": "object",
+                            "default": {}
+                        },
+                        "timeout": {
+                            "type": "number",
+                            "title": "API 请求超时时间",
+                            "default": 120
                         }
                     }
                 }
@@ -292,7 +373,7 @@
                     "type": "string",
                     "title": "应用类型",
                     "description": "支持 chat 和 workflow，chat：聊天助手（含高级编排）和 Agent；workflow：工作流；请填写下方对应的应用类型 API 参数",
-                    "enum": ["chat", "workflow"],
+                    "enum": ["chat", "workflow", "agent"],
                     "default": "chat"
                 },
                 "chat": {
@@ -344,6 +425,59 @@
                     }
                 }
             }
+        },
+        "dashscope-app-api": {
+            "type": "object",
+            "title": "阿里百炼平台自建应用 API 配置",
+            "properties": {
+                "app-type": {
+                    "type": "string",
+                    "title": "应用类型",
+                    "description": "支持 workflow 和 agent，workflow：智能体编排；agent：普通智能体；请填写下方对应的应用类型 API 参数",
+                    "enum": ["workflow", "agent"],
+                    "default": "agent"
+                },
+                "api-key": {
+                    "type": "string",
+                    "title": "API 密钥"
+                },
+                "agent": {
+                    "type": "object",
+                    "title": "Agent API 参数",
+                    "properties": {
+                        "app-id": {
+                            "type": "string",
+                            "title": "应用 ID"
+                        },
+                        "references_quote": {
+                            "type": "string",
+                            "title": "参考资料引用",
+                            "description": "设置参考资料引用，用于从 Dashscope App API 结束节点返回的 JSON 数据中提取引用内容",
+                            "default": "参考资料来自:"
+                        }
+                    }
+                },
+                "workflow": {
+                    "type": "object",
+                    "title": "工作流 API 参数",
+                    "properties": {
+                        "app-id": {
+                            "type": "string",
+                            "title": "应用 ID"
+                        },
+                        "references_quote": {
+                            "type": "string",
+                            "title": "参考资料引用",
+                            "default": "参考资料来自:"
+                        },
+                        "biz_params": {
+                            "type": "object",
+                            "title": "传入参数",
+                            "default": {}
+                        }
+                    }
+                }
+            }
         }
     }
 }

web/package-lock.json

@@ -4410,14 +4410,14 @@
       }
     },
     "node_modules/jsonpath-plus": {
-      "version": "10.1.0",
-      "resolved": "https://registry.npmjs.org/jsonpath-plus/-/jsonpath-plus-10.1.0.tgz",
-      "integrity": "sha512-gHfV1IYqH8uJHYVTs8BJX1XKy2/rR93+f8QQi0xhx95aCiXn1ettYAd5T+7FU6wfqyDoX/wy0pm/fL3jOKJ9Lg==",
+      "version": "10.2.0",
+      "resolved": "https://registry.npmjs.org/jsonpath-plus/-/jsonpath-plus-10.2.0.tgz",
+      "integrity": "sha512-T9V+8iNYKFL2n2rF+w02LBOT2JjDnTjioaNFrxRy0Bv1y/hNsqR/EBK7Ojy2ythRHwmz2cRIls+9JitQGZC/sw==",
       "license": "MIT",
       "dependencies": {
-        "@jsep-plugin/assignment": "^1.2.1",
-        "@jsep-plugin/regex": "^1.0.3",
-        "jsep": "^1.3.9"
+        "@jsep-plugin/assignment": "^1.3.0",
+        "@jsep-plugin/regex": "^1.0.4",
+        "jsep": "^1.4.0"
       },
       "bin": {
         "jsonpath": "bin/jsonpath-cli.js",

web/src/components/MarketPluginCard.vue

@@ -0,0 +1,181 @@
+<template>
+    <div class="plugin-card">
+        <div class="plugin-card-header">
+            <div class="plugin-id">
+                <div class="plugin-card-author">{{ plugin.author }} /</div>
+                <div class="plugin-card-title">{{ plugin.name }}</div>
+            </div>
+            <div class="plugin-card-badges">
+                <v-icon class="plugin-github-source" icon="mdi-github" v-if="plugin.repository != ''"
+                    @click="openGithubSource"></v-icon>
+            </div>
+        </div>
+        <div class="plugin-card-description" >{{ plugin.description }}</div>
+
+        <div class="plugin-card-brief-info">
+            <div class="plugin-card-brief-info-item">
+                <v-icon id="plugin-stars-icon" icon="mdi-star" />
+                <div id="plugin-stars-count">{{ plugin.stars }}</div>
+            </div>
+            <v-btn color="primary" @click="installPlugin" density="compact">安装</v-btn>
+        </div>
+    </div>
+</template>
+
+<script setup>
+const props = defineProps({
+    plugin: {
+        type: Object,
+        required: true
+    },
+});
+
+const emit = defineEmits(['install']);
+
+const openGithubSource = () => {
+    window.open("https://"+props.plugin.repository, '_blank');
+}
+
+const installPlugin = () => {
+    emit('install', props.plugin);
+}
+
+</script>
+
+<style scoped>
+.plugin-card {
+    border: 1px solid #e0e0e0;
+    border-radius: 8px;
+    padding: 0.8rem;
+    padding-left: 1rem;
+    margin: 1rem 0;
+    background-color: white;
+    display: flex;
+    flex-direction: column;
+    justify-content: space-between;
+    height: 10rem;
+}
+
+.plugin-card-header {
+    display: flex;
+    flex-direction: row;
+    justify-content: space-between;
+}
+
+.plugin-card-author {
+    font-size: 0.8rem;
+    color: #666;
+    font-weight: 500;
+    user-select: none;
+}
+
+.plugin-card-title {
+    font-size: 0.9rem;
+    font-weight: 600;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    user-select: none;
+}
+
+.plugin-card-description {
+    font-size: 0.7rem;
+    color: #666;
+    font-weight: 500;
+    margin-top: -1rem;
+    height: 2rem;
+    /* 超出部分自动换行，最多两行 */
+    text-overflow: ellipsis;
+    overflow-y: hidden;
+    white-space: wrap;
+    user-select: none;
+}
+
+.plugin-card-badges {
+    display: flex;
+    flex-direction: row;
+    gap: 0.5rem;
+}
+
+.plugin-github-source {
+    cursor: pointer;
+    color: #222;
+    font-size: 1.3rem;
+}
+
+.plugin-disabled {
+    font-size: 0.7rem;
+    font-weight: 500;
+    height: 1.3rem;
+    padding-inline: 0.4rem;
+    user-select: none;
+}
+
+
+.plugin-card-brief-info {
+    display: flex;
+    flex-direction: row;
+    justify-content: space-between;
+    /* background-color: #f0f0f0; */
+    gap: 0.8rem;
+    margin-left: -0.2rem;
+    margin-bottom: 0rem;
+}
+
+.plugin-card-events {
+    display: flex;
+    flex-direction: row;
+    gap: 0.4rem;
+}
+
+.plugin-card-events-icon {
+    font-size: 1.8rem;
+    color: #666;
+}
+
+.plugin-card-events-count {
+    font-size: 1.2rem;
+    font-weight: 600;
+    color: #666;
+}
+
+.plugin-card-functions {
+    display: flex;
+    flex-direction: row;
+    gap: 0.4rem;
+}
+
+.plugin-card-functions-icon {
+    font-size: 1.6rem;
+    color: #666;
+}
+
+.plugin-card-functions-count {
+    font-size: 1.2rem;
+    font-weight: 600;
+    color: #666;
+}
+
+.plugin-card-brief-info-item {
+    display: flex;
+    flex-direction: row;
+    gap: 0.4rem;
+}
+
+#plugin-stars-icon {
+    color: #0073ff;
+}
+
+#plugin-stars-count {
+    margin-top: 0.1rem;
+    font-weight: 700;
+    color: #0073ff;
+    user-select: none;
+}
+
+.plugin-card-brief-info-item:hover .plugin-card-brief-info-item-icon {
+    color: #333;
+}
+
+
+</style>

web/src/components/Marketplace.vue

@@ -0,0 +1,228 @@
+<template>
+    <div id="marketplace-container">
+        <div id="marketplace-search-bar">
+            
+            <span style="width: 14rem;">
+                <v-text-field id="marketplace-search-bar-search-input" variant="solo" v-model="proxy.$store.state.marketplaceParams.query" label="搜索"
+                    density="compact" @update:model-value="updateSearch" />
+            </span>
+            <!--下拉选择排序-->
+            <span style="width: 10rem;">
+                <v-select id="marketplace-search-bar-sort-select" v-model="sort" :items="sortItems" variant="solo"
+                    label="排序" density="compact" @update:model-value="updateSort" />
+            </span>
+            <span style="margin-left: 1rem;">
+                <div id="marketplace-search-bar-total-plugins-count">
+                    共 {{ proxy.$store.state.marketplaceTotalPluginsCount }} 个插件
+                </div>
+            </span>
+            <span style="margin-left: 1rem;">
+                <!-- 分页 -->
+                <v-pagination style="width: 14rem;" v-model="proxy.$store.state.marketplaceParams.page"
+                    :length="proxy.$store.state.marketplaceTotalPages" variant="solo" density="compact"
+                    total-visible="4" @update:model-value="updatePage" />
+            </span>
+        </div>
+        <div id="marketplace-plugins-container" ref="pluginsContainer">
+            <div id="marketplace-plugins-container-inner">
+                <MarketPluginCard v-for="plugin in proxy.$store.state.marketplacePlugins" :key="plugin.id" :plugin="plugin" @install="installPlugin" />
+            </div>
+        </div>
+    </div>
+</template>
+
+<script setup>
+import MarketPluginCard from './MarketPluginCard.vue'
+
+import { ref, getCurrentInstance, onMounted } from 'vue'
+
+import { inject } from "vue";
+
+const snackbar = inject('snackbar');
+
+const { proxy } = getCurrentInstance()
+
+const pluginsContainer = ref(null)
+
+const sortItems = ref([
+    '最近新增',
+    '最多星标',
+    '最近更新',
+])
+
+const sortParams = ref({
+    '最近新增': {
+        sort_by: 'created_at',
+        sort_order: 'DESC',
+    },
+    '最多星标': {
+        sort_by: 'stars',
+        sort_order: 'DESC',
+    },
+    '最近更新': {
+        sort_by: 'pushed_at',
+        sort_order: 'DESC',
+    }
+})
+
+const sort = ref(sortItems.value[0])
+
+proxy.$store.state.marketplaceParams.sort_by = sortParams.value[sort.value].sort_by
+proxy.$store.state.marketplaceParams.sort_order = sortParams.value[sort.value].sort_order
+
+const updateSort = (value) => {
+    console.log(value)
+    proxy.$store.state.marketplaceParams.sort_by = sortParams.value[value].sort_by
+    proxy.$store.state.marketplaceParams.sort_order = sortParams.value[value].sort_order
+    proxy.$store.state.marketplaceParams.page = 1
+
+    console.log(proxy.$store.state.marketplaceParams)
+    fetchMarketplacePlugins()
+}
+
+const updatePage = (value) => {
+    proxy.$store.state.marketplaceParams.page = value
+    fetchMarketplacePlugins()
+}
+
+const updateSearch = (value) => {
+    console.log(value)
+    proxy.$store.state.marketplaceParams.query = value
+    proxy.$store.state.marketplaceParams.page = 1
+    fetchMarketplacePlugins()
+}
+
+const calculatePluginsPerPage = () => {
+    if (!pluginsContainer.value) return 10
+    
+    const containerWidth = pluginsContainer.value.clientWidth
+    const containerHeight = pluginsContainer.value.clientHeight
+
+    console.log(containerWidth, containerHeight)
+    
+    // 每个卡片宽度18rem + gap 16px
+    const cardWidth = 18 * 16 + 16 // rem转px
+    // 每个卡片高度9rem + gap 16px
+    const cardHeight = 9 * 16 + 16
+    
+    // 计算每行可以放几个卡片
+    const cardsPerRow = Math.floor(containerWidth / cardWidth)
+    // 计算每行可以放几行
+    const rows = Math.floor(containerHeight / cardHeight)
+    
+    // 计算每页总数
+    const perPage = cardsPerRow * rows
+    
+    proxy.$store.state.marketplaceParams.per_page = perPage > 0 ? perPage : 10
+}
+
+const fetchMarketplacePlugins = async () => {
+    calculatePluginsPerPage()
+    proxy.$axios.post('https://space.langbot.app/api/v1/market/plugins', {
+        query: proxy.$store.state.marketplaceParams.query,
+        sort_by: proxy.$store.state.marketplaceParams.sort_by,
+        sort_order: proxy.$store.state.marketplaceParams.sort_order,
+        page: proxy.$store.state.marketplaceParams.page,
+        page_size: proxy.$store.state.marketplaceParams.per_page,
+    }).then(response => {
+        console.log(response.data)
+        if (response.data.code != 0) {
+            snackbar.error(response.data.msg)
+            return
+        }
+
+        // 解析出 name 和 author
+        response.data.data.plugins.forEach(plugin => {
+            plugin.name = plugin.repository.split('/')[2]
+            plugin.author = plugin.repository.split('/')[1]
+        })
+
+        proxy.$store.state.marketplacePlugins = response.data.data.plugins
+        proxy.$store.state.marketplaceTotalPluginsCount = response.data.data.total
+
+        let totalPages = Math.floor(response.data.data.total / proxy.$store.state.marketplaceParams.per_page)
+        if (response.data.data.total % proxy.$store.state.marketplaceParams.per_page != 0) {
+            totalPages += 1
+        }
+        proxy.$store.state.marketplaceTotalPages = totalPages
+    }).catch(error => {
+        snackbar.error(error)
+    })
+}
+
+onMounted(() => {
+    calculatePluginsPerPage()
+    fetchMarketplacePlugins()
+    
+    // 监听窗口大小变化
+    window.addEventListener('resize', () => {
+        calculatePluginsPerPage()
+        fetchMarketplacePlugins()
+    })
+})
+
+const emit = defineEmits(['installPlugin'])
+
+const installPlugin = (plugin) => {
+    emit('installPlugin', plugin.repository)
+}
+</script>
+
+<style scoped>
+#marketplace-container {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    width: 100%;
+    height: 100%;
+}
+
+#marketplace-search-bar {
+    display: flex;
+    flex-direction: row;
+    margin-top: 1rem;
+    padding-right: 1rem;
+    gap: 1rem;
+    width: 100%;
+}
+
+#marketplace-search-bar-search-input {
+    position: relative;
+    left: 1rem;
+    width: 10rem;
+}
+
+#marketplace-search-bar-total-plugins-count {
+    font-size: 1.1rem;
+    font-weight: 500;
+    margin-top: 0.5rem;
+    color: #666;
+    user-select: none;
+}
+
+.plugin-card {
+    width: 18rem;
+    height: 9rem;
+}
+
+#marketplace-plugins-container {
+    display: flex;
+    flex-direction: row;
+    justify-content: flex-start;
+    flex-wrap: wrap;
+    gap: 16px;
+    margin-inline: 0rem;
+    width: 100%;
+    height: calc(100vh - 16rem);
+    overflow-y: auto;
+}
+
+#marketplace-plugins-container-inner {
+    display: flex;
+    flex-direction: row;
+    justify-content: flex-start;
+    flex-wrap: wrap;
+    gap: 16px;
+}
+</style>

web/src/pages/Plugins.vue

@@ -2,6 +2,10 @@
     <PageTitle title="插件" @refresh="refresh" />
     <v-card id="plugins-toolbar">
         <div id="view-btns">
+            <v-btn-toggle id="plugins-view-toggle" color="primary" v-model="proxy.$store.state.pluginsView" mandatory density="compact">
+                <v-btn class="plugins-view-toggle-btn" value="installed" density="compact">已安装</v-btn>
+                <v-btn class="plugins-view-toggle-btn" value="market" density="compact">插件市场</v-btn>
+            </v-btn-toggle>
         </div>
         <div id="operation-btns">
             <v-tooltip text="设置插件优先级" location="top">
@@ -78,17 +82,21 @@
             </v-btn>
         </div>
     </v-card>
-    <div class="plugins-container">
+    <div class="plugins-container" v-if="proxy.$store.state.pluginsView == 'installed'">
         <v-alert id="no-plugins-alert" v-if="plugins.length == 0" color="warning" icon="$warning" title="暂无插件" text="暂无已安装的插件，请安装插件" density="compact" style="margin-inline: 1rem;"></v-alert>
         <PluginCard class="plugin-card" v-if="plugins.length > 0" v-for="plugin in plugins" :key="plugin.name" :plugin="plugin"
             @toggle="togglePlugin" @update="updatePlugin" @remove="removePlugin" />
     </div>
+    <div class="plugins-container" v-if="proxy.$store.state.pluginsView == 'market'">
+        <Marketplace @installPlugin="installMarketplacePlugin" />
+    </div>
 </template>
 
 <script setup>
 
 import PageTitle from '@/components/PageTitle.vue'
 import PluginCard from '@/components/PluginCard.vue'
+import Marketplace from '@/components/Marketplace.vue'
 
 import draggable from 'vuedraggable'
 
@@ -154,6 +162,12 @@ const removePlugin = (plugin) => {
     })
 }
 
+const installMarketplacePlugin = (repository) => {
+
+    installDialogSource.value = 'https://'+repository
+    isInstallDialogActive.value = true
+}
+
 const installPlugin = () => {
 
     if (installDialogSource.value == '' || installDialogSource.value.trim() == '') {
@@ -224,6 +238,11 @@ const installDialogSource = ref('')
     margin-left: 1rem;
 }
 
+#plugins-view-toggle {
+    margin: 0.5rem;
+    box-shadow: 0 0 0 2px #dddddd;
+}
+
 #operation-btns {
     display: flex;
     flex-direction: row;

web/src/store/index.js

@@ -18,7 +18,18 @@ export default createStore({
       tokenValid: false,
       systemInitialized: true,
       jwtToken: '',
-    }
+    },
+    pluginsView: 'installed',
+    marketplaceParams: {
+      query: '',
+      page: 1,
+      per_page: 10,
+      sort_by: 'pushed_at',
+      sort_order: 'DESC',
+    },
+    marketplacePlugins: [],
+    marketplaceTotalPages: 0,
+    marketplaceTotalPluginsCount: 0,
   },
   mutations: {
     initializeFetch() {