chore: release v3.4.10

feat(dingtalk): add supports for audio receiving

.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

@@ -29,6 +29,7 @@ qcapi
 claude.json
 bard.json
 /*yaml
+!components.yaml
 !/docker-compose.yaml
 data/labels/instance_id.json
 .DS_Store
@@ -37,4 +38,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,29 @@
 <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-966235608-blue)](https://qm.qq.com/q/JLi38whHum)
 [![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">
+[![star](https://gitcode.com/RockChinQ/LangBot/star/badge.svg)](https://gitcode.com/RockChinQ/LangBot)
+
+[简体中文](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、Telegram 等平台。
 - 🛠️ 高稳定性、功能完备：原生支持访问控制、限速、敏感词过滤等机制；配置简单，支持多种部署方式。
 - 🧩 插件扩展、活跃社区：支持事件驱动、组件扩展等插件机制；丰富生态，目前已有数十个[插件](https://docs.langbot.app/plugin/plugin-intro.html)
 - 😻 [New] Web 管理面板：支持通过浏览器管理 LangBot 实例，具体支持功能，查看[文档](https://docs.langbot.app/webui/intro.html)
@@ -81,9 +85,15 @@
 | 平台 | 状态 | 备注 |
 | --- | --- | --- |
 | QQ 个人号 | ✅ | QQ 个人号私聊、群聊 |
-| QQ 官方机器人 | ✅ | QQ 频道机器人，支持频道、私聊、群聊 |
+| QQ 官方机器人 | ✅ | QQ 官方机器人，支持频道、私聊、群聊 |
 | 企业微信 | ✅ |  |
-| 钉钉 | 🚧 |  |
+| 个人微信 | ✅ | 使用 [Gewechat](https://github.com/Devo919/Gewechat) 接入 |
+| 微信公众号 | ✅ |  |
+| 飞书 | ✅ |  |
+| 钉钉 | ✅ |  |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| WhatsApp | 🚧 |  |
 
 🚧: 正在开发中
 
@@ -98,5 +108,18 @@
 | [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 平台 |
+| [火山方舟](https://console.volcengine.com/ark/region:ark+cn-beijing/model?vendor=Bytedance&view=LIST_VIEW) | ✅ | 大模型聚合平台, 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,124 @@
+<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, personal WeChat, Lark, DingTalk, Discord, Telegram, etc.
+- 🛠️ 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 |
+| [Volc Engine Ark](https://console.volcengine.com/ark/region:ark+cn-beijing/model?vendor=Bytedance&view=LIST_VIEW) | ✅ | 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,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">ホーム</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 チャンネル、WeChat、個人 WeChat、Lark、DingTalk、Discord、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プラットフォーム |
+| [Volc Engine Ark](https://console.volcengine.com/ark/region:ark+cn-beijing/model?vendor=Bytedance&view=LIST_VIEW) | ✅ | LLMゲートウェイ(MaaS), LLMOpsプラットフォーム |
+
+## 🤝 コミュニティ貢献
+
+以下の貢献者とコミュニティの皆さんの貢献に感謝します。
+
+
+<a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
+</a>
+
+

components.yaml

@@ -0,0 +1,19 @@
+apiVersion: v1
+kind: Blueprint
+metadata:
+  name: builtin-components
+  label:
+    en_US: Builtin Components
+    zh_CN: 内置组件
+spec:
+  components:
+    ComponentTemplate:
+      fromFiles:
+        - pkg/platform/adapter.yaml
+        - pkg/provider/modelmgr/requester.yaml
+    MessagePlatformAdapter:
+      fromDirs:
+        - path: pkg/platform/sources/
+    LLMAPIRequester:
+      fromDirs:
+        - path: pkg/provider/modelmgr/requesters/

libs/dingtalk_api/EchoHandler.py

@@ -0,0 +1,30 @@
+import asyncio
+import json
+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,203 @@
+import base64
+import json
+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 get_audio_url(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")
+                if download_url:
+                    return await self.download_url_to_base64(download_url)
+                else:
+                    raise Exception("获取音频失败")
+            else:
+                raise Exception(f"Error: {response.status_code}, {response.text}")
+                
+    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:
+            # print(json.dumps(incoming_message.to_dict(), indent=4, ensure_ascii=False))
+            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'
+            elif incoming_message.message_type == 'audio':
+                message_data['Audio'] = await self.get_audio_url(incoming_message.to_dict()['content']['downloadCode'])
+
+                message_data['Type'] = 'audio'
+
+            copy_message_data = message_data.copy()
+            del copy_message_data['IncomingMessage']
+            # print("message_data:", json.dumps(copy_message_data, indent=4, ensure_ascii=False))
+        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,69 @@
+from typing import Dict, Any, Optional
+import dingtalk_stream
+
+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) -> Optional["dingtalk_stream.chatbot.ChatbotMessage"]:
+        return self.get("IncomingMessage")
+
+    @property
+    def type(self):
+        return self.get("Type","")
+    
+    @property
+    def picture(self):
+        return self.get("Picture","")
+    
+    @property
+    def audio(self):
+        return self.get("Audio","")
+
+    @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"<DingTalkEvent {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/app.py

@@ -25,9 +25,11 @@ from ..utils import version as version_mgr, proxy as proxy_mgr, announce as anno
 from ..persistence import mgr as persistencemgr
 from ..api.http.controller import main as http_controller
 from ..api.http.service import user as user_service
+from ..discover import engine as discover_engine
 from ..utils import logcache, ip
 from . import taskmgr
 from . import entities as core_entities
+from .bootutils import config
 
 
 class Application:
@@ -38,6 +40,8 @@ class Application:
     # asyncio_tasks: list[asyncio.Task] = []
     task_mgr: taskmgr.AsyncTaskManager = None
 
+    discover: discover_engine.ComponentDiscoveryEngine = None
+
     platform_mgr: im_mgr.PlatformManager = None
 
     cmd_mgr: cmdmgr.CommandManager = None
@@ -200,6 +204,8 @@ class Application:
             case core_entities.LifecycleControlScope.PROVIDER.value:
                 self.logger.info("执行热重载 scope="+scope)
 
+                latest_llm_model_config = await config.load_json_config("data/metadata/llm-models.json", "templates/metadata/llm-models.json")
+                self.llm_models_meta = latest_llm_model_config
                 llm_model_mgr_inst = llm_model_mgr.ModelManager(self)
                 await llm_model_mgr_inst.initialize()
                 self.model_mgr = llm_model_mgr_inst

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/entities.py

@@ -57,7 +57,7 @@ class Query(pydantic.BaseModel):
     message_chain: platform_message.MessageChain
     """消息链，platform收到的原始消息链"""
 
-    adapter: msadapter.MessageSourceAdapter
+    adapter: msadapter.MessagePlatformAdapter
     """消息平台适配器对象，单个app中可能启用了多个消息平台适配器，此对象表明发起此query的适配器"""
 
     session: typing.Optional[Session] = None

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,33 @@
+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",
+            "gewechat_file_url": "http://your-gewechat-server:2532",
+            "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/migrations/m032_volcark_config.py

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

pkg/core/migrations/m033_dify_thinking_config.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("dify-thinking-config", 33)
+class DifyThinkingConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        
+        if 'options' not in self.ap.provider_cfg.data["dify-service-api"]:
+            return True
+
+        if 'convert-thinking-tips' not in self.ap.provider_cfg.data["dify-service-api"]["options"]:
+            return True
+
+        return False
+    
+    async def run(self):
+        """执行迁移"""
+        self.ap.provider_cfg.data["dify-service-api"]["options"] = {
+            "convert-thinking-tips": "plain"
+        }
+        await self.ap.provider_cfg.dump_config()

pkg/core/migrations/m034_gewechat_file_url_config.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+from .. import migration
+
+
+@migration.migration_class("gewechat-file-url-config", 34)
+class GewechatFileUrlConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] == 'gewechat':
+                if 'gewechat_file_url' not in adapter:
+                    return True
+        return False
+
+    async def run(self):
+        """执行迁移"""
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] == 'gewechat':
+                if 'gewechat_file_url' not in adapter:
+                    parsed_url = urlparse(adapter['gewechat_url'])
+                    adapter['gewechat_file_url'] = f"{parsed_url.scheme}://{parsed_url.hostname}:2532"
+
+        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/build_app.py

@@ -18,6 +18,7 @@ from ...platform import manager as im_mgr
 from ...persistence import mgr as persistencemgr
 from ...api.http.controller import main as http_controller
 from ...api.http.service import user as user_service
+from ...discover import engine as discover_engine
 from ...utils import logcache
 from .. import taskmgr
 
@@ -32,6 +33,12 @@ class BuildAppStage(stage.BootingStage):
         """
         ap.task_mgr = taskmgr.AsyncTaskManager(ap)
 
+        discover = discover_engine.ComponentDiscoveryEngine(ap)
+        discover.discover_blueprint(
+            "components.yaml"
+        )
+        ap.discover = discover
+
         proxy_mgr = proxy.ProxyManager(ap)
         await proxy_mgr.initialize()
         ap.proxy_mgr = proxy_mgr

pkg/core/stages/migrate.py

@@ -8,8 +8,10 @@ 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, m032_volcark_config
+from ..migrations import m033_dify_thinking_config, m034_gewechat_file_url_config
 
 @stage.stage_class("MigrationStage")
 class MigrationStage(stage.BootingStage):

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/discover/engine.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import typing
+import importlib
+import os
+import inspect
+
+import yaml
+import pydantic
+
+from ..core import app
+
+
+class I18nString(pydantic.BaseModel):
+    """国际化字符串"""
+
+    en_US: str
+    """英文"""
+
+    zh_CN: typing.Optional[str] = None
+    """中文"""
+
+    ja_JP: typing.Optional[str] = None
+    """日文"""
+
+
+class Metadata(pydantic.BaseModel):
+    """元数据"""
+
+    name: str
+    """名称"""
+
+    label: I18nString
+    """标签"""
+
+    description: typing.Optional[I18nString] = None
+    """描述"""
+
+    icon: typing.Optional[str] = None
+    """图标"""
+
+
+class PythonExecution(pydantic.BaseModel):
+    """Python执行"""
+
+    path: str
+    """路径"""
+
+    attr: str
+    """属性"""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        if self.path.startswith('./'):
+            self.path = self.path[2:]
+
+
+class Execution(pydantic.BaseModel):
+    """执行"""
+
+    python: PythonExecution
+    """Python执行"""
+
+
+class Component(pydantic.BaseModel):
+    """组件清单"""
+
+    owner: str
+    """组件所属"""
+
+    manifest: typing.Dict[str, typing.Any]
+    """组件清单内容"""
+
+    rel_path: str
+    """组件清单相对main.py的路径"""
+
+    _metadata: Metadata
+    """组件元数据"""
+
+    _spec: typing.Dict[str, typing.Any]
+    """组件规格"""
+
+    _execution: Execution
+    """组件执行"""
+
+    def __init__(self, owner: str, manifest: typing.Dict[str, typing.Any], rel_path: str):
+        super().__init__(
+            owner=owner,
+            manifest=manifest,
+            rel_path=rel_path
+        )
+        self._metadata = Metadata(**manifest['metadata'])
+        self._spec = manifest['spec']
+        self._execution = Execution(**manifest['execution']) if 'execution' in manifest else None
+
+    @property
+    def kind(self) -> str:
+        """组件类型"""
+        return self.manifest['kind']
+    
+    @property
+    def metadata(self) -> Metadata:
+        """组件元数据"""
+        return self._metadata
+    
+    @property
+    def spec(self) -> typing.Dict[str, typing.Any]:
+        """组件规格"""
+        return self._spec
+    
+    @property
+    def execution(self) -> Execution:
+        """组件执行"""
+        return self._execution
+    
+    def get_python_component_class(self) -> typing.Type[typing.Any]:
+        """获取Python组件类"""
+        parent_path = os.path.dirname(self.rel_path)
+        module_path = os.path.join(parent_path, self.execution.python.path)
+        if module_path.endswith('.py'):
+            module_path = module_path[:-3]
+        module_path = module_path.replace('/', '.').replace('\\', '.')
+        module = importlib.import_module(module_path)
+        return getattr(module, self.execution.python.attr)
+
+
+class ComponentDiscoveryEngine:
+    """组件发现引擎"""
+
+    ap: app.Application
+    """应用实例"""
+
+    components: typing.Dict[str, typing.List[Component]] = {}
+    """组件列表"""
+
+    def __init__(self, ap: app.Application):
+        self.ap = ap
+
+    def load_component_manifest(self, path: str, owner: str = 'builtin', no_save: bool = False) -> Component:
+        """加载组件清单"""
+        with open(path, 'r', encoding='utf-8') as f:
+            manifest = yaml.safe_load(f)
+            comp = Component(
+                owner=owner,
+                manifest=manifest,
+                rel_path=path
+            )
+            if not no_save:
+                if comp.kind not in self.components:
+                    self.components[comp.kind] = []
+                self.components[comp.kind].append(comp)
+            return comp
+        
+    def load_component_manifests_in_dir(self, path: str, owner: str = 'builtin', no_save: bool = False) -> typing.List[Component]:
+        """加载目录中的组件清单"""
+        components: typing.List[Component] = []
+        for file in os.listdir(path):
+            if file.endswith('.yaml') or file.endswith('.yml'):
+                components.append(self.load_component_manifest(os.path.join(path, file), owner, no_save))
+        return components
+    
+    def load_blueprint_comp_group(self, group: dict, owner: str = 'builtin', no_save: bool = False) -> typing.List[Component]:
+        """加载蓝图组件组"""
+        components: typing.List[Component] = []
+        if 'fromFiles' in group:
+            for file in group['fromFiles']:
+                components.append(self.load_component_manifest(file, owner, no_save))
+        if 'fromDirs' in group:
+            for dir in group['fromDirs']:
+                path = dir['path']
+                # depth = dir['depth']
+                components.extend(self.load_component_manifests_in_dir(path, owner, no_save))
+        return components
+
+    def discover_blueprint(self, blueprint_manifest_path: str, owner: str = 'builtin'):
+        """发现蓝图"""
+        blueprint_manifest = self.load_component_manifest(blueprint_manifest_path, owner, no_save=True)
+        assert blueprint_manifest.kind == 'Blueprint', '`Kind` must be `Blueprint`'
+        components: typing.Dict[str, typing.List[Component]] = {}
+
+        # load ComponentTemplate first
+        if 'ComponentTemplate' in blueprint_manifest.spec['components']:
+            components['ComponentTemplate'] = self.load_blueprint_comp_group(blueprint_manifest.spec['components']['ComponentTemplate'], owner)
+
+        for name, component in blueprint_manifest.spec['components'].items():
+            if name == 'ComponentTemplate':
+                continue
+            components[name] = self.load_blueprint_comp_group(component, owner)
+        
+        self.ap.logger.debug(f'Components: {components}')
+
+        return blueprint_manifest, components
+
+
+    def get_components_by_kind(self, kind: str) -> typing.List[Component]:
+        """获取指定类型的组件"""
+        if kind not in self.components:
+            raise ValueError(f'No components found for kind: {kind}')
+        return self.components[kind]

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/pool.py

@@ -33,7 +33,7 @@ class QueryPool:
         sender_id: typing.Union[int, str],
         message_event: platform_events.MessageEvent,
         message_chain: platform_message.MessageChain,
-        adapter: msadapter.MessageSourceAdapter
+        adapter: msadapter.MessagePlatformAdapter
     ) -> entities.Query:
         async with self.condition:
             query = entities.Query(

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/adapter.py

@@ -10,27 +10,7 @@ from .types import message as platform_message
 from .types import events as platform_events
 
 
-preregistered_adapters: list[typing.Type[MessageSourceAdapter]] = []
-
-def adapter_class(
-    name: str
-):
-    """消息平台适配器类装饰器
-
-    Args:
-        name (str): 适配器名称
-
-    Returns:
-        typing.Callable[[typing.Type[MessageSourceAdapter]], typing.Type[MessageSourceAdapter]]: 装饰器
-    """
-    def decorator(cls: typing.Type[MessageSourceAdapter]) -> typing.Type[MessageSourceAdapter]:
-        cls.name = name
-        preregistered_adapters.append(cls)
-        return cls
-    return decorator
-
-
-class MessageSourceAdapter(metaclass=abc.ABCMeta):
+class MessagePlatformAdapter(metaclass=abc.ABCMeta):
     """消息平台适配器基类"""
 
     name: str
@@ -89,7 +69,7 @@ class MessageSourceAdapter(metaclass=abc.ABCMeta):
     def register_listener(
         self,
         event_type: typing.Type[platform_message.Event],
-        callback: typing.Callable[[platform_message.Event, MessageSourceAdapter], None]
+        callback: typing.Callable[[platform_message.Event, MessagePlatformAdapter], None]
     ):
         """注册事件监听器
         
@@ -102,7 +82,7 @@ class MessageSourceAdapter(metaclass=abc.ABCMeta):
     def unregister_listener(
         self,
         event_type: typing.Type[platform_message.Event],
-        callback: typing.Callable[[platform_message.Event, MessageSourceAdapter], None]
+        callback: typing.Callable[[platform_message.Event, MessagePlatformAdapter], None]
     ):
         """注销事件监听器
         

pkg/platform/adapter.yaml

@@ -0,0 +1,14 @@
+apiVersion: v1
+kind: ComponentTemplate
+metadata:
+  name: MessagePlatformAdapter
+  label:
+    en_US: Message Platform Adapter
+    zh_CN: 消息平台适配器模板类
+spec:
+  type:
+    - python
+execution:
+  python:
+    path: ./adapter.py
+    attr: MessagePlatformAdapter

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
 
@@ -16,6 +18,8 @@ from .types import message as platform_message
 from .types import events as platform_events
 from .types import entities as platform_entities
 
+from ..discover import engine
+
 # 处理 3.4 移除了 YiriMirai 之后，插件的兼容性问题
 from . import types as mirai
 sys.modules['mirai'] = mirai
@@ -25,7 +29,9 @@ sys.modules['mirai'] = mirai
 class PlatformManager:
     
     # adapter: msadapter.MessageSourceAdapter = None
-    adapters: list[msadapter.MessageSourceAdapter] = []
+    adapters: list[msadapter.MessagePlatformAdapter] = []
+
+    message_platform_adapter_components: list[engine.Component] = []
 
     # modern
     ap: app.Application = None
@@ -37,9 +43,13 @@ class PlatformManager:
     
     async def initialize(self):
 
-        from .sources import nakuru, aiocqhttp, qqbotpy,wecom
+        components = self.ap.discover.get_components_by_kind('MessagePlatformAdapter')
 
-        async def on_friend_message(event: platform_events.FriendMessage, adapter: msadapter.MessageSourceAdapter):
+        self.message_platform_adapter_components = components
+
+        # 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.MessagePlatformAdapter):
 
             await self.ap.query_pool.add_query(
                 launcher_type=core_entities.LauncherTypes.PERSON,
@@ -50,7 +60,7 @@ class PlatformManager:
                 adapter=adapter
             )
 
-        async def on_group_message(event: platform_events.GroupMessage, adapter: msadapter.MessageSourceAdapter):
+        async def on_group_message(event: platform_events.GroupMessage, adapter: msadapter.MessagePlatformAdapter):
 
             await self.ap.query_pool.add_query(
                 launcher_type=core_entities.LauncherTypes.GROUP,
@@ -74,10 +84,10 @@ class PlatformManager:
 
                 found = False
 
-                for adapter in msadapter.preregistered_adapters:
-                    if adapter.name == adapter_name:
+                for adapter in self.message_platform_adapter_components:
+                    if adapter.metadata.name == adapter_name:
                         found = True
-                        adapter_cls = adapter
+                        adapter_cls = adapter.get_python_component_class()
                         
                         adapter_inst = adapter_cls(
                             cfg_copy,
@@ -100,7 +110,36 @@ class PlatformManager:
         if len(self.adapters) == 0:
             self.ap.logger.warning('未运行平台适配器，请根据文档配置并启用平台适配器。')
 
-    async def send(self, event: platform_events.MessageEvent, msg: platform_message.MessageChain, adapter: msadapter.MessageSourceAdapter):
+    async def write_back_config(self, adapter_name: str, adapter_inst: msadapter.MessagePlatformAdapter, 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_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.MessagePlatformAdapter):
         
         if self.ap.platform_cfg.data['at-sender'] and isinstance(event, platform_events.GroupMessage):
 
@@ -121,7 +160,7 @@ class PlatformManager:
         try:
             tasks = []
             for adapter in self.adapters:
-                async def exception_wrapper(adapter: msadapter.MessageSourceAdapter):
+                async def exception_wrapper(adapter: msadapter.MessagePlatformAdapter):
                     try:
                         await adapter.run_async()
                     except Exception as e:
@@ -136,7 +175,7 @@ class PlatformManager:
                 self.ap.task_mgr.create_task(
                     task,
                     kind="platform-adapter",
-                    name=f"platform-adapter-{adapter.name}",
+                    name=f"platform-adapter-{adapter.__class__.__name__}",
                     scopes=[core_entities.LifecycleControlScope.APPLICATION, core_entities.LifecycleControlScope.PLATFORM],
                 )
 

pkg/platform/sources/aiocqhttp.py

@@ -210,8 +210,7 @@ class AiocqhttpEventConverter(adapter.EventConverter):
             )
 
 
-@adapter.adapter_class("aiocqhttp")
-class AiocqhttpAdapter(adapter.MessageSourceAdapter):
+class AiocqhttpAdapter(adapter.MessagePlatformAdapter):
 
     bot: aiocqhttp.CQHttp
 
@@ -273,7 +272,7 @@ class AiocqhttpAdapter(adapter.MessageSourceAdapter):
     def register_listener(
         self,
         event_type: typing.Type[platform_events.Event],
-        callback: typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None],
+        callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
     ):
         async def on_message(event: aiocqhttp.Event):
             self.bot_account_id = event.self_id
@@ -290,7 +289,7 @@ class AiocqhttpAdapter(adapter.MessageSourceAdapter):
     def unregister_listener(
         self,
         event_type: typing.Type[platform_events.Event],
-        callback: typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None],
+        callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
     ):
         return super().unregister_listener(event_type, callback)
 

pkg/platform/sources/aiocqhttp.yaml

@@ -0,0 +1,37 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: aiocqhttp
+  label:
+    en_US: OneBot v11 Adapter
+    zh_CN: OneBot v11 适配器
+  description:
+    en_US: OneBot v11 Adapter
+    zh_CN: OneBot v11 适配器
+spec:
+  config:
+    - name: host
+      label:
+        en_US: Host
+        zh_CN: 主机
+      type: string
+      required: true
+      default: 0.0.0.0
+    - name: port
+      label:
+        en_US: Port
+        zh_CN: 端口
+      type: int
+      required: true
+      default: 2280
+    - name: access-token
+      label:
+        en_US: Access Token
+        zh_CN: 访问令牌
+      type: string
+      required: false
+      default: ""
+execution:
+  python:
+    path: ./aiocqhttp.py
+    attr: AiocqhttpAdapter

pkg/platform/sources/dingtalk.py

@@ -0,0 +1,189 @@
+
+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 MessagePlatformAdapter
+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, bot_name:str):
+        yiri_msg_list = []
+        yiri_msg_list.append(
+            platform_message.Source(id = event.incoming_message.message_id,time=datetime.datetime.now())
+        )
+
+        for atUser in event.incoming_message.at_users:
+            if atUser.dingtalk_id == event.incoming_message.chatbot_user_id:
+                yiri_msg_list.append(platform_message.At(target=bot_name))
+
+        if event.content:
+            text_content = event.content.replace("@"+bot_name, '')
+            yiri_msg_list.append(platform_message.Plain(text=text_content))
+        if event.picture:
+            yiri_msg_list.append(platform_message.Image(base64=event.picture))
+        if event.audio:
+            yiri_msg_list.append(platform_message.Voice(base64=event.audio))
+
+        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,
+        bot_name:str
+    ):
+        
+        message_chain = await DingTalkMessageConverter.target2yiri(event, bot_name)
+
+
+        if event.conversation == 'FriendMessage':
+
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id=event.incoming_message.sender_id,
+                    nickname = event.incoming_message.sender_nick,
+                    remark=""
+                ),
+                message_chain = message_chain,
+                time = datetime.datetime.now(),
+                source_platform_object=event,
+            )
+        elif event.conversation == 'GroupMessage':
+            sender = platform_entities.GroupMember(
+                id = event.incoming_message.sender_id,
+                member_name=event.incoming_message.sender_nick,
+                permission= 'MEMBER',
+                group = platform_entities.Group(
+                    id = event.incoming_message.conversation_id,
+                    name = event.incoming_message.conversation_title,
+                    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
+            )
+
+
+class DingTalkAdapter(adapter.MessagePlatformAdapter):
+    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_account_id = self.config["robot_name"]
+        
+        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.MessagePlatformAdapter], None
+        ],
+    ):
+        async def on_message(event: DingTalkEvent):
+            try:
+                return await callback(
+                    await self.event_converter.target2yiri(event, self.config["robot_name"]), 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, MessagePlatformAdapter], None],
+    ):
+        return super().unregister_listener(event_type, callback)
+

pkg/platform/sources/dingtalk.yaml

@@ -0,0 +1,44 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: dingtalk
+  label:
+    en_US: DingTalk
+    zh_CN: 钉钉
+  description:
+    en_US: DingTalk Adapter
+    zh_CN: 钉钉适配器
+spec:
+  config:
+    - name: client_id
+      label:
+        en_US: Client ID
+        zh_CN: 客户端ID
+      type: string
+      required: true
+      default: ""
+    - name: client_secret
+      label:
+        en_US: Client Secret
+        zh_CN: 客户端密钥
+      type: string
+      required: true
+      default: ""
+    - name: robot_code
+      label:
+        en_US: Robot Code
+        zh_CN: 机器人代码
+      type: string
+      required: true
+      default: ""
+    - name: robot_name
+      label:
+        en_US: Robot Name
+        zh_CN: 机器人名称
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./dingtalk.py
+    attr: DingTalkAdapter

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,
+            )
+
+
+class DiscordAdapter(adapter.MessagePlatformAdapter):
+
+    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.MessagePlatformAdapter], 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.MessagePlatformAdapter], None],
+    ):
+        self.listeners[event_type] = callback
+
+    def unregister_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], 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/discord.yaml

@@ -0,0 +1,30 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: discord
+  label:
+    en_US: Discord
+    zh_CN: Discord
+  description:
+    en_US: Discord Adapter
+    zh_CN: Discord 适配器
+spec:
+  config:
+    - name: client_id
+      label:
+        en_US: Client ID
+        zh_CN: 客户端ID
+      type: string
+      required: true
+      default: ""
+    - name: token
+      label:
+        en_US: Token
+        zh_CN: 令牌
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./discord.py
+    attr: DiscordAdapter

pkg/platform/sources/gewechat.py

@@ -0,0 +1,361 @@
+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):
+
+    def __init__(self, config: dict):
+        self.config = config
+
+    @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):
+                if not component.url:
+                    pass
+                content_list.append({"type": "image", "image": component.url})
+
+
+            elif isinstance(component, platform_message.Voice):
+                content_list.append({"type": "voice", "url": component.url, "length": component.length})
+            elif isinstance(component, platform_message.Forward):
+                for node in component.node_list:
+                    content_list.extend(await GewechatMessageConverter.yiri2target(node.message_chain))
+
+        return content_list
+
+    async def target2yiri(
+        self,
+        message: dict,
+        bot_account_id: str
+    ) -> platform_message.MessageChain:
+
+        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_xml = message["Data"]["Content"]["string"]
+            if not image_xml:
+                return platform_message.MessageChain([
+                    platform_message.Plain(text="[图片内容为空]")
+                ])
+
+
+            try:
+                base64_str, image_format = await image.get_gewechat_image_base64(
+                    gewechat_url=self.config["gewechat_url"],
+                    gewechat_file_url=self.config["gewechat_file_url"],
+                    app_id=self.config["app_id"],
+                    xml_content=image_xml,
+                    token=self.config["token"],
+                    image_type=2,
+                )
+
+                return platform_message.MessageChain([
+                    platform_message.Image(
+                        base64=f"data:image/{image_format};base64,{base64_str}"
+                    )
+                ])
+            except Exception as e:
+                print(f"处理图片消息失败: {str(e)}")
+                return platform_message.MessageChain([
+                    platform_message.Plain(text=f"[图片处理失败]")
+                ])
+        elif message["Data"]["MsgType"] == 34:
+            audio_base64 = message["Data"]["ImgBuf"]["buffer"]
+            return platform_message.MessageChain(
+                [platform_message.Voice(base64=f"data:audio/silk;base64,{audio_base64}")]
+            )
+        elif message["Data"]["MsgType"] == 49:
+            # 支持微信聊天记录的消息类型，将 XML 内容转换为 MessageChain 传递
+            try:
+                content = message["Data"]["Content"]["string"]
+
+                try:
+                    content_bytes = content.encode('utf-8')
+                    decoded_content = base64.b64decode(content_bytes)
+                    return platform_message.MessageChain(
+                        [platform_message.Unknown(content=decoded_content)]
+                    )
+                except Exception as e:
+                    return platform_message.MessageChain(
+                        [platform_message.Plain(text=content)]
+                    )
+            except Exception as e:
+                print(f"Error processing type 49 message: {str(e)}")
+                return platform_message.MessageChain(
+                    [platform_message.Plain(text="[无法解析的消息]")]
+                )
+
+class GewechatEventConverter(adapter.EventConverter):
+
+    def __init__(self, config: dict):
+        self.config = config
+        self.message_converter = GewechatMessageConverter(config)
+
+    @staticmethod
+    async def yiri2target(
+        event: platform_events.MessageEvent
+    ) -> dict:
+        pass
+
+    async def target2yiri(
+        self,
+        event: dict,
+        bot_account_id: str
+    ) -> platform_events.MessageEvent:
+        message_chain = await self.message_converter.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,
+            )
+        else:
+            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,
+            )
+
+
+class GeWeChatAdapter(adapter.MessagePlatformAdapter):
+
+    name: str = "gewechat"  # 定义适配器名称
+
+    bot: gewechat_client.GewechatClient
+    quart_app: quart.Quart
+
+    bot_account_id: str
+
+    config: dict
+
+    ap: app.Application
+
+    message_converter: GewechatMessageConverter
+    event_converter: GewechatEventConverter
+
+    listeners: typing.Dict[
+        typing.Type[platform_events.Event],
+        typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
+    ] = {}
+    
+    def __init__(self, config: dict, ap: app.Application):
+        self.config = config
+        self.ap = ap
+
+        self.quart_app = quart.Quart(__name__)
+
+        self.message_converter = GewechatMessageConverter(config)
+        self.event_converter = GewechatEventConverter(config)
+
+        @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
+    ):
+        geweap_msg = await GewechatMessageConverter.yiri2target(message)
+        # 此处加上群消息at处理
+        # ats = [item["target"] for item in geweap_msg if item["type"] == "at"]
+
+        for msg in geweap_msg:
+            if msg['type'] == 'text':
+                await self.bot.post_text(app_id=self.config['app_id'], to_wxid=target_id, content=msg['content'])
+
+            elif msg['type'] == 'image':
+
+                await self.bot.post_image(app_id=self.config['app_id'], to_wxid=target_id, img_url=msg["image"])
+
+
+
+    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.MessagePlatformAdapter], None]
+    ):
+        self.listeners[event_type] = callback
+
+    def unregister_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], 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('gewechat', 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/gewechat.yaml

@@ -0,0 +1,58 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: gewechat
+  label:
+    en_US: GeWeChat
+    zh_CN: GeWeChat（个人微信）
+  description:
+    en_US: GeWeChat Adapter
+    zh_CN: GeWeChat 适配器
+spec:
+  config:
+    - name: gewechat_url
+      label:
+        en_US: GeWeChat URL
+        zh_CN: GeWeChat URL
+      type: string
+      required: true
+      default: ""
+    - name: gewechat_file_url
+      label:
+        en_US: GeWeChat file download URL
+        zh_CN: GeWeChat 文件下载URL
+      type: string
+      required: true
+      default: ""
+    - name: port
+      label:
+        en_US: Port
+        zh_CN: 端口
+      type: int
+      required: true
+      default: 2286
+    - name: callback_url
+      label:
+        en_US: Callback URL
+        zh_CN: 回调URL
+      type: string
+      required: true
+      default: ""
+    - name: app_id
+      label:
+        en_US: App ID
+        zh_CN: 应用ID
+      type: string
+      required: true
+      default: ""
+    - name: token
+      label:
+        en_US: Token
+        zh_CN: 令牌
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./gewechat.py
+    attr: GeWeChatAdapter

pkg/platform/sources/lark.py

@@ -0,0 +1,492 @@
+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,
+            )
+
+
+class LarkAdapter(adapter.MessagePlatformAdapter):
+
+    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.MessagePlatformAdapter], 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.MessagePlatformAdapter], None
+        ],
+    ):
+        self.listeners[event_type] = callback
+
+    def unregister_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[
+            [platform_events.Event, adapter.MessagePlatformAdapter], 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/lark.yaml

@@ -0,0 +1,58 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: lark
+  label:
+    en_US: Lark
+    zh_CN: 飞书
+  description:
+    en_US: Lark Adapter
+    zh_CN: 飞书适配器
+spec:
+  config:
+    - name: app_id
+      label:
+        en_US: App ID
+        zh_CN: 应用ID
+      type: string
+      required: true
+      default: ""
+    - name: app_secret
+      label:
+        en_US: App Secret
+        zh_CN: 应用密钥
+      type: string
+      required: true
+      default: ""
+    - name: bot_name
+      label:
+        en_US: Bot Name
+        zh_CN: 机器人名称
+      type: string
+      required: true
+      default: ""
+    - name: enable-webhook
+      label:
+        en_US: Enable Webhook Mode
+        zh_CN: 启用Webhook模式
+      type: boolean
+      required: true
+      default: false
+    - name: port
+      label:
+        en_US: Webhook Port
+        zh_CN: Webhook端口
+      type: int
+      required: true
+      default: 2285
+    - name: encrypt-key
+      label:
+        en_US: Encrypt Key
+        zh_CN: 加密密钥
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./lark.py
+    attr: LarkAdapter

pkg/platform/sources/nakuru.py

@@ -158,8 +158,7 @@ class NakuruProjectEventConverter(adapter_model.EventConverter):
             raise Exception("未支持转换的事件类型: " + str(event))
 
 
-@adapter_model.adapter_class("nakuru")
-class NakuruProjectAdapter(adapter_model.MessageSourceAdapter):
+class NakuruAdapter(adapter_model.MessagePlatformAdapter):
     """nakuru-project适配器"""
     bot: nakuru.CQHTTP
     bot_account_id: int
@@ -256,7 +255,7 @@ class NakuruProjectAdapter(adapter_model.MessageSourceAdapter):
     def register_listener(
         self,
         event_type: typing.Type[platform_events.Event],
-        callback: typing.Callable[[platform_events.Event, adapter_model.MessageSourceAdapter], None]
+        callback: typing.Callable[[platform_events.Event, adapter_model.MessagePlatformAdapter], None]
     ):
         try:
 
@@ -284,7 +283,7 @@ class NakuruProjectAdapter(adapter_model.MessageSourceAdapter):
     def unregister_listener(
         self,
         event_type: typing.Type[platform_events.Event],
-        callback: typing.Callable[[platform_events.Event, adapter_model.MessageSourceAdapter], None]
+        callback: typing.Callable[[platform_events.Event, adapter_model.MessagePlatformAdapter], None]
     ):
         nakuru_event_name = self.event_converter.yiri2target(event_type).__name__
 

pkg/platform/sources/nakuru.yaml

@@ -0,0 +1,44 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: nakuru
+  label:
+    en_US: Nakuru
+    zh_CN: Nakuru
+  description:
+    en_US: Nakuru Adapter
+    zh_CN: Nakuru 适配器(go-cqhttp)
+spec:
+  config:
+    - name: host
+      label:
+        en_US: Host
+        zh_CN: 主机
+      type: string
+      required: true
+      default: "127.0.0.1"
+    - name: http_port
+      label:
+        en_US: HTTP Port
+        zh_CN: HTTP端口
+      type: int
+      required: true
+      default: 5700
+    - name: ws_port
+      label:
+        en_US: WebSocket Port
+        zh_CN: WebSocket端口
+      type: int
+      required: true
+      default: 8080
+    - name: token
+      label:
+        en_US: Token
+        zh_CN: 令牌
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./nakuru.py
+    attr: NakuruAdapter

pkg/platform/sources/officialaccount.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+import typing
+import asyncio
+import traceback
+import time
+import datetime
+from pkg.core import app
+from pkg.platform.adapter import MessagePlatformAdapter
+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 MessagePlatformAdapter
+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
+
+class OfficialAccountAdapter(adapter.MessagePlatformAdapter):
+
+    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, MessagePlatformAdapter], 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, MessagePlatformAdapter], None],
+    ):
+        return super().unregister_listener(event_type, callback)
+    
+    

pkg/platform/sources/officialaccount.yaml

@@ -0,0 +1,58 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: officialaccount
+  label:
+    en_US: Official Account
+    zh_CN: 微信公众号
+  description:
+    en_US: Official Account Adapter
+    zh_CN: 微信公众号适配器
+spec:
+  config:
+    - name: token
+      label:
+        en_US: Token
+        zh_CN: 令牌
+      type: string
+      required: true
+      default: ""
+    - name: EncodingAESKey
+      label:
+        en_US: EncodingAESKey
+        zh_CN: 消息加解密密钥
+      type: string
+      required: true
+      default: ""
+    - name: AppID
+      label:
+        en_US: App ID
+        zh_CN: 应用ID
+      type: string
+      required: true
+      default: ""
+    - name: AppSecret
+      label:
+        en_US: App Secret
+        zh_CN: 应用密钥
+      type: string
+      required: true
+      default: ""
+    - name: host
+      label:
+        en_US: Host
+        zh_CN: 监听主机
+      type: string
+      required: true
+      default: 0.0.0.0
+    - name: port
+      label:
+        en_US: Port
+        zh_CN: 监听端口
+      type: int
+      required: true
+      default: 2287
+execution:
+  python:
+    path: ./officialaccount.py
+    attr: OfficialAccountAdapter

pkg/platform/sources/qqbotpy.py

@@ -360,8 +360,7 @@ class OfficialEventConverter(adapter_model.EventConverter):
             )
 
 
-@adapter_model.adapter_class("qq-botpy")
-class OfficialAdapter(adapter_model.MessageSourceAdapter):
+class OfficialAdapter(adapter_model.MessagePlatformAdapter):
     """QQ 官方消息适配器"""
 
     bot: botpy.Client = None
@@ -535,7 +534,7 @@ class OfficialAdapter(adapter_model.MessageSourceAdapter):
         self,
         event_type: typing.Type[platform_events.Event],
         callback: typing.Callable[
-            [platform_events.Event, adapter_model.MessageSourceAdapter], None
+            [platform_events.Event, adapter_model.MessagePlatformAdapter], None
         ],
     ):
 
@@ -561,7 +560,7 @@ class OfficialAdapter(adapter_model.MessageSourceAdapter):
         self,
         event_type: typing.Type[platform_events.Event],
         callback: typing.Callable[
-            [platform_events.Event, adapter_model.MessageSourceAdapter], None
+            [platform_events.Event, adapter_model.MessagePlatformAdapter], None
         ],
     ):
         delattr(self.bot, event_handler_mapping[event_type])

pkg/platform/sources/qqbotpy.yaml

@@ -0,0 +1,37 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: qq-botpy
+  label:
+    en_US: QQBotPy
+    zh_CN: QQBotPy
+  description:
+    en_US: QQ Official API (WebSocket)
+    zh_CN: QQ 官方 API (WebSocket)
+spec:
+  config:
+    - name: appid
+      label:
+        en_US: App ID
+        zh_CN: 应用ID
+      type: string
+      required: true
+      default: ""
+    - name: secret
+      label:
+        en_US: Secret
+        zh_CN: 密钥
+      type: string
+      required: true
+      default: ""
+    - name: intents
+      label:
+        en_US: Intents
+        zh_CN: 权限
+      type: array[string]
+      required: true
+      default: []
+execution:
+  python:
+    path: ./qqbotpy.py
+    attr: OfficialAdapter

pkg/platform/sources/qqofficial.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+import typing
+import asyncio
+import traceback
+import time
+import datetime
+import aiocqhttp
+import aiohttp
+from pkg.platform.adapter import MessagePlatformAdapter
+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
+            )
+
+
+class QQOfficialAdapter(adapter.MessagePlatformAdapter):
+    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.MessagePlatformAdapter], 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, MessagePlatformAdapter], None],
+    ):
+        return super().unregister_listener(event_type, callback)
+

pkg/platform/sources/qqofficial.yaml

@@ -0,0 +1,44 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: qqofficial
+  label:
+    en_US: QQ Official API
+    zh_CN: QQ 官方 API
+  description:
+    en_US: QQ Official API (Webhook)
+    zh_CN: QQ 官方 API (Webhook)
+spec:
+  config:
+    - name: appid
+      label:
+        en_US: App ID
+        zh_CN: 应用ID
+      type: string
+      required: true
+      default: ""
+    - name: secret
+      label:
+        en_US: Secret
+        zh_CN: 密钥
+      type: string
+      required: true
+      default: ""
+    - name: port
+      label:
+        en_US: Port
+        zh_CN: 监听端口
+      type: int
+      required: true
+      default: 2284
+    - name: token
+      label:
+        en_US: Token
+        zh_CN: 令牌
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./qqofficial.py
+    attr: QQOfficialAdapter

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
+            )
+    
+
+class TelegramAdapter(adapter.MessagePlatformAdapter):
+    
+    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.MessagePlatformAdapter], 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.MessagePlatformAdapter], None],
+    ):
+        self.listeners[event_type] = callback
+    
+    def unregister_listener(
+        self,
+        event_type: typing.Type[platform_events.Event],
+        callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], 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/telegram.yaml

@@ -0,0 +1,23 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: telegram
+  label:
+    en_US: Telegram
+    zh_CN: 电报
+  description:
+    en_US: Telegram Adapter
+    zh_CN: 电报适配器
+spec:
+  config:
+    - name: token
+      label:
+        en_US: Token
+        zh_CN: 令牌
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./telegram.py
+    attr: TelegramAdapter

pkg/platform/sources/wecom.py

@@ -8,7 +8,7 @@ import datetime
 import aiocqhttp
 import aiohttp
 from libs.wecom_api.api import WecomClient
-from pkg.platform.adapter import MessageSourceAdapter
+from pkg.platform.adapter import MessagePlatformAdapter
 from pkg.platform.types import events as platform_events, message as platform_message
 from libs.wecom_api.wecomevent import WecomEvent
 from pkg.core import app
@@ -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="",
             )
@@ -156,8 +144,7 @@ class WecomEventConverter:
             )
 
 
-@adapter.adapter_class("wecom")
-class WecomeAdapter(adapter.MessageSourceAdapter):
+class WecomAdapter(adapter.MessagePlatformAdapter):
 
     bot: WecomClient
     ap: app.Application
@@ -165,7 +152,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 +188,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
     ):
@@ -218,7 +206,7 @@ class WecomeAdapter(adapter.MessageSourceAdapter):
         self,
         event_type: typing.Type[platform_events.Event],
         callback: typing.Callable[
-            [platform_events.Event, adapter.MessageSourceAdapter], None
+            [platform_events.Event, adapter.MessagePlatformAdapter], None
         ],
     ):
         async def on_message(event: WecomEvent):
@@ -253,6 +241,6 @@ class WecomeAdapter(adapter.MessageSourceAdapter):
     async def unregister_listener(
         self,
         event_type: type,
-        callback: typing.Callable[[platform_events.Event, MessageSourceAdapter], None],
+        callback: typing.Callable[[platform_events.Event, MessagePlatformAdapter], None],
     ):
         return super().unregister_listener(event_type, callback)

pkg/platform/sources/wecom.yaml

@@ -0,0 +1,65 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: wecom
+  label:
+    en_US: WeCom
+    zh_CN: 企业微信
+  description:
+    en_US: WeCom Adapter
+    zh_CN: 企业微信适配器
+spec:
+  config:
+    - name: host
+      label:
+        en_US: Host
+        zh_CN: 监听主机
+      type: string
+      required: true
+      default: "0.0.0.0"
+    - name: port
+      label:
+        en_US: Port
+        zh_CN: 监听端口
+      type: int
+      required: true
+      default: 2290
+    - name: corpid
+      label:
+        en_US: Corpid
+        zh_CN: 企业ID
+      type: string
+      required: true
+      default: ""
+    - name: secret
+      label:
+        en_US: Secret
+        zh_CN: 密钥
+      type: string
+      required: true
+      default: ""
+    - name: token
+      label:
+        en_US: Token
+        zh_CN: 令牌
+      type: string
+      required: true
+      default: ""
+    - name: EncodingAESKey
+      label:
+        en_US: EncodingAESKey
+        zh_CN: 消息加解密密钥
+      type: string
+      required: true
+      default: ""
+    - name: contacts_secret
+      label:
+        en_US: Contacts Secret
+        zh_CN: 通讯录密钥
+      type: string
+      required: true
+      default: ""
+execution:
+  python:
+    path: ./wecom.py
+    attr: WecomAdapter

pkg/platform/types/entities.py

@@ -13,31 +13,25 @@ import pydantic.v1 as pydantic
 class Entity(pydantic.BaseModel):
     """实体，表示一个用户或群。"""
     id: int
-    """QQ 号或群号。"""
-    @abc.abstractmethod
-    def get_avatar_url(self) -> str:
-        """头像图片链接。"""
-
+    """ID。"""
     @abc.abstractmethod
     def get_name(self) -> str:
         """名称。"""
 
 
 class Friend(Entity):
-    """好友。"""
+    """私聊对象。"""
     id: typing.Union[int, str]
-    """QQ 号。"""
+    """ID。"""
     nickname: typing.Optional[str]
     """昵称。"""
     remark: typing.Optional[str]
     """备注。"""
-    def get_avatar_url(self) -> str:
-        return f'http://q4.qlogo.cn/g?b=qq&nk={self.id}&s=140'
-
     def get_name(self) -> str:
         return self.nickname or self.remark or ''
 
 
+
 class Permission(str, Enum):
     """群成员身份权限。"""
     Member = "MEMBER"
@@ -58,8 +52,6 @@ class Group(Entity):
     """群名称。"""
     permission: Permission
     """Bot 在群中的权限。"""
-    def get_avatar_url(self) -> str:
-        return f'https://p.qlogo.cn/gh/{self.id}/{self.id}/'
 
     def get_name(self) -> str:
         return self.name
@@ -68,11 +60,11 @@ class Group(Entity):
 class GroupMember(Entity):
     """群成员。"""
     id: typing.Union[int, str]
-    """QQ 号。"""
+    """群员 ID。"""
     member_name: str
-    """群成员名称。"""
+    """群员名称。"""
     permission: Permission
-    """Bot 在群中的权限。"""
+    """在群中的权限。"""
     group: Group
     """群。"""
     special_title: str = ''
@@ -83,61 +75,6 @@ class GroupMember(Entity):
     """最后一次发言的时间。"""
     mute_time_remaining: int = 0
     """禁言剩余时间。"""
-    def get_avatar_url(self) -> str:
-        return f'http://q4.qlogo.cn/g?b=qq&nk={self.id}&s=140'
 
     def get_name(self) -> str:
         return self.member_name
-
-
-class Client(Entity):
-    """来自其他客户端的用户。"""
-    id: typing.Union[int, str]
-    """识别 id。"""
-    platform: str
-    """来源平台。"""
-    def get_avatar_url(self) -> str:
-        raise NotImplementedError
-
-    def get_name(self) -> str:
-        return self.platform
-
-
-class Subject(pydantic.BaseModel):
-    """另一种实体类型表示。"""
-    id: typing.Union[int, str]
-    """QQ 号或群号。"""
-    kind: typing.Literal['Friend', 'Group', 'Stranger']
-    """类型。"""
-
-
-class Config(pydantic.BaseModel):
-    """配置项类型。"""
-    def modify(self, **kwargs) -> 'Config':
-        """修改部分设置。"""
-        for k, v in kwargs.items():
-            if k in self.__fields__:
-                setattr(self, k, v)
-            else:
-                raise ValueError(f'未知配置项: {k}')
-        return self
-
-
-class GroupConfigModel(Config):
-    """群配置。"""
-    name: str
-    """群名称。"""
-    confess_talk: bool
-    """是否允许坦白说。"""
-    allow_member_invite: bool
-    """是否允许成员邀请好友入群。"""
-    auto_approve: bool
-    """是否开启自动审批入群。"""
-    anonymous_chat: bool
-    """是否开启匿名聊天。"""
-    announcement: str = ''
-    """群公告。"""
-
-
-class MemberInfoModel(Config, GroupMember):
-    """群成员信息。"""

pkg/platform/types/events.py

@@ -43,21 +43,6 @@ class Event(pydantic.BaseModel):
             return Event
 
 
-###############################
-# Bot Event
-class BotEvent(Event):
-    """Bot 自身事件。
-
-    Args:
-        type: 事件名。
-        qq: Bot 的 QQ 号。
-    """
-    type: str
-    """事件名。"""
-    qq: int
-    """Bot 的 QQ 号。"""
-
-
 ###############################
 # Message Event
 class MessageEvent(Event):
@@ -72,9 +57,14 @@ class MessageEvent(Event):
     message_chain: platform_message.MessageChain
     """消息内容。"""
 
+    source_platform_object: typing.Optional[typing.Any] = None
+    """原消息平台对象。
+    供消息平台适配器开发者使用，如果回复用户时需要使用原消息事件对象的信息，
+    那么可以将其存到这个字段以供之后取出使用。"""
+
 
 class FriendMessage(MessageEvent):
-    """好友消息。
+    """私聊消息。
 
     Args:
         type: 事件名。
@@ -106,19 +96,3 @@ class GroupMessage(MessageEvent):
     @property
     def group(self) -> platform_entities.Group:
         return self.sender.group
-
-
-class StrangerMessage(MessageEvent):
-    """陌生人消息。
-
-    Args:
-        type: 事件名。
-        sender: 发送消息的人。
-        message_chain: 消息内容。
-    """
-    type: str = 'StrangerMessage'
-    """事件名。"""
-    sender: platform_entities.Friend
-    """发送消息的人。"""
-    message_chain: platform_message.MessageChain
-    """消息内容。"""

pkg/platform/types/message.py

@@ -116,18 +116,6 @@ class MessageChain(PlatformBaseModel):
         print('At Me')
     ```
 
-    消息链对索引操作进行了增强。以消息组件类型为索引，获取消息链中的全部该类型的消息组件。
-    ```py
-    plain_list = message_chain[Plain]
-    '[Plain("Hello World!")]'
-    ```
-
-    可以用加号连接两个消息链。
-    ```py
-    MessageChain(['Hello World!']) + MessageChain(['Goodbye World!'])
-    # 返回 MessageChain([Plain("Hello World!"), Plain("Goodbye World!")])
-    ```
-
     """
     __root__: typing.List[MessageComponent]
 
@@ -460,7 +448,7 @@ class Source(MessageComponent):
     """源。包含消息的基本信息。"""
     type: str = "Source"
     """消息组件类型。"""
-    id: int
+    id: typing.Union[int, str]
     """消息的识别号，用于引用回复（Source 类型永远为 MessageChain 的第一个元素）。"""
     time: datetime
     """消息时间。"""
@@ -488,9 +476,9 @@ class Quote(MessageComponent):
     group_id: typing.Optional[typing.Union[int, str]] = None
     """被引用回复的原消息所接收的群号，当为好友消息时为0。"""
     sender_id: typing.Optional[typing.Union[int, str]] = None
-    """被引用回复的原消息的发送者的QQ号。"""
+    """被引用回复的原消息的发送者的ID。"""
     target_id: typing.Optional[typing.Union[int, str]] = None
-    """被引用回复的原消息的接收者者的QQ号（或群号）。"""
+    """被引用回复的原消息的接收者者的ID或群ID。"""
     origin: MessageChain
     """被引用回复的原消息的消息链对象。"""
 
@@ -503,8 +491,8 @@ class At(MessageComponent):
     """At某人。"""
     type: str = "At"
     """消息组件类型。"""
-    target: int
-    """群员 QQ 号。"""
+    target: typing.Union[int, str]
+    """群员 ID。"""
     display: typing.Optional[str] = None
     """At时显示的文字，发送消息时无效，自动使用群名片。"""
     def __eq__(self, other):
@@ -527,9 +515,9 @@ class Image(MessageComponent):
     type: str = "Image"
     """消息组件类型。"""
     image_id: typing.Optional[str] = None
-    """图片的 image_id，群图片与好友图片格式不同。不为空时将忽略 url 属性。"""
+    """图片的 image_id，不为空时将忽略 url 属性。"""
     url: typing.Optional[pydantic.HttpUrl] = None
-    """图片的 URL，发送时可作网络图片的链接；接收时为腾讯图片服务器的链接，可用于图片下载。"""
+    """图片的 URL，发送时可作网络图片的链接；接收时为图片的链接，可用于图片下载。"""
     path: typing.Union[str, Path, None] = None
     """图片的路径，发送本地图片。"""
     base64: typing.Optional[str] = None
@@ -663,7 +651,7 @@ class Voice(MessageComponent):
     voice_id: typing.Optional[str] = None
     """语音的 voice_id，不为空时将忽略 url 属性。"""
     url: typing.Optional[str] = None
-    """语音的 URL，发送时可作网络语音的链接；接收时为腾讯语音服务器的链接，可用于语音下载。"""
+    """语音的 URL，发送时可作网络语音的链接；接收时为语音文件的链接，可用于语音下载。"""
     path: typing.Optional[str] = None
     """语音的路径，发送本地语音。"""
     base64: typing.Optional[str] = None
@@ -691,8 +679,6 @@ class Voice(MessageComponent):
     ):
         """下载语音到本地。
 
-        语音采用 silk v3 格式，silk 格式的编码解码请使用 [graiax-silkcoder](https://pypi.org/project/graiax-silkcoder/)。
-
         Args:
             filename: 下载到本地的文件路径。与 `directory` 二选一。
             directory: 下载到本地的文件夹路径。与 `filename` 二选一。
@@ -750,13 +736,13 @@ class Voice(MessageComponent):
 class ForwardMessageNode(pydantic.BaseModel):
     """合并转发中的一条消息。"""
     sender_id: typing.Optional[typing.Union[int, str]] = None
-    """发送人QQ号。"""
+    """发送人ID。"""
     sender_name: typing.Optional[str] = None
     """显示名称。"""
     message_chain: typing.Optional[MessageChain] = None
     """消息内容。"""
     message_id: typing.Optional[int] = None
-    """消息的 message_id，可以只使用此属性，从缓存中读取消息内容。"""
+    """消息的 message_id。"""
     time: typing.Optional[datetime] = None
     """发送时间。"""
     @pydantic.validator('message_chain', check_fields=False)
@@ -785,10 +771,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/plugin/context.py

@@ -116,7 +116,7 @@ class APIHost:
 
     # ========== 插件可调用的 API（主程序API） ==========
 
-    def get_platform_adapters(self) -> list[platform_adapter.MessageSourceAdapter]:
+    def get_platform_adapters(self) -> list[platform_adapter.MessagePlatformAdapter]:
         """获取已启用的消息平台适配器列表
         
         Returns:
@@ -126,7 +126,7 @@ class APIHost:
     
     async def send_active_message(
         self,
-        adapter: platform_adapter.MessageSourceAdapter,
+        adapter: platform_adapter.MessagePlatformAdapter,
         target_type: str,
         target_id: str,
         message: platform_message.MessageChain,

pkg/provider/modelmgr/modelmgr.py

@@ -4,9 +4,9 @@ import aiohttp
 
 from . import entities, requester
 from ...core import app
-
+from ...discover import engine
 from . import token
-from .requesters import chatcmpl, anthropicmsgs, moonshotchatcmpl, deepseekchatcmpl, ollamachat, giteeaichatcmpl, xaichatcmpl, zhipuaichatcmpl
+from .requesters import bailianchatcmpl, chatcmpl, anthropicmsgs, moonshotchatcmpl, deepseekchatcmpl, ollamachat, giteeaichatcmpl, volcarkchatcmpl, xaichatcmpl, zhipuaichatcmpl, lmstudiochatcmpl, siliconflowchatcmpl, volcarkchatcmpl
 
 FETCH_MODEL_LIST_URL = "https://api.qchatgpt.rockchin.top/api/v2/fetch/model_list"
 
@@ -16,6 +16,8 @@ class ModelManager:
 
     ap: app.Application
 
+    requester_components: list[engine.Component]
+
     model_list: list[entities.LLMModelInfo]
 
     requesters: dict[str, requester.LLMAPIRequester]
@@ -38,14 +40,21 @@ class ModelManager:
     
     async def initialize(self):
 
+        self.requester_components = self.ap.discover.get_components_by_kind('LLMAPIRequester')
+
         # 初始化token_mgr, requester
         for k, v in self.ap.provider_cfg.data['keys'].items():
             self.token_mgrs[k] = token.TokenManager(k, v)
 
-        for api_cls in requester.preregistered_requesters:
+        # for api_cls in requester.preregistered_requesters:
+        #     api_inst = api_cls(self.ap)
+        #     await api_inst.initialize()
+        #     self.requesters[api_inst.name] = api_inst
+        for component in self.requester_components:
+            api_cls = component.get_python_component_class()
             api_inst = api_cls(self.ap)
             await api_inst.initialize()
-            self.requesters[api_inst.name] = api_inst
+            self.requesters[component.metadata.name] = api_inst
 
         # 尝试从api获取最新的模型信息
         try:
@@ -109,4 +118,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/requester.py

@@ -10,18 +10,6 @@ from . import entities as modelmgr_entities
 from ..tools import entities as tools_entities
 
 
-preregistered_requesters: list[typing.Type[LLMAPIRequester]] = []
-
-def requester_class(name: str):
-
-    def decorator(cls: typing.Type[LLMAPIRequester]) -> typing.Type[LLMAPIRequester]:
-        cls.name = name
-        preregistered_requesters.append(cls)
-        return cls
-
-    return decorator
-
-
 class LLMAPIRequester(metaclass=abc.ABCMeta):
     """LLM API请求器
     """

pkg/provider/modelmgr/requester.yaml

@@ -0,0 +1,14 @@
+apiVersion: v1
+kind: ComponentTemplate
+metadata:
+  name: LLMAPIRequester
+  label:
+    en_US: LLM API Requester
+    zh_CN: LLM API 请求器
+spec:
+  type:
+    - python
+execution:
+  python:
+    path: ./requester.py
+    attr: LLMAPIRequester

pkg/provider/modelmgr/requesters/anthropicmsgs.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import typing
+import json
 import traceback
 import base64
 
@@ -16,7 +17,6 @@ from ...tools import entities as tools_entities
 from ....utils import image
 
 
-@requester.requester_class("anthropic-messages")
 class AnthropicMessages(requester.LLMAPIRequester):
     """Anthropic Messages API 请求器"""
 
@@ -69,11 +69,32 @@ class AnthropicMessages(requester.LLMAPIRequester):
         req_messages = []
 
         for m in messages:
-            if isinstance(m.content, str) and m.content.strip() != "":
-                req_messages.append(m.dict(exclude_none=True))
-            elif isinstance(m.content, list):
+            if m.role == 'tool':
+                tool_call_id = m.tool_call_id
 
-                msg_dict = m.dict(exclude_none=True)
+                req_messages.append({
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": tool_call_id,
+                            "content": m.content
+                        }
+                    ]
+                })
+
+                continue
+
+            msg_dict = m.dict(exclude_none=True)
+
+            if isinstance(m.content, str) and m.content.strip() != "":
+                msg_dict["content"] = [
+                    {
+                        "type": "text",
+                        "text": m.content
+                    }
+                ]
+            elif isinstance(m.content, list):
 
                 for i, ce in enumerate(m.content):
 
@@ -90,25 +111,60 @@ class AnthropicMessages(requester.LLMAPIRequester):
                         }
                         msg_dict["content"][i] = alter_image_ele
 
-                req_messages.append(msg_dict)
+            if m.tool_calls:
+
+                for tool_call in m.tool_calls:
+                    msg_dict["content"].append({
+                        "type": "tool_use",
+                        "id": tool_call.id,
+                        "name": tool_call.function.name,
+                        "input": json.loads(tool_call.function.arguments)
+                    })
+
+                del msg_dict["tool_calls"]
+
+            req_messages.append(msg_dict)
+                
 
         args["messages"] = req_messages
+        
+        if funcs:
+            tools = await self.ap.tool_mgr.generate_tools_for_anthropic(funcs)
 
-        # anthropic的tools处在beta阶段，sdk不稳定，故暂时不支持
-        #
-        # if funcs:
-        #     tools = await self.ap.tool_mgr.generate_tools_for_openai(funcs)
-
-        #     if tools:
-        #         args["tools"] = tools
+            if tools:
+                args["tools"] = tools
 
         try:
+            # print(json.dumps(args, indent=4, ensure_ascii=False))
             resp = await self.client.messages.create(**args)
 
-            return llm_entities.Message(
-                content=resp.content[0].text,
-                role=resp.role
-            )
+            args = {
+                'content': '',
+                'role': resp.role,
+            }
+            
+            assert type(resp) is anthropic.types.message.Message
+
+            for block in resp.content:
+                if block.type == 'thinking':
+                    args['content'] = '<think>' + block.thinking + '</think>\n' + args['content']
+                elif block.type == 'text':
+                    args['content'] += block.text
+                elif block.type == 'tool_use':
+                    assert type(block) is anthropic.types.tool_use_block.ToolUseBlock
+                    tool_call = llm_entities.ToolCall(
+                        id=block.id,
+                        type="function",
+                        function=llm_entities.FunctionCall(
+                            name=block.name,
+                            arguments=json.dumps(block.input)
+                        )
+                    )
+                    if 'tool_calls' not in args:
+                        args['tool_calls'] = []
+                    args['tool_calls'].append(tool_call)
+
+            return llm_entities.Message(**args)
         except anthropic.AuthenticationError as e:
             raise errors.RequesterError(f'api-key 无效: {e.message}')
         except anthropic.BadRequestError as e:

pkg/provider/modelmgr/requesters/anthropicmsgs.yaml

@@ -0,0 +1,34 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: anthropic-messages
+  label:
+    en_US: Anthropic
+    zh_CN: Anthropic
+spec:
+  config:
+    - name: base-url
+      label:
+        en_US: Base URL
+        zh_CN: 基础 URL
+      type: string
+      required: true
+      default: "https://api.anthropic.com/v1"
+    - name: args
+      label:
+        en_US: Args
+        zh_CN: 附加参数
+      type: object
+      required: true
+      default: {}
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_CN: 超时时间
+      type: int
+      required: true
+      default: 120
+execution:
+  python:
+    path: ./anthropicmsgs.py
+    attr: AnthropicMessages

pkg/provider/modelmgr/requesters/bailianchatcmpl.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import openai
+
+from . import chatcmpl
+from .. import requester
+from ....core import app
+
+
+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/bailianchatcmpl.yaml

@@ -0,0 +1,34 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: bailian-chat-completions
+  label:
+    en_US: Aliyun Bailian
+    zh_CN: 阿里云百炼
+spec:
+  config:
+    - name: base-url
+      label:
+        en_US: Base URL
+        zh_CN: 基础 URL
+      type: string
+      required: true
+      default: "https://dashscope.aliyuncs.com/compatible-mode/v1"
+    - name: args
+      label:
+        en_US: Args
+        zh_CN: 附加参数
+      type: object
+      required: true
+      default: {}
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_CN: 超时时间
+      type: int
+      required: true
+      default: 120
+execution:
+  python:
+    path: ./bailianchatcmpl.py
+    attr: BailianChatCompletions

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
@@ -19,7 +20,6 @@ from ...tools import entities as tools_entities
 from ....utils import image
 
 
-@requester.requester_class("openai-chat-completions")
 class OpenAIChatCompletions(requester.LLMAPIRequester):
     """OpenAI ChatCompletion API 请求器"""
 
@@ -40,6 +40,7 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
             timeout=self.requester_cfg['timeout'],
             http_client=httpx.AsyncClient(
                 trust_env=True,
+                timeout=self.requester_cfg['timeout']
             )
         )
 

pkg/provider/modelmgr/requesters/chatcmpl.yaml

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

pkg/provider/modelmgr/requesters/deepseekchatcmpl.py

@@ -7,7 +7,6 @@ from ... import entities as llm_entities
 from ...tools import entities as tools_entities
 
 
-@requester.requester_class("deepseek-chat-completions")
 class DeepseekChatCompletions(chatcmpl.OpenAIChatCompletions):
     """Deepseek ChatCompletion API 请求器"""
 
@@ -46,6 +45,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/deepseekchatcmpl.yaml

@@ -0,0 +1,34 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: deepseek-chat-completions
+  label:
+    en_US: DeepSeek
+    zh_CN: 深度求索
+spec:
+  config:
+    - name: base-url
+      label:
+        en_US: Base URL
+        zh_CN: 基础 URL
+      type: string
+      required: true
+      default: "https://api.deepseek.com"
+    - name: args
+      label:
+        en_US: Args
+        zh_CN: 附加参数
+      type: object
+      required: true
+      default: {}
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_CN: 超时时间
+      type: int
+      required: true
+      default: 120
+execution:
+  python:
+    path: ./deepseekchatcmpl.py
+    attr: DeepseekChatCompletions

pkg/provider/modelmgr/requesters/giteeaichatcmpl.py

@@ -14,7 +14,6 @@ from ...tools import entities as tools_entities
 from .. import entities as modelmgr_entities
 
 
-@requester.requester_class("gitee-ai-chat-completions")
 class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
     """Gitee AI ChatCompletions API 请求器"""
 

pkg/provider/modelmgr/requesters/giteeaichatcmpl.yaml

@@ -0,0 +1,34 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: gitee-ai-chat-completions
+  label:
+    en_US: Gitee AI
+    zh_CN: Gitee AI
+spec:
+  config:
+    - name: base-url
+      label:
+        en_US: Base URL
+        zh_CN: 基础 URL
+      type: string
+      required: true
+      default: "https://ai.gitee.com/v1"
+    - name: args
+      label:
+        en_US: Args
+        zh_CN: 附加参数
+      type: object
+      required: true
+      default: {}
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_CN: 超时时间
+      type: int
+      required: true
+      default: 120
+execution:
+  python:
+    path: ./giteeaichatcmpl.py
+    attr: GiteeAIChatCompletions

pkg/provider/modelmgr/requesters/lmstudiochatcmpl.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import openai
+
+from . import chatcmpl
+from .. import requester
+from ....core import app
+
+
+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/lmstudiochatcmpl.yaml

@@ -0,0 +1,34 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: lmstudio-chat-completions
+  label:
+    en_US: LM Studio
+    zh_CN: LM Studio
+spec:
+  config:
+    - name: base-url
+      label:
+        en_US: Base URL
+        zh_CN: 基础 URL
+      type: string
+      required: true
+      default: "http://127.0.0.1:1234/v1"
+    - name: args
+      label:
+        en_US: Args
+        zh_CN: 附加参数
+      type: object
+      required: true
+      default: {}
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_CN: 超时时间
+      type: int
+      required: true
+      default: 120
+execution:
+  python:
+    path: ./lmstudiochatcmpl.py
+    attr: LmStudioChatCompletions

pkg/provider/modelmgr/requesters/moonshotchatcmpl.py

@@ -9,7 +9,6 @@ from ... import entities as llm_entities
 from ...tools import entities as tools_entities
 
 
-@requester.requester_class("moonshot-chat-completions")
 class MoonshotChatCompletions(chatcmpl.OpenAIChatCompletions):
     """Moonshot ChatCompletion API 请求器"""
 

pkg/provider/modelmgr/requesters/moonshotchatcmpl.yaml

@@ -0,0 +1,34 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: moonshot-chat-completions
+  label:
+    en_US: Moonshot
+    zh_CN: 月之暗面
+spec:
+  config:
+    - name: base-url
+      label:
+        en_US: Base URL
+        zh_CN: 基础 URL
+      type: string
+      required: true
+      default: "https://api.moonshot.com/v1"
+    - name: args
+      label:
+        en_US: Args
+        zh_CN: 附加参数
+      type: object
+      required: true
+      default: {}
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_CN: 超时时间
+      type: int
+      required: true
+      default: 120
+execution:
+  python:
+    path: ./moonshotchatcmpl.py
+    attr: MoonshotChatCompletions

pkg/provider/modelmgr/requesters/ollamachat.py

@@ -20,7 +20,6 @@ from ....utils import image
 REQUESTER_NAME: str = "ollama-chat"
 
 
-@requester.requester_class(REQUESTER_NAME)
 class OllamaChatCompletions(requester.LLMAPIRequester):
     """Ollama平台 ChatCompletion API请求器"""
     client: ollama.AsyncClient

pkg/provider/modelmgr/requesters/ollamachat.yaml

@@ -0,0 +1,34 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: ollama-chat
+  label:
+    en_US: Ollama
+    zh_CN: Ollama
+spec:
+  config:
+    - name: base-url
+      label:
+        en_US: Base URL
+        zh_CN: 基础 URL
+      type: string
+      required: true
+      default: "http://127.0.0.1:11434"
+    - name: args
+      label:
+        en_US: Args
+        zh_CN: 附加参数
+      type: object
+      required: true
+      default: {}
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_CN: 超时时间
+      type: int
+      required: true
+      default: 120
+execution:
+  python:
+    path: ./ollamachat.py
+    attr: OllamaChatCompletions

pkg/provider/modelmgr/requesters/siliconflowchatcmpl.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import openai
+
+from . import chatcmpl
+from .. import requester
+from ....core import app
+
+
+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/modelmgr/requesters/siliconflowchatcmpl.yaml

@@ -0,0 +1,34 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: siliconflow-chat-completions
+  label:
+    en_US: SiliconFlow
+    zh_CN: 硅基流动
+spec:
+  config:
+    - name: base-url
+      label:
+        en_US: Base URL
+        zh_CN: 基础 URL
+      type: string
+      required: true
+      default: "https://api.siliconflow.cn/v1"
+    - name: args
+      label:
+        en_US: Args
+        zh_CN: 附加参数
+      type: object
+      required: true
+      default: {}
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_CN: 超时时间
+      type: int
+      required: true
+      default: 120
+execution:
+  python:
+    path: ./siliconflowchatcmpl.py
+    attr: SiliconFlowChatCompletions

pkg/provider/modelmgr/requesters/volcarkchatcmpl.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import openai
+
+from . import chatcmpl
+from .. import requester
+from ....core import app
+
+
+class VolcArkChatCompletions(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']['volcark-chat-completions']

pkg/provider/modelmgr/requesters/volcarkchatcmpl.yaml

@@ -0,0 +1,34 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: volcark-chat-completions
+  label:
+    en_US: Volc Engine Ark
+    zh_CN: 火山方舟
+spec:
+  config:
+    - name: base-url
+      label:
+        en_US: Base URL
+        zh_CN: 基础 URL
+      type: string
+      required: true
+      default: "https://ark.cn-beijing.volces.com/api/v3"
+    - name: args
+      label:
+        en_US: Args
+        zh_CN: 附加参数
+      type: object
+      required: true
+      default: {}
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_CN: 超时时间
+      type: int
+      required: true
+      default: 120
+execution:
+  python:
+    path: ./volcarkchatcmpl.py
+    attr: VolcArkChatCompletions

pkg/provider/modelmgr/requesters/xaichatcmpl.py

@@ -7,7 +7,6 @@ from .. import requester
 from ....core import app
 
 
-@requester.requester_class("xai-chat-completions")
 class XaiChatCompletions(chatcmpl.OpenAIChatCompletions):
     """xAI ChatCompletion API 请求器"""
 

pkg/provider/modelmgr/requesters/xaichatcmpl.yaml

@@ -0,0 +1,34 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: xai-chat-completions
+  label:
+    en_US: xAI
+    zh_CN: xAI
+spec:
+  config:
+    - name: base-url
+      label:
+        en_US: Base URL
+        zh_CN: 基础 URL
+      type: string
+      required: true
+      default: "https://api.x.ai/v1"
+    - name: args
+      label:
+        en_US: Args
+        zh_CN: 附加参数
+      type: object
+      required: true
+      default: {}
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_CN: 超时时间
+      type: int
+      required: true
+      default: 120
+execution:
+  python:
+    path: ./xaichatcmpl.py
+    attr: XaiChatCompletions

pkg/provider/modelmgr/requesters/zhipuaichatcmpl.py

@@ -7,7 +7,6 @@ from . import chatcmpl
 from .. import requester
 
 
-@requester.requester_class("zhipuai-chat-completions")
 class ZhipuAIChatCompletions(chatcmpl.OpenAIChatCompletions):
     """智谱AI ChatCompletion API 请求器"""
 

pkg/provider/modelmgr/requesters/zhipuaichatcmpl.yaml

@@ -0,0 +1,34 @@
+apiVersion: v1
+kind: LLMAPIRequester
+metadata:
+  name: zhipuai-chat-completions
+  label:
+    en_US: ZhipuAI
+    zh_CN: 智谱 AI
+spec:
+  config:
+    - name: base-url
+      label:
+        en_US: Base URL
+        zh_CN: 基础 URL
+      type: string
+      required: true
+      default: "https://open.bigmodel.cn/api/paas/v4"
+    - name: args
+      label:
+        en_US: Args
+        zh_CN: 附加参数
+      type: object
+      required: true
+      default: {}
+    - name: timeout
+      label:
+        en_US: Timeout
+        zh_CN: 超时时间
+      type: int
+      required: true
+      default: 120
+execution:
+  python:
+    path: ./zhipuaichatcmpl.py
+    attr: ZhipuAIChatCompletions