Merge pull request #1268 from RockChinQ/version/3.4.12

chore: release v3.4.12

.gitignore

@@ -19,7 +19,7 @@ cookies.json
 data/labels/announcement_saved.json
 cmdpriv.json
 tips.py
-.venv
+venv*
 bin/
 .vscode
 test_*
@@ -29,6 +29,7 @@ qcapi
 claude.json
 bard.json
 /*yaml
+!components.yaml
 !/docker-compose.yaml
 data/labels/instance_id.json
 .DS_Store
@@ -38,3 +39,4 @@ botpy.log*
 /libs/wecom_api/test.py
 /venv
 /jp-tyo-churros-05.rockchin.top
+test.py

README.md

@@ -6,10 +6,10 @@
 
 <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> ｜
+<a href="https://docs.langbot.app/insight/intro.html">功能介绍</a> ｜
 <a href="https://docs.langbot.app/insight/guide.html">部署文档</a> ｜
 <a href="https://docs.langbot.app/usage/faq.html">常见问题</a> ｜
 <a href="https://docs.langbot.app/plugin/plugin-intro.html">插件介绍</a> ｜
@@ -22,12 +22,14 @@
 <br/>
 
 
-[![QQ Group](https://img.shields.io/badge/%E7%A4%BE%E5%8C%BAQQ%E7%BE%A4-1030838208-blue)](https://qm.qq.com/q/PF9OuQCCcM)
+[![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">
+<img src="https://img.shields.io/badge/python-3.10 ~ 3.13 -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.md) / [English](README_EN.md) / [日本語](README_JP.md)
 
 </div>
 
@@ -35,9 +37,9 @@
 
 ## ✨ 特性
 
-- 💬 大模型对话、Agent：支持多种大模型，适配群聊和私聊；具有多轮对话、工具调用、多模态能力，并深度适配 [Dify](https://dify.ai)。目前支持 QQ、QQ频道、企业微信、飞书、Discord、个人微信，后续还将支持 WhatsApp、Telegram 等平台。
+- 💬 大模型对话、Agent：支持多种大模型，适配群聊和私聊；具有多轮对话、工具调用、多模态能力，并深度适配 [Dify](https://dify.ai)。目前支持 QQ、QQ频道、企业微信、个人微信、飞书、Discord、Telegram 等平台。
 - 🛠️ 高稳定性、功能完备：原生支持访问控制、限速、敏感词过滤等机制；配置简单，支持多种部署方式。
-- 🧩 插件扩展、活跃社区：支持事件驱动、组件扩展等插件机制；丰富生态，目前已有数十个[插件](https://docs.langbot.app/plugin/plugin-intro.html)
+- 🧩 插件扩展、活跃社区：支持事件驱动、组件扩展等插件机制；适配 Anthropic [MCP 协议](https://modelcontextprotocol.io/)；目前已有数十个[插件](https://docs.langbot.app/plugin/plugin-intro.html)
 - 😻 [New] Web 管理面板：支持通过浏览器管理 LangBot 实例，具体支持功能，查看[文档](https://docs.langbot.app/webui/intro.html)
 
 ## 📦 开始使用
@@ -85,16 +87,19 @@
 | QQ 个人号 | ✅ | QQ 个人号私聊、群聊 |
 | QQ 官方机器人 | ✅ | QQ 官方机器人，支持频道、私聊、群聊 |
 | 企业微信 | ✅ |  |
-| 飞书 | ✅ |  |
-| Discord | ✅ |  |
 | 个人微信 | ✅ | 使用 [Gewechat](https://github.com/Devo919/Gewechat) 接入 |
-| Telegram | 🚧 |  |
+| 微信公众号 | ✅ |  |
+| 飞书 | ✅ |  |
+| 钉钉 | ✅ |  |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| Slack | ✅ |  |
+| LINE | 🚧 |  |
 | WhatsApp | 🚧 |  |
-| 钉钉 | 🚧 |  |
 
 🚧: 正在开发中
 
-### 大模型
+### 大模型能力
 
 | 模型 | 状态 | 备注 |
 | --- | --- | --- |
@@ -109,13 +114,35 @@
 | [LMStudio](https://lmstudio.ai/) | ✅ | 本地大模型运行平台 |
 | [GiteeAI](https://ai.gitee.com/) | ✅ | 大模型接口聚合平台 |
 | [SiliconFlow](https://siliconflow.cn/) | ✅ | 大模型聚合平台 |
-| [阿里云百炼](https://bailian.console.aliyun.com/) | ✅ | 大模型聚合平台 |
+| [阿里云百炼](https://bailian.console.aliyun.com/) | ✅ | 大模型聚合平台, LLMOps 平台 |
+| [火山方舟](https://console.volcengine.com/ark/region:ark+cn-beijing/model?vendor=Bytedance&view=LIST_VIEW) | ✅ | 大模型聚合平台, LLMOps 平台 |
+| [MCP](https://modelcontextprotocol.io/) | ✅ | 支持通过 MCP 协议获取工具 |
+
+### TTS
+
+| 平台/模型 | 备注 |
+| --- | --- |
+| [FishAudio](https://fish.audio/zh-CN/discovery/) | [插件](https://github.com/the-lazy-me/NewChatVoice) |
+| [海豚 AI](https://www.ttson.cn/?source=thelazy) | [插件](https://github.com/the-lazy-me/NewChatVoice) |
+| [AzureTTS](https://portal.azure.com/) | [插件](https://github.com/Ingnaryk/LangBot_AzureTTS) |
+
+### 文生图
+
+| 平台/模型 | 备注 |
+| --- | --- |
+| 阿里云百炼 | [插件](https://github.com/Thetail001/LangBot_BailianTextToImagePlugin)
 
 ## 😘 社区贡献
 
-LangBot 离不开以下贡献者和社区内所有人的贡献，我们欢迎任何形式的贡献和反馈。
+感谢以下[代码贡献者](https://github.com/RockChinQ/LangBot/graphs/contributors)和社区里其他成员对 LangBot 的贡献：
-
 
 <a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
   <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
 </a>
+
+以及 LangBot 核心团队成员：
+
+- [RockChinQ](https://github.com/RockChinQ)
+- [the-lazy-me](https://github.com/the-lazy-me)
+- [wangcham](https://github.com/wangcham)
+- [KaedeSAMA](https://github.com/KaedeSAMA)

README_EN.md

@@ -5,10 +5,10 @@
 
 <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">Home</a> ｜
-<a href="https://docs.langbot.app/insight/intro.htmll">Features</a> ｜
+<a href="https://docs.langbot.app/insight/intro.html">Features</a> ｜
 <a href="https://docs.langbot.app/insight/guide.html">Deployment</a> ｜
 <a href="https://docs.langbot.app/usage/faq.html">FAQ</a> ｜
 <a href="https://docs.langbot.app/plugin/plugin-intro.html">Plugin</a> ｜
@@ -21,12 +21,12 @@
 <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">
+<img src="https://img.shields.io/badge/python-3.10 ~ 3.13 -blue.svg" alt="python">
 
-[简体中文](README.md) / [English](README_EN.md)
+[简体中文](README.md) / [English](README_EN.md) / [日本語](README_JP.md)
 
 </div>
 
@@ -34,9 +34,9 @@
 
 ## ✨ Features
 
-- 💬 Chat with LLM / Agent: Supports multiple LLMs, adapt to group chats and private chats; Supports multi-round conversations, tool calls, and multi-modal capabilities. Deeply integrates with [Dify](https://dify.ai). Currently supports QQ, QQ Channel, WeCom, Lark, Discord, personal WeChat, and will support WhatsApp, Telegram, etc. in the future.
+- 💬 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)
+- 🧩 Plugin Extension, Active Community: Support event-driven, component extension, etc. plugin mechanisms; Integrate Anthropic [MCP protocol](https://modelcontextprotocol.io/); 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
@@ -85,12 +85,14 @@ Directly use the released version to run, see the [Manual Deployment](https://do
 | Personal QQ | ✅ |  |
 | QQ Official API | ✅ |  |
 | WeCom | ✅ |  |
-| Lark | ✅ |  |
-| Discord | ✅ |  |
 | Personal WeChat | ✅ | Use [Gewechat](https://github.com/Devo919/Gewechat) to access |
-| Telegram | 🚧 |  |
+| Lark | ✅ |  |
+| DingTalk | ✅ |  |
+| Discord | ✅ |  |
+| Telegram | ✅ |  |
+| Slack | ✅ |  |
+| LINE | 🚧 |  |
 | WhatsApp | 🚧 |  |
-| DingTalk | 🚧 |  |
 
 🚧: In development
 
@@ -109,15 +111,21 @@ Directly use the released version to run, see the [Manual Deployment](https://do
 | [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) |
+| [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 |
+| [MCP](https://modelcontextprotocol.io/) | ✅ | Support tool access through MCP protocol |
 
 ## 🤝 Community Contribution
 
-Thanks to the following contributors and everyone in the community for their contributions.
+Thank you for the following [code contributors](https://github.com/RockChinQ/LangBot/graphs/contributors) and other members in the community for their contributions to LangBot:
-
 
 <a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
   <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
 </a>
 
+And the core team members of LangBot:
 
+- [RockChinQ](https://github.com/RockChinQ)
+- [the-lazy-me](https://github.com/the-lazy-me)
+- [wangcham](https://github.com/wangcham)
+- [KaedeSAMA](https://github.com/KaedeSAMA)

README_JP.md

@@ -0,0 +1,130 @@
+<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.html">機能</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.13 -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 など、複数のプラットフォームをサポートしています。
+- 🛠️ 高い安定性、豊富な機能: ネイティブのアクセス制御、レート制限、敏感な単語のフィルタリングなどのメカニズムをサポート。使いやすく、複数のデプロイ方法をサポート。
+- 🧩 プラグイン拡張、活発なコミュニティ: イベント駆動、コンポーネント拡張などのプラグインメカニズムをサポート。適配 Anthropic [MCP プロトコル](https://modelcontextprotocol.io/)；豊富なエコシステム、現在数十の[プラグイン](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 | ✅ |  |
+| Slack | ✅ |  |
+| LINE | 🚧 |  |
+| 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プラットフォーム |
+| [MCP](https://modelcontextprotocol.io/) | ✅ | MCPプロトコルをサポート |
+
+## 🤝 コミュニティ貢献
+
+LangBot への貢献に対して、以下の [コード貢献者](https://github.com/RockChinQ/LangBot/graphs/contributors) とコミュニティの他のメンバーに感謝します。
+
+<a href="https://github.com/RockChinQ/LangBot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=RockChinQ/LangBot" />
+</a>
+
+LangBot の核心チームメンバー:
+
+- [RockChinQ](https://github.com/RockChinQ)
+- [the-lazy-me](https://github.com/the-lazy-me)
+- [wangcham](https://github.com/wangcham)
+- [KaedeSAMA](https://github.com/KaedeSAMA)

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/

docker-compose.yaml

@@ -8,6 +8,8 @@ services:
       - ./data:/app/data
       - ./plugins:/app/plugins
     restart: on-failure
+    environment:
+      - TZ=Asia/Shanghai
     ports:
       - 5300:5300  # 供 WebUI 使用
       - 2280-2290:2280-2290  # 供消息平台适配器方向连接

libs/dingtalk_api/EchoHandler.py

@@ -0,0 +1,31 @@
+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,255 @@
+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,markdown_card:bool):
+        """初始化 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 = ''
+        self.markdown_card = markdown_card
+
+
+
+    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):
+        if self.markdown_card:
+            self.EchoTextHandler.reply_markdown(title=self.robot_name+'的回答',text=content,incoming_message=incoming_message)
+        else:
+            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 send_proactive_message_to_one(self,target_id:str,content:str):
+        if not await self.check_access_token():
+            await self.get_access_token()
+
+        url = 'https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend'
+
+        headers ={
+            "x-acs-dingtalk-access-token":self.access_token,
+            "Content-Type":"application/json",
+        }
+
+        data ={
+            "robotCode":self.robot_code,
+            "userIds":[target_id],
+            "msgKey": "sampleText",
+            "msgParam": json.dumps({"content":content}),
+        }
+        try:
+            async with httpx.AsyncClient() as client:
+                response  = await client.post(url,headers=headers,json=data)
+        except Exception:
+            traceback.print_exc()
+
+
+    async def send_proactive_message_to_group(self,target_id:str,content:str):
+        if not await self.check_access_token():
+            await self.get_access_token()
+
+        url = 'https://api.dingtalk.com/v1.0/robot/groupMessages/send'
+
+        headers ={
+            "x-acs-dingtalk-access-token":self.access_token,
+            "Content-Type":"application/json",
+        }
+
+        data ={
+            "robotCode":self.robot_code,
+            "openConversationId":target_id,
+            "msgKey": "sampleText",
+            "msgParam": json.dumps({"content":content}),
+        }
+        try:
+            async with httpx.AsyncClient() as client:
+                response  = await client.post(url,headers=headers,json=data)
+        except Exception:
+            traceback.print_exc()
+    
+    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,340 @@
+# 微信公众号的加解密算法与企业微信一样，所以直接使用企业微信的加解密算法文件
+from collections import deque
+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
+from pkg.platform.sources import officialaccount as oa
+
+
+
+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 = {}
+        self.generated_content = {}
+
+    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  # 机器人
+                
+                timeout = 4.80
+                interval = 0.1
+                while True:
+                    content = self.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)
+
+    async def set_message(self,msg_id:int,content:str):
+        self.generated_content[msg_id] = content
+
+
+
+class OAClientForLongerResponse():
+    
+    def __init__(self,token:str,EncodingAESKey:str,AppID:str,Appsecret:str,LoadingMessage: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.loading_message = LoadingMessage
+        self.msg_queue = {}
+        self.user_msg_queue = {}
+
+    async def handle_callback_request(self):
+        try:
+            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()
+                return echostr if check_signature == signature else "拒绝请求"
+
+            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("消息解密失败")
+
+                # 解析 XML
+                root = ET.fromstring(xml_msg)
+                from_user = root.find("FromUserName").text
+                to_user = root.find("ToUserName").text
+
+
+                if self.msg_queue.get(from_user) and self.msg_queue[from_user][0]["content"]:
+
+                    queue_top = self.msg_queue[from_user].pop(0)
+                    queue_content = queue_top["content"]
+
+                    # 弹出用户消息
+                    if self.user_msg_queue.get(from_user) and self.user_msg_queue[from_user]:
+                        self.user_msg_queue[from_user].pop(0)
+
+                    response_xml = xml_template.format(
+                        to_user=from_user,
+                        from_user=to_user,
+                        create_time=int(time.time()),
+                        content=queue_content
+                    )
+                    return response_xml
+
+                else:
+                    response_xml = xml_template.format(
+                        to_user=from_user,
+                        from_user=to_user,
+                        create_time=int(time.time()),
+                        content=self.loading_message
+                    )
+                    
+                    if self.user_msg_queue.get(from_user) and self.user_msg_queue[from_user][0]["content"]:
+                        return response_xml
+                    else:
+                        message_data = await self.get_message(xml_msg)
+                        
+                        if message_data:
+                            event = OAEvent.from_payload(message_data)
+                            if event:
+                                self.user_msg_queue.setdefault(from_user,[]).append(
+                                    {
+                                        "content":event.message,
+                                    }
+                                )
+                                await self._handle_message(event)
+
+                        return response_xml
+
+        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):
+        """
+        处理消息事件。
+        """
+
+        msg_type = event.type
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+    async def set_message(self,from_user:int,message_id:int,content:str):
+        if  from_user not in self.msg_queue:
+            self.msg_queue[from_user] = []
+        
+        self.msg_queue[from_user].append(
+            {
+                "msg_id":message_id,
+                "content":content,
+            }
+        )
+        
+
+
+
+            
+
+            
+
+

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/slack_api/api.py

@@ -0,0 +1,111 @@
+import json
+from quart import Quart, jsonify,request
+from slack_sdk.web.async_client import AsyncWebClient
+from .slackevent import SlackEvent
+from typing import Callable, Dict, Any
+from pkg.platform.types import events as platform_events, message as platform_message
+
+class SlackClient():
+    
+      def __init__(self,bot_token:str,signing_secret:str):
+
+            self.bot_token = bot_token
+            self.signing_secret = signing_secret
+            self.app = Quart(__name__)
+            self.client = AsyncWebClient(self.bot_token)
+            self.app.add_url_rule('/callback/command', 'handle_callback', self.handle_callback_request, methods=['GET', 'POST'])
+            self._message_handlers = {
+            "example":[],
+            }
+            self.bot_user_id = None # 避免机器人回复自己的消息
+
+      async def handle_callback_request(self):
+            try:
+                  body = await request.get_data()
+                  data = json.loads(body)
+                  if 'type' in data:
+                        if data['type'] == 'url_verification':
+                              return data['challenge']
+                  
+                  bot_user_id = data.get("event",{}).get("bot_id","")
+
+                  if self.bot_user_id and bot_user_id == self.bot_user_id:
+                        return jsonify({'status': 'ok'})
+                  
+                  
+                  # 处理私信
+                  if data and data.get("event", {}).get("channel_type") in ["im"]:
+                        event = SlackEvent.from_payload(data)
+                        await self._handle_message(event)
+                        return jsonify({'status': 'ok'})
+                  
+                  #处理群聊
+                  if data.get("event",{}).get("type") == 'app_mention':
+                             data.setdefault("event", {})["channel_type"] = "channel"
+                             event = SlackEvent.from_payload(data)
+                             await self._handle_message(event)
+                             return jsonify({'status':'ok'})
+
+                  return jsonify({'status': 'ok'})
+            
+            except Exception as e:
+                 raise(e)
+            
+
+
+      async def _handle_message(self, event: SlackEvent):
+        """
+        处理消息事件。
+        """
+        msg_type = event.type
+        if msg_type in self._message_handlers:
+            for handler in self._message_handlers[msg_type]:
+                await handler(event)
+
+      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 send_message_to_channel(self,text:str,channel_id:str):
+            try:
+                  response = await self.client.chat_postMessage(
+                        channel=channel_id,
+                        text=text
+                  )
+                  if self.bot_user_id is None and response.get("ok"):
+                        self.bot_user_id = response["message"]["bot_id"]
+                  return 
+            except Exception as e:
+                  raise e
+
+      async def send_message_to_one(self,text:str,user_id:str):
+            try:
+                  response = await self.client.chat_postMessage(
+                        channel = '@'+user_id,
+                        text= text
+                  )
+                  if self.bot_user_id is None and response.get("ok"):
+                        self.bot_user_id = response["message"]["bot_id"]
+                  
+                  return 
+            except Exception as e:
+                  raise e
+
+      async def run_task(self, host: str, port: int, *args, **kwargs):
+            """
+            启动 Quart 应用。
+            """
+            await self.app.run_task(host=host, port=port, *args, **kwargs)
+
+
+
+
+
+            
+
+

libs/slack_api/slackevent.py

@@ -0,0 +1,91 @@
+from typing import Dict, Any, Optional
+
+class SlackEvent(dict):
+    @staticmethod
+    def from_payload(payload: Dict[str, Any]) -> Optional["SlackEvent"]:
+        try:
+            event = SlackEvent(payload)
+            return event
+        except KeyError:
+            return None
+    
+    @property
+    def text(self) -> str:
+        
+        if self.get("event", {}).get("channel_type") == "im":
+                blocks = self.get("event", {}).get("blocks", [])
+                if not blocks:
+                    return ""
+
+                elements = blocks[0].get("elements", [])
+                if not elements:
+                    return "" 
+
+                elements = elements[0].get("elements", [])
+                text = ""
+
+                for el in elements:
+                    if el.get("type") == "text":
+                        text += el.get("text", "")
+                    elif el.get("type") == "link":
+                        text += el.get("url", "")
+
+                return text 
+
+                
+        if self.get("event",{}).get("channel_type") == 'channel': 
+            message_text = ""
+            for block in self.get("event", {}).get("blocks", []):
+                if block.get("type") == "rich_text":
+                    for element in block.get("elements", []):
+                        if element.get("type") == "rich_text_section":
+                            parts = []
+                            for el in element.get("elements", []):
+                                if el.get("type") == "text":
+                                    parts.append(el["text"])
+                                elif el.get("type") == "link":
+                                    parts.append(el["url"])
+                            message_text = "".join(parts)
+                            
+            return message_text
+
+
+    
+    @property
+    def user_id(self) -> Optional[str]:
+        return self.get("event", {}).get("user","")
+    
+    @property
+    def channel_id(self) -> Optional[str]:
+        return self.get("event", {}).get("channel","")
+    
+    @property
+    def type(self) -> str:
+        """ message对应私聊，app_mention对应频道at """
+        return self.get("event", {}).get("channel_type", "")
+    
+    @property
+    def message_id(self) -> str:
+        return self.get("event_id","")
+    
+    @property
+    def pic_url(self) -> str:
+        """提取 Slack 事件中的图片 URL"""
+        files = self.get("event", {}).get("files", [])
+        if files:
+            return files[0].get("url_private", "")
+        return None
+        
+    
+    @property
+    def sender_name(self) -> str:
+        return self.get("event", {}).get("user","")
+    
+    def __getattr__(self, key: str) -> Optional[Any]:
+        return self.get(key)
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        self[key] = value
+
+    def __repr__(self) -> str:
+        return f"<SlackEvent {super().__repr__()}>"

libs/wecom_api/api.py

@@ -66,7 +66,7 @@ class WecomClient():
             else:
                 raise Exception("未获取用户")
             
-    async def send_to_all(self,content:str):
+    async def send_to_all(self,content:str,agent_id:int):
         if not self.check_access_token_for_contacts():
             self.access_token_for_contacts = await self.get_access_token(self.secret_for_contacts)
 
@@ -77,7 +77,7 @@ class WecomClient():
                 params = {
                 "touser" : user_ids_string,
                 "msgtype" : "text",
-                "agentid" : 1000002,
+                "agentid" : agent_id,
                 "text" : {
                     "content" : content,
                 },
@@ -129,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,
@@ -228,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

pkg/api/http/controller/main.py

@@ -66,8 +66,42 @@ class HTTPController:
 
         @self.quart_app.route("/")
         async def index():
-            return await quart.send_from_directory(frontend_path, "index.html")
+            return await quart.send_from_directory(
+                frontend_path,
+                "index.html",
+                mimetype="text/html"
+            )
 
         @self.quart_app.route("/<path:path>")
         async def static_file(path: str):
-            return await quart.send_from_directory(frontend_path, path)
+
+            mimetype = None
+
+            if path.endswith(".html"):
+                mimetype = "text/html"
+            elif path.endswith(".js"):
+                mimetype = "application/javascript"
+            elif path.endswith(".css"):
+                mimetype = "text/css"
+            elif path.endswith(".png"):
+                mimetype = "image/png"
+            elif path.endswith(".jpg"):
+                mimetype = "image/jpeg"
+            elif path.endswith(".jpeg"):
+                mimetype = "image/jpeg"
+            elif path.endswith(".gif"):
+                mimetype = "image/gif"
+            elif path.endswith(".svg"):
+                mimetype = "image/svg+xml"
+            elif path.endswith(".ico"):
+                mimetype = "image/x-icon"
+            elif path.endswith(".json"):
+                mimetype = "application/json"
+            elif path.endswith(".txt"):
+                mimetype = "text/plain"
+
+            return await quart.send_from_directory(
+                frontend_path,
+                path,
+                mimetype=mimetype
+            )

pkg/command/operators/func.py

@@ -16,7 +16,6 @@ class FuncOperator(operator.CommandOperator):
 
         all_functions = await self.ap.tool_mgr.get_all_functions(
             plugin_enabled=True,
-            plugin_status=plugin_context.RuntimeContainerStatus.INITIALIZED,
         )
 
         for func in all_functions:

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,10 @@ class Application:
             case core_entities.LifecycleControlScope.PROVIDER.value:
                 self.logger.info("执行热重载 scope="+scope)
 
+                await self.tool_mgr.shutdown()
+
+                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

@@ -29,7 +29,12 @@ required_deps = {
     "lark_oapi": "lark-oapi",
     "discord": "discord.py",
     "cryptography": "cryptography",
-    "gewechat_client": "gewechat-client"
+    "gewechat_client": "gewechat-client",
+    "dingtalk_stream": "dingtalk_stream",
+    "dashscope": "dashscope",
+    "telegram": "python-telegram-bot",
+    "certifi": "certifi",
+    "mcp": "mcp",
 }
 
 

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
@@ -72,6 +72,9 @@ class Query(pydantic.BaseModel):
     user_message: typing.Optional[llm_entities.Message] = None
     """此次请求的用户消息对象，由前置处理器阶段设置"""
 
+    variables: typing.Optional[dict[str, typing.Any]] = None
+    """变量，由前置处理器阶段设置。在prompt中嵌入或由 Runner 传递到 LLMOps 平台。"""
+
     use_model: typing.Optional[entities.LLMModelInfo] = None
     """使用的模型，由前置处理器阶段设置"""
 
@@ -86,10 +89,31 @@ class Query(pydantic.BaseModel):
 
     # ======= 内部保留 =======
     current_stage: "pkg.pipeline.stagemgr.StageInstContainer" = None
+    """当前所处阶段"""
 
     class Config:
         arbitrary_types_allowed = True
 
+    # ========== 插件可调用的 API（请求 API） ==========
+
+    def set_variable(self, key: str, value: typing.Any):
+        """设置变量"""
+        if self.variables is None:
+            self.variables = {}
+        self.variables[key] = value
+    
+    def get_variable(self, key: str) -> typing.Any:
+        """获取变量"""
+        if self.variables is None:
+            return None
+        return self.variables.get(key)
+    
+    def get_variables(self) -> dict[str, typing.Any]:
+        """获取所有变量"""
+        if self.variables is None:
+            return {}
+        return self.variables
+
 
 class Conversation(pydantic.BaseModel):
     """对话，包含于 Session 中，一个 Session 可以有多个历史 Conversation，但只有一个当前使用的 Conversation"""

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

pkg/core/migrations/m021_lark_config.py

@@ -10,11 +10,12 @@ class LarkConfigMigration(migration.Migration):
     async def need_migrate(self) -> bool:
         """判断当前环境是否需要运行此迁移"""
         
-        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+        # for adapter in self.ap.platform_cfg.data['platform-adapters']:
-            if adapter['adapter'] == 'lark':
+        #     if adapter['adapter'] == 'lark':
-                return False
+        #         return False
 
-        return True
+        # return True
+        return False
 
     async def run(self):
         """执行迁移"""
@@ -23,7 +24,10 @@ class LarkConfigMigration(migration.Migration):
             "enable": False,
             "app_id": "cli_abcdefgh",
             "app_secret": "XXXXXXXXXX",
-            "bot_name": "LangBot"
+            "bot_name": "LangBot",
+            "enable-webhook": False,
+            "port": 2285,
+            "encrypt-key": "xxxxxxxxx"
         })
 
         await self.ap.platform_cfg.dump_config()

pkg/core/migrations/m024_discord_config.py

@@ -10,11 +10,12 @@ class DiscordConfigMigration(migration.Migration):
     async def need_migrate(self) -> bool:
         """判断当前环境是否需要运行此迁移"""
         
-        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+        # for adapter in self.ap.platform_cfg.data['platform-adapters']:
-            if adapter['adapter'] == 'discord':
+        #     if adapter['adapter'] == 'discord':
-                return False
+        #         return False
 
-        return True
+        # return True
+        return False
 
     async def run(self):
         """执行迁移"""

pkg/core/migrations/m025_gewechat_config.py

@@ -10,11 +10,12 @@ class GewechatConfigMigration(migration.Migration):
     async def need_migrate(self) -> bool:
         """判断当前环境是否需要运行此迁移"""
         
-        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+        # for adapter in self.ap.platform_cfg.data['platform-adapters']:
-            if adapter['adapter'] == 'gewechat':
+        #     if adapter['adapter'] == 'gewechat':
-                return False
+        #         return False
 
-        return True
+        # return True
+        return False
 
     async def run(self):
         """执行迁移"""
@@ -22,6 +23,7 @@ class GewechatConfigMigration(migration.Migration):
             "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": "",

pkg/core/migrations/m026_qqofficial_config.py

@@ -10,11 +10,12 @@ class QQOfficialConfigMigration(migration.Migration):
     async def need_migrate(self) -> bool:
         """判断当前环境是否需要运行此迁移"""
         
-        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+        # for adapter in self.ap.platform_cfg.data['platform-adapters']:
-            if adapter['adapter'] == 'qqofficial':
+        #     if adapter['adapter'] == 'qqofficial':
-                return False
+        #         return False
 
-        return True
+        # return True
+        return False
 
     async def run(self):
         """执行迁移"""

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/migrations/m035_wxoa_mode.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("wxoa-mode", 35)
+class WxoaModeMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] == 'officialaccount':
+                if 'Mode' not in adapter:
+                    return True
+        return False
+
+    async def run(self):
+        """执行迁移"""
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] == 'officialaccount':
+                if 'Mode' not in adapter:
+                    adapter['Mode'] = 'drop'
+
+        await self.ap.platform_cfg.dump_config()

pkg/core/migrations/m036_wxoa_loading_message.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("wxoa-loading-message", 36)
+class WxoaLoadingMessageMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] == 'officialaccount':
+                if 'LoadingMessage' not in adapter:
+                    return True
+        return False
+
+    async def run(self):
+        """执行迁移"""
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] == 'officialaccount':
+                if 'LoadingMessage' not in adapter:
+                    adapter['LoadingMessage'] = 'AI正在思考中，请发送任意内容获取回复。'
+
+        await self.ap.platform_cfg.dump_config()

pkg/core/migrations/m037_mcp_config.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("mcp-config", 37)
+class MCPConfigMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        return 'mcp' not in self.ap.provider_cfg.data
+
+    async def run(self):
+        """执行迁移"""
+        self.ap.provider_cfg.data['mcp'] = {
+            "servers": []
+        }
+
+        await self.ap.provider_cfg.dump_config()

pkg/core/migrations/m038_tg_dingtalk_markdown.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from .. import migration
+
+
+@migration.migration_class("tg-dingtalk-markdown", 38)
+class TgDingtalkMarkdownMigration(migration.Migration):
+    """迁移"""
+
+    async def need_migrate(self) -> bool:
+        """判断当前环境是否需要运行此迁移"""
+        
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] in ['dingtalk','telegram']:
+                if 'markdown_card' not in adapter:
+                    return True
+        return False
+    
+    async def run(self):
+        """执行迁移"""
+        for adapter in self.ap.platform_cfg.data['platform-adapters']:
+            if adapter['adapter'] in ['dingtalk','telegram']:
+                if 'markdown_card' not in adapter:
+                    adapter['markdown_card'] = False
+        await self.ap.platform_cfg.dump_config()
+                    

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

@@ -9,7 +9,11 @@ from ..migrations import m005_deepseek_cfg_completion, m006_vision_config, m007_
 from ..migrations import m010_ollama_requester_config, m011_command_prefix_config, m012_runner_config, m013_http_api_config, m014_force_delay_config
 from ..migrations import m015_gitee_ai_config, m016_dify_service_api, m017_dify_api_timeout_params, m018_xai_config, m019_zhipuai_config
 from ..migrations import m020_wecom_config, m021_lark_config, m022_lmstudio_config, m023_siliconflow_config, m024_discord_config, m025_gewechat_config
-from ..migrations import m026_qqofficial_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, m035_wxoa_mode, m036_wxoa_loading_message
+from ..migrations import m037_mcp_config, m038_tg_dingtalk_markdown
+
 
 @stage.stage_class("MigrationStage")
 class MigrationStage(stage.BootingStage):

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

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import datetime
 
 from .. import stage, entities, stagemgr
 from ...core import entities as core_entities
@@ -34,7 +35,7 @@ class PreProcessor(stage.PipelineStage):
 
         conversation = await self.ap.sess_mgr.get_conversation(session)
 
-        # 从会话取出消息和情景预设到query
+        # 设置query
         query.session = session
         query.prompt = conversation.prompt.copy()
         query.messages = conversation.messages.copy()
@@ -43,6 +44,11 @@ class PreProcessor(stage.PipelineStage):
 
         query.use_funcs = conversation.use_funcs if query.use_model.tool_call_supported else None
 
+        query.variables = {
+            "session_id": f"{query.session.launcher_type.value}_{query.session.launcher_id}",
+            "conversation_id": conversation.uuid,
+            "msg_create_time": int(query.message_event.time) if query.message_event.time else int(datetime.datetime.now().timestamp()),
+        }
 
         # 检查vision是否启用，没启用就删除所有图片
         if not self.ap.provider_cfg.data['enable-vision'] or (self.ap.provider_cfg.data['runner'] == 'local-agent' and not query.use_model.vision_supported):
@@ -54,11 +60,14 @@ class PreProcessor(stage.PipelineStage):
 
         content_list = []
 
+        plain_text = ""
+
         for me in query.message_chain:
             if isinstance(me, platform_message.Plain):
                 content_list.append(
                     llm_entities.ContentElement.from_text(me.text)
                 )
+                plain_text += me.text
             elif isinstance(me, platform_message.Image):
                 if self.ap.provider_cfg.data['enable-vision'] and (self.ap.provider_cfg.data['runner'] != 'local-agent' or query.use_model.vision_supported):
                     if me.base64 is not None:
@@ -66,6 +75,8 @@ class PreProcessor(stage.PipelineStage):
                             llm_entities.ContentElement.from_image_base64(me.base64)
                         )
 
+        query.variables['user_message_text'] = plain_text
+
         query.user_message = llm_entities.Message(
             role='user',
             content=content_list

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]] = []
+class MessagePlatformAdapter(metaclass=abc.ABCMeta):
-
-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):
     """消息平台适配器基类"""
 
     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

@@ -18,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
@@ -27,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
@@ -39,9 +43,13 @@ class PlatformManager:
     
     async def initialize(self):
 
-        from .sources import nakuru, aiocqhttp, qqbotpy, qqofficial, wecom, lark, discord, gewechat
+        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,
@@ -52,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,
@@ -76,10 +84,10 @@ class PlatformManager:
 
                 found = False
 
-                for adapter in msadapter.preregistered_adapters:
+                for adapter in self.message_platform_adapter_components:
-                    if adapter.name == adapter_name:
+                    if adapter.metadata.name == adapter_name:
                         found = True
-                        adapter_cls = adapter
+                        adapter_cls = adapter.get_python_component_class()
                         
                         adapter_inst = adapter_cls(
                             cfg_copy,
@@ -102,7 +110,7 @@ class PlatformManager:
         if len(self.adapters) == 0:
             self.ap.logger.warning('未运行平台适配器，请根据文档配置并启用平台适配器。')
 
-    async def write_back_config(self, adapter_inst: msadapter.MessageSourceAdapter, config: dict):
+    def write_back_config(self, adapter_name: str, adapter_inst: msadapter.MessagePlatformAdapter, config: dict):
         index = -2
 
         for i, adapter in enumerate(self.adapters):
@@ -124,14 +132,14 @@ class PlatformManager:
                     break
 
         new_cfg = {
-            'adapter': adapter_inst.name,
+            'adapter': adapter_name,
             'enable': True,
             **config
         }
         self.ap.platform_cfg.data['platform-adapters'][real_index] = new_cfg
-        await self.ap.platform_cfg.dump_config()
+        self.ap.platform_cfg.dump_config_sync()
 
-    async def send(self, event: platform_events.MessageEvent, msg: platform_message.MessageChain, adapter: msadapter.MessageSourceAdapter):
+    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):
 
@@ -152,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:
@@ -162,12 +170,13 @@ class PlatformManager:
                         self.ap.logger.debug(f"Traceback: {traceback.format_exc()}")
 
                 tasks.append(exception_wrapper(adapter))
-            
+
+
             for task in tasks:
                 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

@@ -57,7 +57,7 @@ class AiocqhttpMessageConverter(adapter.MessageConverter):
                 elif msg.path:
                     arg = msg.path
                     msg_list.append(aiocqhttp.MessageSegment.record(msg.path))
-            elif type(msg) is forward.Forward:
+            elif type(msg) is platform_message.Forward:
 
                 for node in msg.node_list:
                     msg_list.extend((await AiocqhttpMessageConverter.yiri2target(node.message_chain))[0])
@@ -101,69 +101,8 @@ class AiocqhttpMessageConverter(adapter.MessageConverter):
 class AiocqhttpEventConverter(adapter.EventConverter):
 
     @staticmethod
-    async def yiri2target(event: platform_events.Event, bot_account_id: int):
+    async def yiri2target(event: platform_events.MessageEvent, bot_account_id: int):
-
+        return event.source_platform_object
-        msg, msg_id, msg_time = await AiocqhttpMessageConverter.yiri2target(event.message_chain)
-
-        if type(event) is platform_events.GroupMessage:
-            role = "member"
-
-            if event.sender.permission == "ADMINISTRATOR":
-                role = "admin"
-            elif event.sender.permission == "OWNER":
-                role = "owner"
-
-            payload = {
-                "post_type": "message",
-                "message_type": "group",
-                "time": int(msg_time.timestamp()),
-                "self_id": bot_account_id,
-                "sub_type": "normal",
-                "anonymous": None,
-                "font": 0,
-                "message": str(msg),
-                "raw_message": str(msg),
-                "sender": {
-                    "age": 0,
-                    "area": "",
-                    "card": "",
-                    "level": "",
-                    "nickname": event.sender.member_name,
-                    "role": role,
-                    "sex": "unknown",
-                    "title": "",
-                    "user_id": event.sender.id,
-                },
-                "user_id": event.sender.id,
-                "message_id": msg_id,
-                "group_id": event.group.id,
-                "message_seq": 0,
-            }
-
-            return aiocqhttp.Event.from_payload(payload)
-        elif type(event) is platform_events.FriendMessage:
-
-            payload = {
-                "post_type": "message",
-                "message_type": "private",
-                "time": int(msg_time.timestamp()),
-                "self_id": bot_account_id,
-                "sub_type": "friend",
-                "target_id": bot_account_id,
-                "message": str(msg),
-                "raw_message": str(msg),
-                "font": 0,
-                "sender": {
-                    "age": 0,
-                    "nickname": event.sender.nickname,
-                    "sex": "unknown",
-                    "user_id": event.sender.id,
-                },
-                "message_id": msg_id,
-                "user_id": event.sender.id,
-            }
-            
-            return aiocqhttp.Event.from_payload(payload)
 
     @staticmethod
     async def target2yiri(event: aiocqhttp.Event):
@@ -196,6 +135,7 @@ class AiocqhttpEventConverter(adapter.EventConverter):
                 ),
                 message_chain=yiri_chain,
                 time=event.time,
+                source_platform_object=event
             )
             return converted_event
         elif event.message_type == "private":
@@ -207,11 +147,11 @@ class AiocqhttpEventConverter(adapter.EventConverter):
                 ),
                 message_chain=yiri_chain,
                 time=event.time,
+                source_platform_object=event
             )
 
 
-@adapter.adapter_class("aiocqhttp")
+class AiocqhttpAdapter(adapter.MessagePlatformAdapter):
-class AiocqhttpAdapter(adapter.MessageSourceAdapter):
 
     bot: aiocqhttp.CQHttp
 
@@ -273,7 +213,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 +230,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,194 @@
+
+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 = event.incoming_message.create_at,
+                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 = event.incoming_message.create_at
+            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"],
+            markdown_card=config["markdown_card"]
+        )
+    
+    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
+    ):
+        content = await DingTalkMessageConverter.yiri2target(message)
+        if target_type == 'person':
+            await self.bot.send_proactive_message_to_one(target_id,content)
+        if target_type == 'group':
+            await self.bot.send_proactive_message_to_group(target_id,content)
+
+    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

@@ -168,8 +168,8 @@ class DiscordEventConverter(adapter.EventConverter):
                 source_platform_object=event,
             )
 
-@adapter.adapter_class("discord")
+
-class DiscordMessageSourceAdapter(adapter.MessageSourceAdapter):
+class DiscordAdapter(adapter.MessagePlatformAdapter):
 
     bot: discord.Client
 
@@ -184,7 +184,7 @@ class DiscordMessageSourceAdapter(adapter.MessageSourceAdapter):
 
     listeners: typing.Dict[
         typing.Type[platform_events.Event],
-        typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None],
+        typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
     ] = {}
 
     def __init__(self, config: dict, ap: app.Application):
@@ -249,14 +249,14 @@ class DiscordMessageSourceAdapter(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],
     ):
         self.listeners[event_type] = callback
 
     def unregister_listener(
         self,
         event_type: typing.Type[platform_events.Event],
-        callback: typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None],
+        callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
     ):
         self.listeners.pop(event_type)
 

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

@@ -25,10 +25,14 @@ 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
+import xml.etree.ElementTree as ET
 
 
 class GewechatMessageConverter(adapter.MessageConverter):
-    
+
+    def __init__(self, config: dict):
+        self.config = config
+
     @staticmethod
     async def yiri2target(
         message_chain: platform_message.MessageChain
@@ -40,59 +44,209 @@ class GewechatMessageConverter(adapter.MessageConverter):
             elif isinstance(component, platform_message.Plain):
                 content_list.append({"type": "text", "content": component.text})
             elif isinstance(component, platform_message.Image):
-                # content_list.append({"type": "image", "image_id": component.image_id})
+                if not component.url:
-                pass
+                    pass
+                content_list.append({"type": "image", "image": component.url})
+            elif isinstance(component, platform_message.WeChatMiniPrograms):
+                content_list.append({"type": 'WeChatMiniPrograms', 'mini_app_id': component.mini_app_id, 'display_name': component.display_name,
+                                     'page_path': component.page_path, 'cover_img_url': component.image_url, 'title': component.title,
+                                     'user_name': component.user_name})
+            elif isinstance(component, platform_message.WeChatForwardMiniPrograms):
+                content_list.append({"type": 'WeChatForwardMiniPrograms', 'xml_data': component.xml_data, 'image_url': component.image_url})
+            elif isinstance(component, platform_message.WeChatEmoji):
+                content_list.append({'type': 'WeChatEmoji', 'emoji_md5': component.emoji_md5, 'emoji_size': component.emoji_size})
+            elif isinstance(component, platform_message.WeChatLink):
+                content_list.append({'type': 'WeChatLink', 'link_title': component.link_title, 'link_desc': component.link_desc,
+                                     'link_thumb_url': component.link_thumb_url, 'link_url': component.link_url})
+
+
+            elif isinstance(component, platform_message.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
 
-    @staticmethod
     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_.*:")
+            # print(message)
 
             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}'
+
+            # 正则表达式模式，匹配'@'后跟任意数量的非空白字符
+            pattern = r'@\S+'
+            at_string = f"@{bot_account_id}"
             content_list = []
             if at_string in message["Data"]["Content"]["string"]:
                 content_list.append(platform_message.At(target=bot_account_id))
-                content_list.append(platform_message.Plain(message["Data"]["Content"]["string"].replace(at_string, "", 1)))
+                content_list.append(platform_message.Plain(message["Data"]["Content"]["string"].replace(at_string, '', 1)))
+            # 更优雅的替换改名后@机器人，仅仅限于单独AT的情况
+            elif "PushContent" in message['Data'] and '在群聊中@了你' in message["Data"]["PushContent"]:
+                if '@所有人' in message["Data"]["Content"]["string"]:  # at全员时候传入atll不当作at自己
+                    content_list.append(platform_message.AtAll())
+                else:
+                    content_list.append(platform_message.At(target=bot_account_id))
+                content_list.append(platform_message.Plain(re.sub(pattern, '', message["Data"]["Content"]["string"])))
             else:
                 content_list = [platform_message.Plain(message["Data"]["Content"]["string"])]
 
             return platform_message.MessageChain(content_list)
                     
         elif message["Data"]["MsgType"] == 3:
-            image_base64 = message["Data"]["ImgBuf"]["buffer"]
+            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.Image(base64=f"data:image/jpeg;base64,{image_base64}")]
+                [platform_message.Voice(base64=f"data:audio/silk;base64,{audio_base64}")]
             )
+        elif message["Data"]["MsgType"] == 49:
+            # 支持微信聊天记录的消息类型，将 XML 内容转换为 MessageChain 传递
+            try:
+                content = message["Data"]["Content"]["string"]
+                # 有三种可能的消息结构weid开头，私聊直接<?xml>和直接<msg>
+                if content.startswith('wxid'):
+                    xml_list = content.split('\n')[2:]
+                    xml_data = '\n'.join(xml_list)
+                elif content.startswith('<?xml'):
+                    xml_list = content.split('\n')[1:]
+                    xml_data = '\n'.join(xml_list)
+                else:
+                    xml_data = content
+
+                content_data = ET.fromstring(xml_data)
+                # print(xml_data)
+                # 拿到细分消息类型，按照gewe接口中描述
+                '''
+                小程序：33/36
+                引用消息：57
+                转账消息：2000
+                红包消息：2001
+                视频号消息：51
+                '''
+                appmsg_data = content_data.find('.//appmsg')
+                data_type = appmsg_data.find('.//type').text
+                if data_type == '57':
+                    user_data = appmsg_data.find('.//title').text  # 拿到用户消息
+                    quote_data = appmsg_data.find('.//refermsg').find('.//content').text  # 引用原文
+                    sender_id = appmsg_data.find('.//refermsg').find('.//chatusr').text  # 引用用户id
+                    from_name = message['Data']['FromUserName']['string']
+                    message_list =[]
+                    if message['Wxid'] == sender_id and from_name.endswith('@chatroom'):  # 因为引用机制暂时无法响应用户，所以当引用用户是机器人是构建一个at激活机器人
+                        message_list.append(platform_message.At(target=bot_account_id))
+                    message_list.append(platform_message.Quote(
+                            sender_id=sender_id,
+                            origin=platform_message.MessageChain(
+                                [platform_message.Plain(quote_data)]
+                            )))
+                    message_list.append(platform_message.Plain(user_data))
+                    return platform_message.MessageChain(message_list)
+                elif data_type == '51':
+                    return platform_message.MessageChain(
+                        [platform_message.Plain(text=f'[视频号消息]')]
+                    )
+                    # print(content_data)
+                elif data_type == '2000':
+                    return platform_message.MessageChain(
+                        [platform_message.Plain(text=f'[转账消息]')]
+                    )
+                elif data_type == '2001':
+                    return platform_message.MessageChain(
+                        [platform_message.Plain(text=f'[红包消息]')]
+                    )
+                elif data_type == '5':
+                    return platform_message.MessageChain(
+                        [platform_message.Plain(text=f'[公众号消息]')]
+                    )
+                elif data_type == '33' or data_type == '36':
+                    return platform_message.MessageChain(
+                        [platform_message.Plain(text=f'[小程序消息]')]
+                    )
+                # print(data_type.text)
+                else:
+
+
+                    try:
+                        content_bytes = content.encode('utf-8')
+                        decoded_content = base64.b64decode(content_bytes)
+                        return platform_message.MessageChain(
+                            [platform_message.Unknown(content=decoded_content)]
+                        )
+                    except Exception as e:
+                        return platform_message.MessageChain(
+                            [platform_message.Plain(text=content)]
+                        )
+            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
 
-    @staticmethod
     async def target2yiri(
+        self,
         event: dict,
         bot_account_id: str
     ) -> platform_events.MessageEvent:
-        message_chain = await GewechatMessageConverter.target2yiri(copy.deepcopy(event), bot_account_id)
+        # print(event)
+        # 排除自己发消息回调回答问题
+        if event['Wxid'] == event['Data']['FromUserName']['string']:
+            return None
+        # 排除公众号以及微信团队消息
+        if event['Data']['FromUserName']['string'].startswith('gh_')\
+                or event['Data']['FromUserName']['string'].startswith('weixin'):
+            return None
+        message_chain = await self.message_converter.target2yiri(copy.deepcopy(event), bot_account_id)
 
         if not message_chain:
             return None
@@ -120,7 +274,7 @@ class GewechatEventConverter(adapter.EventConverter):
                 time=event["Data"]["CreateTime"],
                 source_platform_object=event,
             )
-        elif 'wxid_' in event["Data"]["FromUserName"]["string"]:
+        else:
             return platform_events.FriendMessage(
                 sender=platform_entities.Friend(
                     id=event["Data"]["FromUserName"]["string"],
@@ -133,9 +287,10 @@ class GewechatEventConverter(adapter.EventConverter):
             )
 
 
-@adapter.adapter_class("gewechat")
+class GeWeChatAdapter(adapter.MessagePlatformAdapter):
-class GewechatMessageSourceAdapter(adapter.MessageSourceAdapter):
+
-    
+    name: str = "gewechat"  # 定义适配器名称
+
     bot: gewechat_client.GewechatClient
     quart_app: quart.Quart
 
@@ -145,12 +300,12 @@ class GewechatMessageSourceAdapter(adapter.MessageSourceAdapter):
 
     ap: app.Application
 
-    message_converter: GewechatMessageConverter = GewechatMessageConverter()
+    message_converter: GewechatMessageConverter
-    event_converter: GewechatEventConverter = GewechatEventConverter()
+    event_converter: GewechatEventConverter
 
     listeners: typing.Dict[
         typing.Type[platform_events.Event],
-        typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None],
+        typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None],
     ] = {}
     
     def __init__(self, config: dict, ap: app.Application):
@@ -159,10 +314,23 @@ class GewechatMessageSourceAdapter(adapter.MessageSourceAdapter):
 
         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))
+            self.ap.logger.debug(
+                f"Gewechat callback event: {data}"
+            )
+            
+            if 'data' in data:
+                data['Data'] = data['data']
+            if 'type_name' in data:
+                data['TypeName'] = data['type_name']
+            # print(json.dumps(data, indent=4, ensure_ascii=False))
+
 
             if 'testMsg' in data:
                 return 'ok'
@@ -184,7 +352,44 @@ class GewechatMessageSourceAdapter(adapter.MessageSourceAdapter):
         target_id: str,
         message: platform_message.MessageChain
     ):
-        pass
+        geweap_msg = await self.message_converter.yiri2target(message)
+        # 此处加上群消息at处理
+        ats = [item["target"] for item in geweap_msg if item["type"] == "at"]
+
+
+        for msg in geweap_msg:
+            # at主动发送消息
+            if msg['type'] == 'text':
+                if ats:
+                    member_info = self.bot.get_chatroom_member_detail(
+                        self.config["app_id"],
+                        target_id,
+                        ats[::-1]
+                    )["data"]
+
+                    for member in member_info:
+                        msg['content'] = f'@{member["nickName"]} {msg["content"]}'
+                self.bot.post_text(app_id=self.config['app_id'], to_wxid=target_id, content=msg['content'],
+                                   ats=",".join(ats))
+
+            elif msg['type'] == 'image':
+
+                self.bot.post_image(app_id=self.config['app_id'], to_wxid=target_id, img_url=msg["image"])
+            elif msg['type'] == 'WeChatMiniPrograms':
+                self.bot.post_mini_app(app_id=self.config['app_id'], to_wxid=target_id, mini_app_id=msg['mini_app_id']
+                                       , display_name=msg['display_name'], page_path=msg['page_path']
+                                       , cover_img_url=msg['cover_img_url'], title=msg['title'], user_name=msg['user_name'])
+            elif msg['type'] == 'WeChatForwardMiniPrograms':
+                self.bot.forward_mini_app(app_id=self.config['app_id'], to_wxid=target_id, xml=msg['xml_data'], cover_img_url=msg['image_url'])
+            elif msg['type'] == 'WeChatEmoji':
+                self.bot.post_emoji(app_id=self.config['app_id'], to_wxid=target_id,
+                                    emoji_md5=msg['emoji_md5'], emoji_size=msg['emoji_size'])
+            elif msg['type'] == 'WeChatLink':
+                self.bot.post_link(app_id=self.config['app_id'], to_wxid=target_id
+                                   ,title=msg['link_title'], desc=msg['link_desc']
+                                   , link_url=msg['link_url'], thumb_url=msg['link_thumb_url'])
+
+
 
     async def reply_message(
         self,
@@ -195,6 +400,7 @@ class GewechatMessageSourceAdapter(adapter.MessageSourceAdapter):
         content_list = await self.message_converter.yiri2target(message)
 
         ats = [item["target"] for item in content_list if item["type"] == "at"]
+        target_id = message_source.source_platform_object["Data"]["FromUserName"]["string"]
 
         for msg in content_list:
             if msg["type"] == "text":
@@ -213,8 +419,24 @@ class GewechatMessageSourceAdapter(adapter.MessageSourceAdapter):
                     app_id=self.config["app_id"],
                     to_wxid=message_source.source_platform_object["Data"]["FromUserName"]["string"],
                     content=msg["content"],
-                    ats=','.join(ats)
+                    ats=",".join(ats)
                 )
+            elif msg['type'] == 'image':
+
+                self.bot.post_image(app_id=self.config['app_id'], to_wxid=target_id, img_url=msg["image"])
+            elif msg['type'] == 'WeChatMiniPrograms':
+                self.bot.post_mini_app(app_id=self.config['app_id'], to_wxid=target_id, mini_app_id=msg['mini_app_id']
+                                       , display_name=msg['display_name'], page_path=msg['page_path']
+                                       , cover_img_url=msg['cover_img_url'], title=msg['title'], user_name=msg['user_name'])
+            elif msg['type'] == 'WeChatForwardMiniPrograms':
+                self.bot.forward_mini_app(app_id=self.config['app_id'], to_wxid=target_id, xml=msg['xml_data'], cover_img_url=msg['image_url'])
+            elif msg['type'] == 'WeChatEmoji':
+                self.bot.post_emoji(app_id=self.config['app_id'], to_wxid=target_id,
+                                    emoji_md5=msg['emoji_md5'], emoji_size=msg['emoji_size'])
+            elif msg['type'] == 'WeChatLink':
+                self.bot.post_link(app_id=self.config['app_id'], to_wxid=target_id
+                                   , title=msg['link_title'], desc=msg['link_desc']
+                                   , link_url=msg['link_url'], thumb_url=msg['link_thumb_url'])
 
     async def is_muted(self, group_id: int) -> bool:
         pass
@@ -222,14 +444,14 @@ class GewechatMessageSourceAdapter(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]
     ):
         self.listeners[event_type] = callback
 
     def unregister_listener(
         self,
         event_type: typing.Type[platform_events.Event],
-        callback: typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None]
+        callback: typing.Callable[[platform_events.Event, adapter.MessagePlatformAdapter], None]
     ):
         pass
 
@@ -250,26 +472,28 @@ class GewechatMessageSourceAdapter(adapter.MessageSourceAdapter):
             self.config["token"]
         )
 
-        app_id, error_msg = self.bot.login(self.config["app_id"])
+        def gewechat_login_process():
-        if error_msg:
-            raise Exception(f"Gewechat 登录失败: {error_msg}")
 
-        self.config["app_id"] = app_id
+            app_id, error_msg = self.bot.login(self.config["app_id"])
+            if error_msg:
+                raise Exception(f"Gewechat 登录失败: {error_msg}")
 
-        self.ap.logger.info(f"Gewechat 登录成功，app_id: {app_id}")
+            self.config["app_id"] = app_id
 
-        await self.ap.platform_mgr.write_back_config(self, self.config)
+            self.ap.logger.info(f"Gewechat 登录成功，app_id: {app_id}")
 
-        # 获取 nickname
+            self.ap.platform_mgr.write_back_config('gewechat', self, self.config)
-        profile = self.bot.get_profile(self.config["app_id"])
+
-        self.bot_account_id = profile["data"]["nickName"]
+            # 获取 nickname
+            profile = self.bot.get_profile(self.config["app_id"])
+            self.bot_account_id = profile["data"]["nickName"]
+
+            time.sleep(2)
 
-        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()
+        threading.Thread(target=gewechat_login_process).start()
 
         async def shutdown_trigger_placeholder():
             while True:
@@ -282,4 +506,4 @@ class GewechatMessageSourceAdapter(adapter.MessageSourceAdapter):
         )
 
     async def kill(self) -> bool:
-        pass
+        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

@@ -11,10 +11,16 @@ 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
@@ -25,6 +31,28 @@ 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
@@ -270,8 +298,7 @@ class LarkEventConverter(adapter.EventConverter):
             )
 
 
-@adapter.adapter_class("lark")
+class LarkAdapter(adapter.MessagePlatformAdapter):
-class LarkMessageSourceAdapter(adapter.MessageSourceAdapter):
 
     bot: lark_oapi.ws.Client
     api_client: lark_oapi.Client
@@ -284,16 +311,65 @@ class LarkMessageSourceAdapter(adapter.MessageSourceAdapter):
 
     listeners: typing.Dict[
         typing.Type[platform_events.Event],
-        typing.Callable[[platform_events.Event, adapter.MessageSourceAdapter], None],
+        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
+
+                self.ap.logger.debug(
+                    f"Lark callback event: {data}"
+                )
+
+                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):
 
@@ -377,7 +453,7 @@ class LarkMessageSourceAdapter(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
         ],
     ):
         self.listeners[event_type] = callback
@@ -386,22 +462,35 @@ class LarkMessageSourceAdapter(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
         ],
     ):
         self.listeners.pop(event_type)
 
     async def run_async(self):
-        try:
+        port = self.config['port']
-            await self.bot._connect()
+        enable_webhook = self.config['enable-webhook']
-        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
 
+        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 NakuruAdapter(adapter_model.MessagePlatformAdapter):
-class NakuruProjectAdapter(adapter_model.MessageSourceAdapter):
     """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,166 @@
+from __future__ import annotations
+import typing
+import asyncio
+import traceback
+
+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
+from collections import deque
+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 libs.official_account_api.api import OAClientForLongerResponse
+from pkg.core import app
+from .. import adapter
+from ...core import app
+from ..types import message as platform_message
+from ..types import events as platform_events
+from ..types import entities as platform_entities
+from ...command.errors import ParamNotEnoughError
+
+
+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 | OAClientForLongerResponse
+    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",
+            "Mode",
+        ]
+        missing_keys = [key for key in required_keys if key not in config]
+        if missing_keys:
+            raise ParamNotEnoughError("微信公众号缺少相关配置项，请查看文档或联系管理员")
+        
+        
+        if self.config['Mode'] == "drop":
+            self.bot = OAClient(
+                token=config['token'],
+                EncodingAESKey=config['EncodingAESKey'],
+                Appsecret=config['AppSecret'],
+                AppID=config['AppID'], 
+            )
+        elif self.config['Mode'] == "passive":
+            self.bot = OAClientForLongerResponse(
+                token=config['token'],
+                EncodingAESKey=config['EncodingAESKey'],
+                Appsecret=config['AppSecret'],
+                AppID=config['AppID'], 
+                LoadingMessage=config['LoadingMessage']
+            )
+        else:
+            raise KeyError("请设置微信公众号通信模式")
+
+
+    async def reply_message(self, message_source: platform_events.FriendMessage, message: platform_message.MessageChain, quote_origin: bool = False):
+
+        content = await OAMessageConverter.yiri2target(
+            message
+        )
+        if type(self.bot) == OAClient:
+            await self.bot.set_message(message_source.message_chain.message_id,content)
+        if type(self.bot) == OAClientForLongerResponse:
+            from_user = message_source.sender.id
+            await self.bot.set_message(from_user,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.MessagePlatformAdapter):
-class OfficialAdapter(adapter_model.MessageSourceAdapter):
     """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

@@ -2,15 +2,14 @@ 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.adapter import MessageSourceAdapter
 from pkg.platform.types import events as platform_events, message as platform_message
 from pkg.core import app
 from .. import adapter
-from ...pipeline.longtext.strategies import forward
+
 from ...core import app
 from ..types import message as platform_message
 from ..types import events as platform_events
@@ -47,7 +46,7 @@ class QQOfficialMessageConverter(adapter.MessageConverter):
             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
@@ -74,7 +73,11 @@ class QQOfficialEventConverter(adapter.EventConverter):
                 remark = "",
             )
             return platform_events.FriendMessage(
-                sender = friend,message_chain = yiri_chain,time = event.timestamp,
+                sender = friend,message_chain = yiri_chain,time = int(
+                    datetime.datetime.strptime(
+                        event.timestamp, "%Y-%m-%dT%H:%M:%S%z"
+                    ).timestamp()
+                ),
                 source_platform_object=event
             )
         
@@ -96,7 +99,7 @@ class QQOfficialEventConverter(adapter.EventConverter):
                 member_name= event.t,
                 permission= 'MEMBER',
                 group = platform_entities.Group(
-                    id = 0,
+                    id = event.group_openid,
                     name = 'MEMBER',
                     permission= platform_entities.Permission.Member
                 ),
@@ -105,7 +108,11 @@ class QQOfficialEventConverter(adapter.EventConverter):
                 last_speak_timestamp=0,
                 mute_time_remaining=0
             )
-            time = event.timestamp
+            time = int(
+                    datetime.datetime.strptime(
+                        event.timestamp, "%Y-%m-%dT%H:%M:%S%z"
+                    ).timestamp()
+                )
             return platform_events.GroupMessage(
                 sender = sender,
                 message_chain=yiri_chain,
@@ -119,7 +126,7 @@ class QQOfficialEventConverter(adapter.EventConverter):
                 member_name=event.t,
                 permission= 'MEMBER',
                 group = platform_entities.Group(
-                    id = 0,
+                    id = event.channel_id,
                     name = 'MEMBER',
                     permission=platform_entities.Permission.Member
                 ),
@@ -128,7 +135,11 @@ class QQOfficialEventConverter(adapter.EventConverter):
                 last_speak_timestamp=0,
                 mute_time_remaining=0
             )
-            time = event.timestamp,
+            time = int(
+                    datetime.datetime.strptime(
+                        event.timestamp, "%Y-%m-%dT%H:%M:%S%z"
+                    ).timestamp()
+                )
             return platform_events.GroupMessage(
                 sender  =sender,
                 message_chain = yiri_chain,
@@ -137,10 +148,7 @@ class QQOfficialEventConverter(adapter.EventConverter):
             )
 
 
-        
+class QQOfficialAdapter(adapter.MessagePlatformAdapter):
-
-@adapter.adapter_class("qqofficial")
-class QQOfficialAdapter(adapter.MessageSourceAdapter):
     bot:QQOfficialClient
     ap:app.Application
     config:dict
@@ -213,7 +221,7 @@ class QQOfficialAdapter(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:QQOfficialEvent):
@@ -250,7 +258,7 @@ class QQOfficialAdapter(adapter.MessageSourceAdapter):
     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/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/slack.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+import typing
+import asyncio
+import traceback
+
+import datetime
+
+from libs.slack_api.api import SlackClient
+from pkg.platform.adapter import MessagePlatformAdapter
+from pkg.platform.types import events as platform_events, message as platform_message
+from libs.slack_api.slackevent import SlackEvent
+from pkg.core import app
+from .. import adapter
+from ...core import app
+from ..types import message as platform_message
+from ..types import events as platform_events
+from ..types import entities as platform_entities
+from ...command.errors import ParamNotEnoughError
+from ...utils import image
+
+class SlackMessageConverter(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({
+                    "content":msg.text,
+                })
+        
+        return content_list
+
+    @staticmethod
+    async def target2yiri(message:str,message_id:str,pic_url:str,bot:SlackClient):
+        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_slack_image_to_base64(pic_url=pic_url,bot_token=bot.bot_token)
+            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 SlackEventConverter(adapter.EventConverter):
+    
+    @staticmethod
+    async def yiri2target(event:platform_events.MessageEvent) -> SlackEvent:
+        return event.source_platform_object
+    
+    @staticmethod
+    async def target2yiri(event:SlackEvent,bot:SlackClient):
+        yiri_chain = await SlackMessageConverter.target2yiri(
+            message=event.text,message_id=event.message_id,pic_url=event.pic_url,bot=bot
+        )
+
+        if event.type == 'channel':
+            yiri_chain.insert(0, platform_message.At(target="SlackBot"))
+
+            sender = platform_entities.GroupMember(
+                id = event.user_id,
+                member_name= str(event.sender_name),
+                permission= 'MEMBER',
+                group = platform_entities.Group(
+                    id = event.channel_id,
+                    name = 'MEMBER',
+                    permission= platform_entities.Permission.Member
+                ),
+                special_title='',
+                join_timestamp=0,
+                last_speak_timestamp=0,
+                mute_time_remaining=0
+            )
+            time = int(datetime.datetime.utcnow().timestamp())
+            return platform_events.GroupMessage(
+                sender = sender,
+                message_chain=yiri_chain,
+                time = time,
+                source_platform_object=event
+            )
+
+        if event.type == 'im':
+            return platform_events.FriendMessage(
+                sender=platform_entities.Friend(
+                    id=event.user_id,
+                    nickname = event.sender_name,
+                    remark=""
+                ),
+                message_chain = yiri_chain,
+                time = float(datetime.datetime.now().timestamp()),
+                source_platform_object=event,
+            )
+    
+
+
+
+class SlackAdapter(adapter.MessagePlatformAdapter):
+    bot: SlackClient
+    ap: app.Application
+    bot_account_id: str
+    message_converter: SlackMessageConverter = SlackMessageConverter()
+    event_converter: SlackEventConverter = SlackEventConverter()
+    config: dict
+
+    def __init__(self,config:dict,ap:app.Application):
+        self.config = config
+        self.ap = ap
+        required_keys = [
+            "bot_token",
+            "signing_secret",
+        ]
+        missing_keys = [key for key in required_keys if key not in config]
+        if missing_keys:
+            raise ParamNotEnoughError("Slack机器人缺少相关配置项，请查看文档或联系管理员")
+
+        self.bot = SlackClient(
+            bot_token=self.config["bot_token"],
+            signing_secret=self.config["signing_secret"]
+        ) 
+
+    async def reply_message(
+        self,
+        message_source: platform_events.MessageEvent,
+        message: platform_message.MessageChain,
+        quote_origin: bool = False,
+    ):
+        slack_event = await SlackEventConverter.yiri2target(
+            message_source
+        )
+
+        content_list  = await SlackMessageConverter.yiri2target(message)
+
+        for content in content_list:
+            if slack_event.type == 'channel':
+                await self.bot.send_message_to_channel(
+                    content['content'],slack_event.channel_id
+                )
+            if slack_event.type == 'im':
+                await self.bot.send_message_to_one(
+                    content['content'],slack_event.user_id
+                )
+    
+    async def send_message(self, target_type: str, target_id: str, message: platform_message.MessageChain):
+        content_list = await SlackMessageConverter.yiri2target(message)
+        for content in content_list:
+            if target_type == 'person':
+                await self.bot.send_message_to_one(content['content'],target_id)
+            if target_type == 'group':
+                await self.bot.send_message_to_channel(content['content'],target_id)
+
+
+    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:SlackEvent):
+            self.bot_account_id = 'SlackBot'
+            try:
+                return await callback(
+                    await self.event_converter.target2yiri(event,self.bot),self
+                )
+            except:
+                traceback.print_exc()
+        
+        if event_type == platform_events.FriendMessage:
+            self.bot.on_message("im")(on_message)
+        elif event_type == platform_events.GroupMessage:
+            self.bot.on_message("channel")(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
+
+    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/slack.yaml

@@ -0,0 +1,44 @@
+apiVersion: v1
+kind: MessagePlatformAdapter
+metadata:
+  name: slack
+  label:
+    en_US: Slack API
+    zh_CN: Slack API
+  description:
+    en_US: Slack API
+    zh_CN: Slack API
+spec:
+  config:
+    - name: bot_token
+      label:
+        en_US: Bot Token
+        zh_CN: 机器人令牌
+      type: string
+      required: true
+      default: ""
+    - name: signing_secret
+      label:
+        en_US: signing_secret
+        zh_CN: 密钥
+      type: string
+      required: true
+      default: ""
+    - name: port
+      label:
+        en_US: Port
+        zh_CN: 监听端口
+      type: int
+      required: true
+      default: 2288
+    - name: host
+      label:
+        en_US: Host
+        zh_CN: 监听主机
+      type: string
+      required: true
+      default: 0.0.0.0
+execution:
+  python:
+    path: ./slack.py
+    attr: SlackAdapter

pkg/platform/sources/telegram.py

@@ -0,0 +1,245 @@
+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 self.config['markdown_card'] is True:
+                    args["parse_mode"] = "MarkdownV2"
+
+                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

@@ -2,18 +2,15 @@ from __future__ import annotations
 import typing
 import asyncio
 import traceback
-import time
+
 import datetime
 
-import aiocqhttp
-import aiohttp
 from libs.wecom_api.api import WecomClient
-from pkg.platform.adapter import MessageSourceAdapter
+from pkg.platform.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
 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
@@ -119,9 +116,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="",
             )
@@ -131,7 +127,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="",
             )
@@ -145,8 +141,7 @@ class WecomEventConverter:
             )
 
 
-@adapter.adapter_class("wecom")
+class WecomAdapter(adapter.MessagePlatformAdapter):
-class WecomeAdapter(adapter.MessageSourceAdapter):
 
     bot: WecomClient
     ap: app.Application
@@ -154,7 +149,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
@@ -191,23 +185,37 @@ 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
     ):
-        pass
+        """企业微信目前只有发送给个人的方法，
+        构造target_id的方式为前半部分为账户id，后半部分为agent_id,中间使用“|”符号隔开。
+        """
+        content_list = await WecomMessageConverter.yiri2target(message, self.bot)
+        parts = target_id.split("|")
+        user_id = parts[0]
+        agent_id = int(parts[1])
+        if target_type == 'person':
+            for content in content_list:
+                if content["type"] == "text":
+                    await self.bot.send_private_msg(user_id,agent_id,content["content"])
+                if content["type"] == "image":
+                    await self.bot.send_image(user_id,agent_id,content["media"])
 
     def register_listener(
         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):
@@ -242,6 +250,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 号或群号。"""
+    """ID。"""
-    @abc.abstractmethod
-    def get_avatar_url(self) -> str:
-        """头像图片链接。"""
-
     @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,6 +57,9 @@ class MessageEvent(Event):
     message_chain: platform_message.MessageChain
     """消息内容。"""
 
+    time: float | None = None
+    """消息发送时间戳。"""
+
     source_platform_object: typing.Optional[typing.Any] = None
     """原消息平台对象。
     供消息平台适配器开发者使用，如果回复用户时需要使用原消息事件对象的信息，
@@ -79,7 +67,7 @@ class MessageEvent(Event):
 
 
 class FriendMessage(MessageEvent):
-    """好友消息。
+    """私聊消息。
 
     Args:
         type: 事件名。
@@ -111,19 +99,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]
 
@@ -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
     """被引用回复的原消息的消息链对象。"""
 
@@ -504,7 +492,7 @@ class At(MessageComponent):
     type: str = "At"
     """消息组件类型。"""
     target: typing.Union[int, str]
-    """群员 QQ 号。"""
+    """群员 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)
@@ -821,6 +807,56 @@ class File(MessageComponent):
     """文件名称。"""
     size: int
     """文件大小。"""
+
     def __str__(self):
         return f'[文件]{self.name}'
 
+# ================ 个人微信专用组件 ================
+
+class WeChatMiniPrograms(MessageComponent):
+    """小程序。个人微信专用组件。"""
+    type: str = 'WeChatMiniPrograms'
+    """小程序id"""
+    mini_app_id: str
+    """小程序归属用户id"""
+    user_name: str
+    """小程序名称"""
+    display_name: typing.Optional[str] = ''
+    """打开地址"""
+    page_path: typing.Optional[str] = ''
+    """小程序标题"""
+    title: typing.Optional[str] = ''
+    """首页图片"""
+    image_url: typing.Optional[str] = ''
+
+
+class WeChatForwardMiniPrograms(MessageComponent):
+    """转发小程序。个人微信专用组件。"""
+    type: str = 'WeChatForwardMiniPrograms'
+    """xml数据"""
+    xml_data: str
+    """首页图片"""
+    image_url: typing.Optional[str] = None
+
+
+class WeChatEmoji(MessageComponent):
+    """emoji表情。个人微信专用组件。"""
+    type: str = 'WeChatEmoji'
+    """emojimd5"""
+    emoji_md5: str
+    """emoji大小"""
+    emoji_size: int
+
+
+class WeChatLink(MessageComponent):
+    """发送链接。个人微信专用组件。"""
+    type: str = 'WeChatLink'
+    """标题"""
+    link_title: str = ''
+    """链接描述"""
+    link_desc: str = ''
+    """链接地址"""
+    link_url: str = ''
+    """链接略缩图"""
+    link_thumb_url: str = ''
+

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/plugin/installers/github.py

@@ -4,6 +4,8 @@ import re
 import os
 import shutil
 import zipfile
+import ssl
+import certifi
 
 import aiohttp
 import aiofiles
@@ -21,44 +23,39 @@ class GitHubRepoInstaller(installer.PluginInstaller):
 
     def get_github_plugin_repo_label(self, repo_url: str) -> list[str]:
         """获取username, repo"""
-
-        # 提取 username/repo , 正则表达式
         repo = re.findall(
             r"(?:https?://github\.com/|git@github\.com:)([^/]+/[^/]+?)(?:\.git|/|$)",
             repo_url,
         )
-
+        if len(repo) > 0:
-        if len(repo) > 0:  # github
             return repo[0].split("/")
         else:
             return None
-    
+
     async def download_plugin_source_code(self, repo_url: str, target_path: str, task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder()) -> str:
         """下载插件源码（全异步）"""
-        
-        # 提取 username/repo , 正则表达式
         repo = self.get_github_plugin_repo_label(repo_url)
-
-        target_path += repo[1]
-
         if repo is None:
             raise errors.PluginInstallerError('仅支持GitHub仓库地址')
         
+        target_path += repo[1]
         self.ap.logger.debug("正在下载源码...")
         task_context.trace("下载源码...", "download-plugin-source-code")
         
         zipball_url = f"https://api.github.com/repos/{'/'.join(repo)}/zipball/HEAD"
-
         zip_resp: bytes = None
+        
+        # 创建自定义SSL上下文，使用certifi提供的根证书
+        ssl_context = ssl.create_default_context(cafile=certifi.where())
 
         async with aiohttp.ClientSession(trust_env=True) as session:
             async with session.get(
                 url=zipball_url,
-                timeout=aiohttp.ClientTimeout(total=300)
+                timeout=aiohttp.ClientTimeout(total=300),
+                ssl=ssl_context  # 使用自定义SSL上下文来验证证书
             ) as resp:
                 if resp.status != 200:
-                    raise errors.PluginInstallerError(f"下载源码失败: {resp.text}")
+                    raise errors.PluginInstallerError(f"下载源码失败: {await resp.text()}")
-                
                 zip_resp = await resp.read()
         
         if await aiofiles_os.path.exists("temp/" + target_path):
@@ -80,15 +77,11 @@ class GitHubRepoInstaller(installer.PluginInstaller):
         await aiofiles_os.remove("temp/" + target_path + "/source.zip")
 
         import glob
-
         unzip_dir = glob.glob("temp/" + target_path + "/*")[0]
-
         await aioshutil.copytree(unzip_dir, target_path + "/")
-
         await aioshutil.rmtree(unzip_dir)
         
         self.ap.logger.debug("源码下载完成。")
-
         return repo[1]
 
     async def install_requirements(self, path: str):
@@ -100,20 +93,14 @@ class GitHubRepoInstaller(installer.PluginInstaller):
         plugin_source: str,
         task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
     ):
-        """安装插件
+        """安装插件"""
-        """
         task_context.trace("下载插件源码...", "install-plugin")
-
         repo_label = await self.download_plugin_source_code(plugin_source, "plugins/", task_context)
-
         task_context.trace("安装插件依赖...", "install-plugin")
-
         await self.install_requirements("plugins/" + repo_label)
-
         task_context.trace("完成.", "install-plugin")
-
         await self.ap.plugin_mgr.setting.record_installed_plugin_source(
-            "plugins/"+repo_label+'/', plugin_source
+            "plugins/" + repo_label + '/', plugin_source
         )
 
     async def uninstall_plugin(
@@ -121,10 +108,8 @@ class GitHubRepoInstaller(installer.PluginInstaller):
         plugin_name: str,
         task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
     ):
-        """卸载插件
+        """卸载插件"""
-        """
         plugin_container = self.ap.plugin_mgr.get_plugin_by_name(plugin_name)
-
         if plugin_container is None:
             raise errors.PluginInstallerError('插件不存在或未成功加载')
         else:
@@ -135,24 +120,18 @@ class GitHubRepoInstaller(installer.PluginInstaller):
     async def update_plugin(
         self,
         plugin_name: str,
-        plugin_source: str=None,
+        plugin_source: str = None,
         task_context: taskmgr.TaskContext = taskmgr.TaskContext.placeholder(),
     ):
-        """更新插件
+        """更新插件"""
-        """
         task_context.trace("更新插件...", "update-plugin")
-
         plugin_container = self.ap.plugin_mgr.get_plugin_by_name(plugin_name)
-
         if plugin_container is None:
             raise errors.PluginInstallerError('插件不存在或未成功加载')
         else:
             if plugin_container.plugin_source:
                 plugin_source = plugin_container.plugin_source
-
                 task_context.trace("转交安装任务.", "update-plugin")
-
                 await self.install_plugin(plugin_source, task_context)
-
             else:
-                raise errors.PluginInstallerError('插件无源码信息，无法更新')
+                raise errors.PluginInstallerError('插件无源码信息，无法更新')

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, lmstudiochatcmpl, siliconflowchatcmpl
+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:

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 请求器"""
 
@@ -25,7 +25,7 @@ class AnthropicMessages(requester.LLMAPIRequester):
     async def initialize(self):
 
         httpx_client = anthropic._base_client.AsyncHttpxClientWrapper(
-            base_url=self.ap.provider_cfg.data['requester']['anthropic-messages']['base-url'],
+            base_url=self.ap.provider_cfg.data['requester']['anthropic-messages']['base-url'].replace(' ', ''),
             # cast to a valid type because mypy doesn't understand our type narrowing
             timeout=typing.cast(httpx.Timeout, self.ap.provider_cfg.data['requester']['anthropic-messages']['timeout']),
             limits=anthropic._constants.DEFAULT_CONNECTION_LIMITS,
@@ -59,9 +59,11 @@ class AnthropicMessages(requester.LLMAPIRequester):
             if m.role == "system":
                 system_role_message = m
 
-                messages.pop(i)
                 break
 
+        if system_role_message:
+            messages.pop(i)
+
         if isinstance(system_role_message, llm_entities.Message) \
             and isinstance(system_role_message.content, str):
             args['system'] = system_role_message.content
@@ -69,11 +71,32 @@ class AnthropicMessages(requester.LLMAPIRequester):
         req_messages = []
 
         for m in messages:
-            if isinstance(m.content, str) and m.content.strip() != "":
+            if m.role == 'tool':
-                req_messages.append(m.dict(exclude_none=True))
+                tool_call_id = m.tool_call_id
-            elif isinstance(m.content, list):
 
-                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 +113,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 tools:
-        #
+                args["tools"] = tools
-        # if funcs:
-        #     tools = await self.ap.tool_mgr.generate_tools_for_openai(funcs)
-
-        #     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(
+            args = {
-                content=resp.content[0].text,
+                'content': '',
-                role=resp.role
+                '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

@@ -20,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 请求器"""
 
@@ -37,7 +36,7 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
 
         self.client = openai.AsyncClient(
             api_key="",
-            base_url=self.requester_cfg['base-url'],
+            base_url=self.requester_cfg['base-url'].replace(' ', ''),
             timeout=self.requester_cfg['timeout'],
             http_client=httpx.AsyncClient(
                 trust_env=True,
@@ -48,68 +47,9 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
     async def _req(
         self,
         args: dict,
+        extra_body: dict = {},
     ) -> chat_completion.ChatCompletion:
-        args["stream"] = True
+        return await self.client.chat.completions.create(**args, extra_body=extra_body)
-
-        chunk = None
-
-        pending_content = ""
-
-        tool_calls = []
-
-        resp_gen: openai.AsyncStream = await self.client.chat.completions.create(**args)
-
-        async for chunk in resp_gen:
-            # print(chunk)
-            if not chunk:
-                continue
-
-            if chunk.choices[0].delta.content is not None:
-                pending_content += chunk.choices[0].delta.content
-
-            if chunk.choices[0].delta.tool_calls is not None:
-                for tool_call in chunk.choices[0].delta.tool_calls:
-                    for tc in tool_calls:
-                        if tc.index == tool_call.index:
-                            tc.function.arguments += tool_call.function.arguments
-                            break
-                    else:
-                        tool_calls.append(tool_call)
-
-        real_tool_calls = []
-
-        for tc in tool_calls:
-            function = chat_completion_message_tool_call.Function(
-                name=tc.function.name,
-                arguments=tc.function.arguments
-            )
-            real_tool_calls.append(chat_completion_message_tool_call.ChatCompletionMessageToolCall(
-                id=tc.id,
-                function=function,
-                type="function"
-            ))
-
-        return chat_completion.ChatCompletion(
-            id=chunk.id,
-            object="chat.completion",
-            created=chunk.created,
-            choices=[
-                chat_completion.Choice(
-                    index=0,
-                    message=chat_completion.ChatCompletionMessage(
-                        role="assistant",
-                        content=pending_content,
-                        tool_calls=real_tool_calls if len(real_tool_calls) > 0 else None
-                    ),
-                    finish_reason=chunk.choices[0].finish_reason if hasattr(chunk.choices[0], 'finish_reason') and chunk.choices[0].finish_reason is not None else 'stop',
-                    logprobs=chunk.choices[0].logprobs,
-                )
-            ],
-            model=chunk.model,
-            service_tier=chunk.service_tier if hasattr(chunk, 'service_tier') else None,
-            system_fingerprint=chunk.system_fingerprint if hasattr(chunk, 'system_fingerprint') else None,
-            usage=chunk.usage if hasattr(chunk, 'usage') else None
-        ) if chunk else None
 
     async def _make_msg(
         self,
@@ -134,7 +74,7 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
     ) -> llm_entities.Message:
         self.client.api_key = use_model.token_mgr.get_token()
 
-        args = self.requester_cfg['args'].copy()
+        args = {}
         args["model"] = use_model.name if use_model.model_name is None else use_model.model_name
 
         if use_funcs:
@@ -160,7 +100,7 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
         args["messages"] = messages
 
         # 发送请求
-        resp = await self._req(args)
+        resp = await self._req(args, extra_body=self.requester_cfg['args'])
 
         # 处理请求结果
         message = await self._make_msg(resp)

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 请求器"""
 
@@ -24,7 +23,7 @@ class DeepseekChatCompletions(chatcmpl.OpenAIChatCompletions):
     ) -> llm_entities.Message:
         self.client.api_key = use_model.token_mgr.get_token()
 
-        args = self.requester_cfg['args'].copy()
+        args = {}
         args["model"] = use_model.name if use_model.model_name is None else use_model.model_name
 
         if use_funcs:
@@ -44,7 +43,7 @@ class DeepseekChatCompletions(chatcmpl.OpenAIChatCompletions):
         args["messages"] = messages
 
         # 发送请求
-        resp = await self._req(args)
+        resp = await self._req(args, extra_body=self.requester_cfg['args'])
 
         if resp is None:
             raise errors.RequesterError('接口返回为空，请确定模型提供商服务是否正常')

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 请求器"""
 
@@ -31,7 +30,7 @@ class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
     ) -> llm_entities.Message:
         self.client.api_key = use_model.token_mgr.get_token()
 
-        args = self.requester_cfg['args'].copy()
+        args = {}
         args["model"] = use_model.name if use_model.model_name is None else use_model.model_name
 
         if use_funcs:
@@ -47,7 +46,7 @@ class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
 
         args["messages"] = req_messages
 
-        resp = await self._req(args)
+        resp = await self._req(args, extra_body=self.requester_cfg['args'])
 
         message = await self._make_msg(resp)
 

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

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

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 请求器"""
 
@@ -26,7 +25,7 @@ class MoonshotChatCompletions(chatcmpl.OpenAIChatCompletions):
     ) -> llm_entities.Message:
         self.client.api_key = use_model.token_mgr.get_token()
 
-        args = self.requester_cfg['args'].copy()
+        args = {}
         args["model"] = use_model.name if use_model.model_name is None else use_model.model_name
 
         if use_funcs:
@@ -49,7 +48,7 @@ class MoonshotChatCompletions(chatcmpl.OpenAIChatCompletions):
         args["messages"] = messages
 
         # 发送请求
-        resp = await self._req(args)
+        resp = await self._req(args, extra_body=self.requester_cfg['args'])
 
         # 处理请求结果
         message = await self._make_msg(resp)

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

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

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