feat(channels): add multi-channel management UI with real-time connect/disconnect

- Web console Channels page: display active channels as config cards, support
  save/connect/disconnect with real-time start/stop of channel processes
- Custom dropdown for channel selection (consistent with model selector style),
  custom confirmation dialog for disconnect
- Fix channel stop: use sys.modules['__main__'] to access live ChannelManager
- Fix web request pending: move stop logic outside lock, set daemon_threads=True
- Fix reconnect: new asyncio event loop per startup, ctypes thread interrupt,
  5s grace period before re-establishing remote connection
- Filter stale offline messages (>60s) pushed after reconnect

README.md

@@ -1,4 +1,4 @@
-<p align="center"><img src= "https://github.com/user-attachments/assets/31fb4eab-3be4-477d-aa76-82cf62bfd12c" alt="Chatgpt-on-Wechat" width="600" /></p>
+<p align="center"><img src= "https://github.com/user-attachments/assets/eca9a9ec-8534-4615-9e0f-96c5ac1d10a3" alt="Chatgpt-on-Wechat" width="550" /></p>
 
 <p align="center">
    <a href="https://github.com/zhayujie/chatgpt-on-wechat/releases/latest"><img src="https://img.shields.io/github/v/release/zhayujie/chatgpt-on-wechat" alt="Latest release"></a>
@@ -6,29 +6,33 @@
   <a href="https://github.com/zhayujie/chatgpt-on-wechat"><img src="https://img.shields.io/github/stars/zhayujie/chatgpt-on-wechat?style=flat-square" alt="Stars"></a> <br/>
 </p>
 
-**chatgpt-on-wechat**（简称CoW）项目是基于大模型的智能对话机器人，支持自由切换多种模型，可接入网页、微信公众号、企业微信应用、飞书、钉钉中使用，能处理文本、语音、图片、文件等多模态消息，支持通过插件访问操作系统和互联网等外部资源，以及基于自有知识库定制企业AI应用。
+**CowAgent** 是基于大模型的超级AI助理，能够主动思考和任务规划、操作计算机和外部资源、创造和执行Skills、拥有长期记忆并不断成长。CowAgent 支持灵活切换多种模型，能处理文本、语音、图片、文件等多模态消息，可接入网页、飞书、钉钉、企业微信应用、微信公众号中使用，7*24小时运行于你的个人电脑或服务器中。
+
+📖能力介绍：[CowAgent 2.0](/docs/agent.md)
 
 # 简介
 
-> 该项目既是一个可以开箱即用的对话机器人，也是一个支持高度扩展的AI应用框架，可以通过为项目添加大模型接口、接入渠道、自定义插件来灵活实现各种定制需求。支持的功能如下：
+> 该项目既是一个可以开箱即用的超级AI助理，也是一个支持高扩展的Agent框架，可以通过为项目扩展大模型接口、接入渠道、内置工具、Skills系统来灵活实现各种定制需求。核心能力如下：
 
--  ✅   **多端部署：** 有多种部署方式可选择且功能完备，目前已支持网页、微信公众号、企业微信应用、飞书、钉钉等部署方式
--  ✅   **基础对话：** 私聊及群聊的AI智能回复，支持多轮会话上下文记忆，基础模型支持OpenAI, Claude, Gemini, DeepSeek, 通义千问, Kimi, 文心一言, 讯飞星火, ChatGLM, MiniMax, GiteeAI, ModelScope, LinkAI
--  ✅   **语音能力：** 可识别语音消息，通过文字或语音回复，支持 openai(whisper/tts), azure, baidu, google 等多种语音模型
--  ✅   **图像能力：** 支持图片生成、图片识别、图生图，可选择 Dall-E-3, stable diffusion, replicate, midjourney, CogView-3, vision模型
--  ✅   **丰富插件：** 支持自定义插件扩展，已实现多角色切换、敏感词过滤、聊天记录总结、文档总结和对话、联网搜索、智能体等内置插件
--  ✅   **Agent能力：** 支持访问浏览器、终端、文件系统、搜索引擎等各类工具，并可通过多智能体协作完成复杂任务，基于 [AgentMesh](https://github.com/MinimalFuture/AgentMesh) 框架实现
--  ✅   **知识库：** 通过上传知识库自定义专属机器人，可作为数字分身、智能客服、企业智能体使用，基于 [LinkAI](https://link-ai.tech) 实现
+-  ✅  **复杂任务规划**：能够理解复杂任务并自主规划执行，持续思考和调用工具直到完成目标，支持通过工具操作访问文件、终端、浏览器、定时任务等系统资源
+-  ✅  **长期记忆：** 自动将对话记忆持久化至本地文件和数据库中，包括全局记忆和天级记忆，支持关键词及向量检索
+-  ✅  **技能系统：** 实现了Skills创建和运行的引擎，内置多种技能，并支持通过自然语言对话完成自定义Skills开发
+-  ✅  **多模态消息：** 支持对文本、图片、语音、文件等多类型消息进行解析、处理、生成、发送等操作
+-  ✅  **多模型接入：** 支持OpenAI, Claude, Gemini, DeepSeek, MiniMax、GLM、Qwen、Kimi、Doubao等国内外主流模型厂商
+-  ✅  **多端部署：** 支持运行在本地计算机或服务器，可集成到网页、飞书、钉钉、微信公众号、企业微信应用中使用
+-  ✅  **知识库：** 集成企业知识库能力，让Agent成为专属数字员工，基于[LinkAI](https://link-ai.tech)平台实现
 
 ## 声明
 
-1. 本项目遵循 [MIT开源协议](/LICENSE)，仅用于技术研究和学习，使用本项目时需遵守所在地法律法规、相关政策以及企业章程，禁止用于任何违法或侵犯他人权益的行为。任何个人、团队和企业，无论以何种方式使用该项目、对何对象提供服务，所产生的一切后果，本项目均不承担任何责任
-2. 境内使用该项目时，建议使用国内厂商的大模型服务，并进行必要的内容安全审核及过滤
-3. 本项目当前主要接入协同办公平台，推荐使用网页、公众号、企微自建应用、钉钉、飞书等接入通道，其他通道为历史产物暂不维护
+1. 本项目遵循 [MIT开源协议](/LICENSE)，主要用于技术研究和学习，使用本项目时需遵守所在地法律法规、相关政策以及企业章程，禁止用于任何违法或侵犯他人权益的行为。任何个人、团队和企业，无论以何种方式使用该项目、对何对象提供服务，所产生的一切后果，本项目均不承担任何责任。
+2. 成本与安全：Agent模式下Token使用量高于普通对话模式，请根据效果及成本综合选择模型。Agent具有访问所在操作系统的能力，请谨慎选择项目部署环境。同时项目也会持续升级安全机制、并降低模型消耗成本。
+3. CowAgent项目专注于开源技术开发，不会参与、授权或发行任何加密货币。
 
 ## 演示
 
-DEMO视频：https://cdn.link-ai.tech/doc/cow_demo.mp4
+使用说明(Agent模式)：[CowAgent介绍](/docs/agent.md)
+
+DEMO视频(对话模式)：https://cdn.link-ai.tech/doc/cow_demo.mp4
 
 ## 社区
 
@@ -54,7 +58,9 @@ DEMO视频：https://cdn.link-ai.tech/doc/cow_demo.mp4
 
 # 🏷 更新日志
 
->**2025.05.23：** [1.7.6版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/1.7.6) 优化web网页channel、新增 [AgentMesh多智能体插件](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/plugins/agent/README.md)、百度语音合成优化、企微应用`access_token`获取优化、支持`claude-4-sonnet`和`claude-4-opus`模型
+>**2026.02.03：** [2.0.0版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/2.0.0)，正式升级为超级Agent助理，支持多轮任务决策、具备长期记忆、实现多种系统工具、支持Skills框架，新增多种模型并优化了接入渠道。
+
+>**2025.05.23：** [1.7.6版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/1.7.6) 优化web网页channel、新增 [AgentMesh](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/plugins/agent/README.md)多智能体插件、百度语音合成优化、企微应用`access_token`获取优化、支持`claude-4-sonnet`和`claude-4-opus`模型
 
 >**2025.04.11：** [1.7.5版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/1.7.5) 新增支持 [wechatferry](https://github.com/zhayujie/chatgpt-on-wechat/pull/2562) 协议、新增 deepseek 模型、新增支持腾讯云语音能力、新增支持 ModelScope 和 Gitee-AI API接口
 
@@ -62,37 +68,38 @@ DEMO视频：https://cdn.link-ai.tech/doc/cow_demo.mp4
 
 >**2024.10.31：** [1.7.3版本](https://github.com/zhayujie/chatgpt-on-wechat/releases/tag/1.7.3) 程序稳定性提升、数据库功能、Claude模型优化、linkai插件优化、离线通知
 
-更多更新历史请查看: [更新日志](/docs/version/release-notes.md)
+更多更新历史请查看: [更新日志](/docs/release/history.md)
 
 <br/>
 
 # 🚀 快速开始
 
-项目提供了一键安装、启动、管理程序的脚本，可以选择使用脚本快速运行，也可以根据详细指引一步步安装运行。
+项目提供了一键安装、配置、启动、管理程序的脚本，推荐使用脚本快速运行，也可以根据下文中的详细指引一步步安装运行。
 
-- 详细文档：[快速开始](https://docs.link-ai.tech/cow/quick-start)
-
-- 一键安装脚本说明：[一键安装脚本](https://github.com/zhayujie/chatgpt-on-wechat/wiki/%E4%B8%80%E9%94%AE%E5%AE%89%E8%A3%85%E5%90%AF%E5%8A%A8%E8%84%9A%E6%9C%AC)
+在终端执行以下命令：
 
 ```bash
-bash <(curl -sS https://cdn.link-ai.tech/code/cow/install.sh)
+bash <(curl -sS https://cdn.link-ai.tech/code/cow/run.sh)
 ```
 
-- 项目管理脚本说明：[项目管理脚本](https://github.com/zhayujie/chatgpt-on-wechat/wiki/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E8%84%9A%E6%9C%AC)
+脚本使用说明：[一键运行脚本](https://github.com/zhayujie/chatgpt-on-wechat/wiki/CowAgentQuickStart)
+
 
 ## 一、准备
 
-### 1. 模型账号
+### 1. 模型API
 
-项目默认使用ChatGPT模型，需前往 [OpenAI平台](https://platform.openai.com/api-keys) 创建API Key并填入项目配置文件中。同时支持其他国内外产商以及第三方自定义模型接口，详情参考：[模型说明](#模型说明)。
+项目支持国内外主流厂商的模型接口，可选模型及配置说明参考：[模型说明](#模型说明)。
 
-同时支持使用 **LinkAI平台** 接口，可聚合使用 OpenAI、Claude、DeepSeek、Kimi、Qwen 等多种常用模型，并支持知识库、工作流、联网搜索、MJ绘图、文档总结等能力。修改配置即可一键启用，参考 [接入文档](https://link-ai.tech/platform/link-app/wechat)。
+> 注：Agent模式下推荐使用以下模型，可根据效果及成本综合选择：MiniMax-M2.5、glm-5、kimi-k2.5、qwen3.5-plus、claude-sonnet-4-6、gemini-3.1-pro-preview
+
+同时支持使用 **LinkAI平台** 接口，可灵活切换 OpenAI、Claude、Gemini、DeepSeek、Qwen、Kimi 等多种常用模型，并支持知识库、工作流、插件等Agent能力，参考 [接口文档](https://docs.link-ai.tech/platform/api)。
 
 ### 2.环境安装
 
-支持 Linux、MacOS、Windows 系统，同时需安装 `Python`，Python版本需要在3.7以上，推荐使用3.9版本。
+支持 Linux、MacOS、Windows 操作系统，可在个人计算机及服务器上运行，需安装 `Python`，Python版本需在3.7 ~ 3.12 之间，推荐使用3.9版本。
 
-> 注意：选择Docker部署则无需安装python环境和下载源码，可直接快进到下一节。
+> 注意：Agent模式推荐使用源码运行，若选择Docker部署则无需安装python环境和下载源码，可直接快进到下一节。
 
 **(1) 克隆项目代码：**
 
@@ -129,51 +136,37 @@ pip3 install -r requirements-optional.txt
 ```bash
 # config.json 文件内容示例
 {
-  "channel_type": "web",                                      # 接入渠道类型，默认为web，支持修改为:terminal, wechatmp, wechatmp_service, wechatcom_app, dingtalk, feishu
-  "model": "gpt-4o-mini",                                     # 模型名称, 支持 gpt-4o-mini, gpt-4.1, gpt-4o, deepseek-reasoner, wenxin, xunfei, glm-4, claude-3-7-sonnet-latest, moonshot等
-  "open_ai_api_key": "YOUR API KEY",                          # 如果使用openAI模型则填入上面创建的 OpenAI API KEY
-  "open_ai_api_base": "https://api.openai.com/v1",            # OpenAI接口代理地址，修改此项可接入第三方模型接口
-  "proxy": "",                                                # 代理客户端的ip和端口，国内环境开启代理的需要填写该项，如 "127.0.0.1:7890"
-  "single_chat_prefix": ["bot", "@bot"],                      # 私聊时文本需要包含该前缀才能触发机器人回复
-  "single_chat_reply_prefix": "[bot] ",                       # 私聊时自动回复的前缀，用于区分真人
-  "group_chat_prefix": ["@bot"],                              # 群聊时包含该前缀则会触发机器人回复
-  "group_name_white_list": ["ChatGPT测试群", "ChatGPT测试群2"], # 开启自动回复的群名称列表
-  "group_chat_in_one_session": ["ChatGPT测试群"],              # 支持会话上下文共享的群名称  
-  "image_create_prefix": ["画", "看", "找"],                   # 开启图片回复的前缀
-  "conversation_max_tokens": 1000,                            # 支持上下文记忆的最多字符数
+  "channel_type": "web",                                      # 接入渠道类型，默认为web，支持修改为:feishu,dingtalk,wechatcom_app,terminal,wechatmp,wechatmp_service
+  "model": "MiniMax-M2.5",                                    # 模型名称
+  "minimax_api_key": "",                                      # MiniMax API Key
+  "zhipu_ai_api_key": "",                                     # 智谱GLM API Key
+  "moonshot_api_key": "",                                     # Kimi/Moonshot API Key
+  "ark_api_key": "",                                          # 豆包(火山方舟) API Key
+  "dashscope_api_key": "",                                    # 百炼(通义千问)API Key
+  "claude_api_key": "",                                       # Claude API Key
+  "claude_api_base": "https://api.anthropic.com/v1",          # Claude API 地址，修改可接入三方代理平台
+  "gemini_api_key": "",                                       # Gemini API Key
+  "gemini_api_base": "https://generativelanguage.googleapis.com", # Gemini API地址
+  "open_ai_api_key": "",                                      # OpenAI API Key
+  "open_ai_api_base": "https://api.openai.com/v1",            # OpenAI API 地址
+  "linkai_api_key": "",                                       # LinkAI API Key
+  "proxy": "",                                                # 代理客户端的ip和端口，国内环境需要开启代理的可填写该项，如 "127.0.0.1:7890"
   "speech_recognition": false,                                # 是否开启语音识别
   "group_speech_recognition": false,                          # 是否开启群组语音识别
   "voice_reply_voice": false,                                 # 是否使用语音回复语音
-  "character_desc": "你是基于大语言模型的AI智能助手，旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。",  # 系统提示词
-  # 订阅欢迎语，公众号和企业微信channel中使用，当被订阅时会自动回复以下内容
-  "subscribe_msg": "感谢您的关注！\n这里是AI智能助手，可以自由对话。\n支持语音对话。\n支持图片输入。\n支持图片输出，画字开头的消息将按要求创作图片。\n支持tool、角色扮演和文字冒险等丰富的插件。\n输入{trigger_prefix}#help 查看详细指令。",
-  "use_linkai": false,                                        # 是否使用LinkAI接口，默认关闭，设置为true后可对接LinkAI平台的智能体
-  "linkai_api_key": "",                                       # LinkAI Api Key
-  "linkai_app_code": ""                                       # LinkAI 应用或工作流的code
+  "use_linkai": false,                                        # 是否使用LinkAI接口，默认关闭，设置为true后可对接LinkAI平台接口
+  "agent": true,                                              # 是否启用Agent模式，启用后拥有多轮工具决策、长期记忆、Skills能力等
+  "agent_workspace": "~/cow",                                 # Agent的工作空间路径，用于存储memory、skills、系统设定等
+  "agent_max_context_tokens": 40000,                          # Agent模式下最大上下文tokens，超出将自动丢弃最早的上下文
+  "agent_max_context_turns": 30,                              # Agent模式下最大上下文记忆轮次，每轮包括一次用户提问和AI回复
+  "agent_max_steps": 15                                       # Agent模式下单次任务的最大决策步数，超出后将停止继续调用工具
 }
 ```
 
-**详细配置说明:** 
+**配置补充说明:** 
 
 <details>
-<summary>1. 单聊配置</summary>
-
-+ 个人聊天中，需要以 "bot"或"@bot" 为开头的内容触发机器人，对应配置项 `single_chat_prefix` (如果不需要以前缀触发可以填写  `"single_chat_prefix": [""]`)
-+ 机器人回复的内容会以 "[bot] " 作为前缀， 以区分真人，对应的配置项为 `single_chat_reply_prefix` (如果不需要前缀可以填写 `"single_chat_reply_prefix": ""`)
-</details>
-
-
-<details>
-<summary>2. 群聊配置</summary>
-
-+ 群组聊天中，群名称需配置在 `group_name_white_list ` 中才能开启群聊自动回复。如果想对所有群聊生效，可以直接填写 `"group_name_white_list": ["ALL_GROUP"]`
-+ 默认只要被人 @ 就会触发机器人自动回复；另外群聊天中只要检测到以 "@bot" 开头的内容，同样会自动回复（方便自己触发），这对应配置项 `group_chat_prefix`
-+ 可选配置: `group_name_keyword_white_list`配置项支持模糊匹配群名称，`group_chat_keyword`配置项则支持模糊匹配群消息内容，用法与上述两个配置项相同。（Contributed by [evolay](https://github.com/evolay))
-+ `group_chat_in_one_session`：使群聊共享一个会话上下文，配置 `["ALL_GROUP"]` 则作用于所有群聊
-</details>
-
-<details>
-<summary>3. 语音配置</summary>
+<summary>1. 语音配置</summary>
 
 + 添加 `"speech_recognition": true` 将开启语音识别，默认使用openai的whisper模型识别为文字，同时以文字回复，该参数仅支持私聊 (注意由于语音消息无法匹配前缀，一旦开启将对所有语音自动回复，支持语音触发画图)；
 + 添加 `"group_speech_recognition": true` 将开启群组语音识别，默认使用openai的whisper模型识别为文字，同时以文字回复，参数仅支持群聊 (会匹配group_chat_prefix和group_chat_keyword, 支持语音触发画图)；
@@ -181,30 +174,22 @@ pip3 install -r requirements-optional.txt
 </details>
 
 <details>
-<summary>4. 其他配置</summary>
+<summary>2. 其他配置</summary>
 
-+ `model`: 模型名称，目前支持 `gpt-4o-mini`, `gpt-4.1`, `gpt-4o`, `gpt-3.5-turbo`, `wenxin` , `claude` , `gemini`, `glm-4`,  `xunfei`, `moonshot`等，全部模型名称参考[common/const.py](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/common/const.py)文件
-+ `temperature`,`frequency_penalty`,`presence_penalty`: Chat API接口参数，详情参考[OpenAI官方文档。](https://platform.openai.com/docs/api-reference/chat)
-+ `proxy`：由于目前 `openai` 接口国内无法访问，需配置代理客户端的地址，详情参考  [#351](https://github.com/zhayujie/chatgpt-on-wechat/issues/351)
-+ 对于图像生成，在满足个人或群组触发条件外，还需要额外的关键词前缀来触发，对应配置 `image_create_prefix `
-+ 关于OpenAI对话及图片接口的参数配置（内容自由度、回复字数限制、图片大小等），可以参考 [对话接口](https://beta.openai.com/docs/api-reference/completions) 和 [图像接口](https://beta.openai.com/docs/api-reference/completions)  文档，在[`config.py`](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/config.py)中检查哪些参数在本项目中是可配置的。
-+ `conversation_max_tokens`：表示能够记忆的上下文最大字数（一问一答为一组对话，如果累积的对话字数超出限制，就会优先移除最早的一组对话）
-+ `rate_limit_chatgpt`，`rate_limit_dalle`：每分钟最高问答速率、画图速率，超速后排队按序处理。
-+ `clear_memory_commands`: 对话内指令，主动清空前文记忆，字符串数组可自定义指令别名。
-+ `hot_reload`: 程序退出后，暂存等于状态，默认关闭。
-+ `character_desc` 配置中保存着你对机器人说的一段话，他会记住这段话并作为他的设定，你可以为他定制任何人格      (关于会话上下文的更多内容参考该 [issue](https://github.com/zhayujie/chatgpt-on-wechat/issues/43))
++ `model`: 模型名称，Agent模式下推荐使用 `MiniMax-M2.5`、`glm-5`、`kimi-k2.5`、`qwen3.5-plus`、`claude-sonnet-4-6`、`gemini-3.1-pro-preview`，全部模型名称参考[common/const.py](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/common/const.py)文件
++ `character_desc`：普通对话模式下的机器人系统提示词。在Agent模式下该配置不生效，由工作空间中的文件内容构成。
 + `subscribe_msg`：订阅消息，公众号和企业微信channel中请填写，当被订阅时会自动回复， 可使用特殊占位符。目前支持的占位符有{trigger_prefix}，在程序中它会自动替换成bot的触发词。
 </details>
 
 <details>
-<summary>5. LinkAI配置</summary>
+<summary>3. LinkAI配置</summary>
 
-+ `use_linkai`: 是否使用LinkAI接口，默认关闭，设置为true后可对接LinkAI平台的Agent，使用知识库、工作流、联网搜索、`Midjourney` 绘画等能力, 参考 [文档](https://link-ai.tech/platform/link-app/wechat)
++ `use_linkai`: 是否使用LinkAI接口，默认关闭，设置为true后可对接LinkAI平台，使用知识库、工作流、插件等能力, 参考[接口文档](https://docs.link-ai.tech/platform/api/chat)
 + `linkai_api_key`: LinkAI Api Key，可在 [控制台](https://link-ai.tech/console/interface) 创建
-+ `linkai_app_code`: LinkAI 应用或工作流的code，选填
++ `linkai_app_code`: LinkAI 应用或工作流的code，选填，普通对话模式中使用。
 </details>
 
-注：完整配置项说明可在 [`config.py`](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/config.py) 文件中查看。
+注：全部配置项说明可在 [`config.py`](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/config.py) 文件中查看。
 
 ## 三、运行
 
@@ -216,9 +201,10 @@ pip3 install -r requirements-optional.txt
 python3 app.py         # windows环境下该命令通常为 python app.py
 ```
 
-运行后默认会启动一个web服务，可以通过访问 `http://localhost:9899/chat` 在网页端对话。如果需要接入其他应用通道只需修改 `config.json` 配置文件中的 `channel_type` 参数，详情参考：[通道说明](#通道说明)。
+运行后默认会启动web服务，可通过访问 `http://localhost:9899/chat` 在网页端对话。
+
+如果需要接入其他应用通道只需修改 `config.json` 配置文件中的 `channel_type` 参数，详情参考：[通道说明](#通道说明)。
 
-向机器人发送 `#help` 消息可以查看可用指令及插件的说明。
 
 ### 2.服务器部署
 
@@ -235,7 +221,7 @@ nohup python3 app.py & tail -f nohup.out
 
 ### 3.Docker部署
 
-使用docker部署无需下载源码和安装依赖，只需要获取 `docker-compose.yml` 配置文件并启动容器即可。
+使用docker部署无需下载源码和安装依赖，只需要获取 `docker-compose.yml` 配置文件并启动容器即可。Agent模式下更推荐使用源码进行部署，以获得更多系统访问能力。
 
 > 前提是需要安装好 `docker` 及 `docker-compose`，安装成功后执行 `docker -v` 和 `docker-compose version` (或 `docker compose version`) 可查看到版本号。安装地址为 [docker官网](https://docs.docker.com/engine/install/) 。
 
@@ -275,8 +261,7 @@ volumes:
 
 ## 模型说明
 
-以下对所有可支持的模型的配置和使用方法进行说明，模型接口实现在项目的 `bot/` 目录下。
->部分模型厂商接入有官方sdk和OpenAI兼容两种方式，建议使用OpenAI兼容的方式。
+以下对所有可支持的模型的配置和使用方法进行说明，模型接口实现在项目的 `models/` 目录下。
 
 <details>
 <summary>OpenAI</summary>
@@ -294,7 +279,7 @@ volumes:
 }
 ```
 
- - `model`: 与OpenAI接口的 [model参数](https://platform.openai.com/docs/models) 一致，支持包括 o系列、gpt-4系列、gpt-3.5系列等模型
+ - `model`: 与OpenAI接口的 [model参数](https://platform.openai.com/docs/models) 一致，支持包括 o系列、gpt-5.2、gpt-5.1、gpt-4.1等系列模型
  - `open_ai_api_base`: 如果需要接入第三方代理接口，可通过修改该参数进行接入
  - `bot_type`: 使用OpenAI相关模型时无需填写。当使用第三方代理接口接入Claude等非OpenAI官方模型时，该参数设为 `chatGPT`
 </details>
@@ -308,18 +293,181 @@ volumes:
 
 ```json
 {
- "use_linkai": true,
- "linkai_api_key": "YOUR API KEY",
- "linkai_app_code": "YOUR APP CODE"
+    "use_linkai": true,
+    "linkai_api_key": "YOUR API KEY",
+    "linkai_app_code": "YOUR APP CODE"
 }
 ```
 
-+ `use_linkai`: 是否使用LinkAI接口，默认关闭，设置为true后可对接LinkAI平台的智能体，使用知识库、工作流、数据库、联网搜索、MCP工具等丰富的Agent能力, 参考 [文档](https://link-ai.tech/platform/link-app/wechat)
++ `use_linkai`: 是否使用LinkAI接口，默认关闭，设置为true后可对接LinkAI平台的智能体，使用知识库、工作流、数据库、MCP插件等丰富的Agent能力
 + `linkai_api_key`: LinkAI平台的API Key，可在 [控制台](https://link-ai.tech/console/interface) 中创建
-+ `linkai_app_code`: LinkAI智能体 (应用或工作流) 的code，选填。智能体创建可参考 [说明文档](https://docs.link-ai.tech/platform/quick-start)
++ `linkai_app_code`: LinkAI智能体 (应用或工作流) 的code，选填，普通对话模式可用。智能体创建可参考 [说明文档](https://docs.link-ai.tech/platform/quick-start)
 + `model`: model字段填写空则直接使用智能体的模型，可在平台中灵活切换，[模型列表](https://link-ai.tech/console/models)中的全部模型均可使用
 </details>
 
+<details>
+<summary>MiniMax</summary>
+
+方式一：官方接入，配置如下(推荐)：
+
+```json
+{
+    "model": "MiniMax-M2.5",
+    "minimax_api_key": ""
+}
+```
+ - `model`: 可填写 `MiniMax-M2.5、MiniMax-M2.1、MiniMax-M2.1-lightning、MiniMax-M2、abab6.5-chat` 等
+ - `minimax_api_key`：MiniMax平台的API-KEY，在 [控制台](https://platform.minimaxi.com/user-center/basic-information/interface-key) 创建
+
+方式二：OpenAI兼容方式接入，配置如下：
+```json
+{
+  "bot_type": "chatGPT",
+  "model": "MiniMax-M2.5",
+  "open_ai_api_base": "https://api.minimaxi.com/v1",
+  "open_ai_api_key": ""
+}
+```
+- `bot_type`: OpenAI兼容方式
+- `model`: 可填 `MiniMax-M2.5、MiniMax-M2.1、MiniMax-M2.1-lightning、MiniMax-M2`，参考[API文档](https://platform.minimaxi.com/document/%E5%AF%B9%E8%AF%9D?key=66701d281d57f38758d581d0#QklxsNSbaf6kM4j6wjO5eEek)
+- `open_ai_api_base`: MiniMax平台API的 BASE URL
+- `open_ai_api_key`: MiniMax平台的API-KEY
+</details>
+
+<details>
+<summary>智谱AI (GLM)</summary>
+
+方式一：官方接入，配置如下(推荐)：
+
+```json
+{
+  "model": "glm-5",
+  "zhipu_ai_api_key": ""
+}
+```
+ - `model`: 可填 `glm-5、glm-4.7、glm-4-plus、glm-4-flash、glm-4-air、glm-4-airx、glm-4-long` 等, 参考 [glm系列模型编码](https://bigmodel.cn/dev/api/normal-model/glm-4)
+ - `zhipu_ai_api_key`: 智谱AI平台的 API KEY，在 [控制台](https://www.bigmodel.cn/usercenter/proj-mgmt/apikeys) 创建
+
+方式二：OpenAI兼容方式接入，配置如下：
+```json
+{
+  "bot_type": "chatGPT",
+  "model": "glm-5",
+  "open_ai_api_base": "https://open.bigmodel.cn/api/paas/v4",
+  "open_ai_api_key": ""
+}
+```
+- `bot_type`: OpenAI兼容方式
+- `model`: 可填 `glm-5、glm-4.7、glm-4-plus、glm-4-flash、glm-4-air、glm-4-airx、glm-4-long` 等
+- `open_ai_api_base`: 智谱AI平台的 BASE URL
+- `open_ai_api_key`: 智谱AI平台的 API KEY
+</details>
+
+<details>
+<summary>通义千问 (Qwen)</summary>
+
+方式一：官方SDK接入，配置如下(推荐)：
+
+```json
+{
+    "model": "qwen3.5-plus",
+    "dashscope_api_key": "sk-qVxxxxG"
+}
+```
+ - `model`: 可填写 `qwen3.5-plus、qwen3-max、qwen-max、qwen-plus、qwen-turbo、qwen-long、qwq-plus` 等
+ - `dashscope_api_key`: 通义千问的 API-KEY，参考 [官方文档](https://bailian.console.aliyun.com/?tab=api#/api) ，在 [控制台](https://bailian.console.aliyun.com/?tab=model#/api-key) 创建
+
+方式二：OpenAI兼容方式接入，配置如下：
+```json
+{
+  "bot_type": "chatGPT",
+  "model": "qwen3.5-plus",
+  "open_ai_api_base": "https://dashscope.aliyuncs.com/compatible-mode/v1",
+  "open_ai_api_key": "sk-qVxxxxG"
+}
+```
+- `bot_type`: OpenAI兼容方式
+- `model`: 支持官方所有模型，参考[模型列表](https://help.aliyun.com/zh/model-studio/models?spm=a2c4g.11186623.0.0.78d84823Kth5on#9f8890ce29g5u)
+- `open_ai_api_base`: 通义千问API的 BASE URL
+- `open_ai_api_key`: 通义千问的 API-KEY
+</details>
+
+<details>
+<summary>Kimi (Moonshot)</summary>
+
+方式一：官方接入，配置如下：
+
+```json
+{
+    "model": "kimi-k2.5",
+    "moonshot_api_key": ""
+}
+```
+ - `model`: 可填写 `kimi-k2.5、kimi-k2、moonshot-v1-8k、moonshot-v1-32k、moonshot-v1-128k`
+ - `moonshot_api_key`: Moonshot的API-KEY，在 [控制台](https://platform.moonshot.cn/console/api-keys) 创建
+ 
+方式二：OpenAI兼容方式接入，配置如下：
+```json
+{
+  "bot_type": "chatGPT",
+  "model": "kimi-k2.5",
+  "open_ai_api_base": "https://api.moonshot.cn/v1",
+  "open_ai_api_key": ""
+}
+```
+- `bot_type`: OpenAI兼容方式
+- `model`: 可填写 `kimi-k2.5、kimi-k2、moonshot-v1-8k、moonshot-v1-32k、moonshot-v1-128k`
+- `open_ai_api_base`: Moonshot的 BASE URL
+- `open_ai_api_key`: Moonshot的 API-KEY
+</details>
+
+<details>
+<summary>豆包 (Doubao)</summary>
+
+1. API Key创建：在 [火山方舟控制台](https://console.volcengine.com/ark/region:ark+cn-beijing/apikey) 创建API Key
+
+2. 填写配置
+
+```json
+{
+    "model": "doubao-seed-2-0-code-preview-260215",
+    "ark_api_key": "YOUR_API_KEY"
+}
+```
+ - `model`: 可填写 `doubao-seed-2-0-code-preview-260215、doubao-seed-2-0-pro-260215、doubao-seed-2-0-lite-260215、doubao-seed-2-0-mini-260215` 等
+ - `ark_api_key`: 火山方舟平台的 API Key，在 [控制台](https://console.volcengine.com/ark/region:ark+cn-beijing/apikey) 创建
+ - `ark_base_url`: 可选，默认为 `https://ark.cn-beijing.volces.com/api/v3`
+</details>
+
+<details>
+<summary>Claude</summary>
+
+1. API Key创建：在 [Claude控制台](https://console.anthropic.com/settings/keys) 创建API Key
+
+2. 填写配置
+
+```json
+{
+    "model": "claude-sonnet-4-6",
+    "claude_api_key": "YOUR_API_KEY"
+}
+```
+ - `model`: 参考 [官方模型ID](https://docs.anthropic.com/en/docs/about-claude/models/overview#model-aliases) ，支持 `claude-sonnet-4-6、claude-opus-4-6、claude-sonnet-4-5、claude-sonnet-4-0、claude-opus-4-0、claude-3-5-sonnet-latest` 等
+</details>
+
+<details>
+<summary>Gemini</summary>
+
+API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn) 创建API Key ，配置如下
+```json
+{
+    "model": "gemini-3.1-pro-preview",
+    "gemini_api_key": ""
+}
+```
+ - `model`: 参考[官方文档-模型列表](https://ai.google.dev/gemini-api/docs/models?hl=zh-cn)，支持 `gemini-3.1-pro-preview、gemini-3-flash-preview、gemini-3-pro-preview、gemini-2.5-pro、gemini-2.0-flash` 等
+</details>
+
 <details>
 <summary>DeepSeek</summary>
 
@@ -329,15 +477,16 @@ volumes:
 
 ```json
 {
-  "bot_type": "chatGPT",
-  "model": "deepseek-chat",
-  "open_ai_api_key": "sk-xxxxxxxxxxx",
-  "open_ai_api_base": "https://api.deepseek.com/v1"
+    "model": "deepseek-chat",
+    "open_ai_api_key": "sk-xxxxxxxxxxx",
+    "open_ai_api_base": "https://api.deepseek.com/v1", 
+    "bot_type": "chatGPT"
+
 }
 ```
 
  - `bot_type`: OpenAI兼容方式
- - `model`: 可填 `deepseek-chat、deepseek-reasoner`，分别对应的是 V3 和 R1 模型
+ - `model`: 可填 `deepseek-chat、deepseek-reasoner`，分别对应的是 DeepSeek-V3 和 DeepSeek-R1 模型
  - `open_ai_api_key`: DeepSeek平台的 API Key
  - `open_ai_api_base`: DeepSeek平台 BASE URL
 </details>
@@ -345,7 +494,7 @@ volumes:
 <details>
 <summary>Azure</summary>
 
-1. API Key创建：在 [DeepSeek平台](https://platform.deepseek.com/api_keys) 创建API Key 
+1. API Key创建：在 [Azure平台](https://oai.azure.com/) 创建API Key 
 
 2. 填写配置
 
@@ -353,9 +502,9 @@ volumes:
 {
   "model": "",
   "use_azure_chatgpt": true,
-  "open_ai_api_key": "e7ffc5dd84f14521a53f14a40231ea78",
-  "open_ai_api_base": "https://linkai-240917.openai.azure.com/",
-  "azure_deployment_id": "gpt-4.1",
+  "open_ai_api_key": "",
+  "open_ai_api_base": "",
+  "azure_deployment_id": "",
   "azure_api_version": "2025-01-01-preview"
 }
 ```
@@ -368,100 +517,13 @@ volumes:
  - `azure_api_version`: api版本以及以上参数可以在部署的 [模型配置](https://oai.azure.com/resource/deployments) 界面查看
 </details>
 
-<details>
-<summary>Claude</summary>
-
-1. API Key创建：在 [Claude控制台](https://console.anthropic.com/settings/keys) 创建API Key
-
-2. 填写配置
-
-```json
-{
-    "model": "claude-sonnet-4-0",
-    "claude_api_key": "YOUR_API_KEY"
-}
-```
- - `model`: 参考 [官方模型ID](https://docs.anthropic.com/en/docs/about-claude/models/overview#model-aliases) ，例如`claude-opus-4-0`、`claude-3-7-sonnet-latest`等
-</details>
-
-<details>
-<summary>通义千问</summary>
-
-方式一：官方SDK接入，配置如下：
-
-```json
-{
-    "model": "qwen-turbo",
-    "dashscope_api_key": "sk-qVxxxxG"
-}
-```
- - `model`: 可填写`qwen-turbo、qwen-plus、qwen-max`
- - `dashscope_api_key`: 通义千问的 API-KEY，参考 [官方文档](https://bailian.console.aliyun.com/?tab=api#/api) ，在 [控制台](https://bailian.console.aliyun.com/?tab=model#/api-key) 创建
- 
-方式二：OpenAI兼容方式接入，配置如下：
-```json
-{
-  "bot_type": "chatGPT",
-  "model": "qwen-turbo",
-  "open_ai_api_base": "https://dashscope.aliyuncs.com/compatible-mode/v1",
-  "open_ai_api_key": "sk-qVxxxxG"
-}
-```
-- `bot_type`: OpenAI兼容方式
-- `model`: 支持官方所有模型，参考[模型列表](https://help.aliyun.com/zh/model-studio/models?spm=a2c4g.11186623.0.0.78d84823Kth5on#9f8890ce29g5u)
-- `open_ai_api_base`: 通义千问API的 BASE URL
-- `open_ai_api_key`: 通义千问的 API-KEY，参考 [官方文档](https://bailian.console.aliyun.com/?tab=api#/api) ，在 [控制台](https://bailian.console.aliyun.com/?tab=model#/api-key) 创建
-</details>
-
-<details>
-<summary>Gemini</summary>
-
-API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn) 创建API Key ，配置如下
-```json
-{
-    "model": "gemini-2.5-pro",
-    "gemini_api_key": ""
-}
-```
- - `model`: 参考[官方文档-模型列表](https://ai.google.dev/gemini-api/docs/models?hl=zh-cn)
-</details>
-
-<details>
-<summary>Moonshot</summary>
-
-方式一：官方接入，配置如下：
-
-```json
-{
-    "model": "moonshot-v1-8k",
-    "moonshot_api_key": "moonshot-v1-8k"
-}
-```
- - `model`: 可填写`moonshot-v1-8k、 moonshot-v1-32k、 moonshot-v1-128k`
- - `moonshot_api_key`: Moonshot的API-KEY，在 [控制台](https://platform.moonshot.cn/console/api-keys) 创建
- 
-方式二：OpenAI兼容方式接入，配置如下：
-```json
-{
-  "bot_type": "chatGPT",
-  "model": "moonshot-v1-8k",
-  "open_ai_api_base": "https://api.moonshot.cn/v1",
-  "open_ai_api_key": ""
-}
-```
-- `bot_type`: OpenAI兼容方式
-- `model`: 可填写`moonshot-v1-8k、 moonshot-v1-32k、 moonshot-v1-128k`
-- `open_ai_api_base`: Moonshot的 BASE URL
-- `open_ai_api_key`: Moonshot的 API-KEY，在 [控制台](https://platform.moonshot.cn/console/api-keys) 创建
-</details>
-
 <details>
 <summary>百度文心</summary>
 方式一：官方SDK接入，配置如下：
 
 ```json
 {
-    "model": "wenxin", 
+    "model": "wenxin-4", 
     "baidu_wenxin_api_key": "IajztZ0bDxgnP9bEykU7lBer",
     "baidu_wenxin_secret_key": "EDPZn6L24uAS9d8RWFfotK47dPvkjD6G"
 }
@@ -474,7 +536,7 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
 ```json
 {
   "bot_type": "chatGPT",
-  "model": "qwen-turbo",
+  "model": "ERNIE-4.0-Turbo-8K",
   "open_ai_api_base": "https://qianfan.baidubce.com/v2",
   "open_ai_api_key": "bce-v3/ALTxxxxxxd2b"
 }
@@ -503,7 +565,7 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
 }
 ```
  - `model`: 填 `xunfei`
- - `xunfei_domain`: 可填写 `4.0Ultra、 generalv3.5、 max-32k、 generalv3、 pro-128k、 lite`
+ - `xunfei_domain`: 可填写 `4.0Ultra、generalv3.5、max-32k、generalv3、pro-128k、lite`
  - `xunfei_spark_url`: 填写参考 [官方文档-请求地址](https://www.xfyun.cn/doc/spark/Web.html#_1-1-%E8%AF%B7%E6%B1%82%E5%9C%B0%E5%9D%80) 的说明
  
 方式二：OpenAI兼容方式接入，配置如下：
@@ -516,71 +578,11 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
 }
 ```
 - `bot_type`: OpenAI兼容方式
-- `model`: 可填写 `4.0Ultra、 generalv3.5、 max-32k、 generalv3、 pro-128k、 lite`
+- `model`: 可填写 `4.0Ultra、generalv3.5、max-32k、generalv3、pro-128k、lite`
 - `open_ai_api_base`: 讯飞星火平台的 BASE URL
 - `open_ai_api_key`: 讯飞星火平台的[APIPassword](https://console.xfyun.cn/services/bm3) ，因模型而已
 </details>
 
-<details>
-<summary>智谱AI</summary>
-
-方式一：官方接入，配置如下：
-
-```json
-{
-  "model": "glm-4-plus",
-  "zhipu_ai_api_key": ""
-}
-```
- - `model`: 可填 `glm-4-plus、glm-4-air-250414、glm-4-airx、glm-4-long 、glm-4-flashx 、glm-4-flash-250414`, 参考 [glm-4系列模型编码](https://bigmodel.cn/dev/api/normal-model/glm-4)
- - `zhipu_ai_api_key`: 智谱AI平台的 API KEY，在 [控制台](https://www.bigmodel.cn/usercenter/proj-mgmt/apikeys) 创建
- 
-方式二：OpenAI兼容方式接入，配置如下：
-```json
-{
-  "bot_type": "chatGPT",
-  "model": "glm-4-plus",
-  "open_ai_api_base": "https://open.bigmodel.cn/api/paas/v4",
-  "open_ai_api_key": ""
-}
-```
-- `bot_type`: OpenAI兼容方式
-- `model`: 可填 `glm-4-plus、glm-4-air-250414、glm-4-airx、glm-4-long 、glm-4-flashx 、glm-4-flash-250414`, 参考 [glm-4系列模型编码](https://bigmodel.cn/dev/api/normal-model/glm-4) 
-- `open_ai_api_base`: 智谱AI平台的 BASE URL
-- `open_ai_api_key`: 智谱AI平台的 API KEY，在 [控制台](https://www.bigmodel.cn/usercenter/proj-mgmt/apikeys) 创建
-</details>
-
-<details>
-<summary>MiniMax</summary>
-
-方式一：官方接入，配置如下：
-
-```json
-{
-    "model": "abab6.5-chat",
-    "Minimax_api_key": "",
-    "Minimax_group_id": ""
-}
-```
- - `model`: 可填写`abab6.5-chat`
- - `Minimax_api_key`：MiniMax平台的API-KEY，在 [控制台](https://platform.minimaxi.com/user-center/basic-information/interface-key) 创建
- - `Minimax_group_id`: 在 [账户信息](https://platform.minimaxi.com/user-center/basic-information) 右上角获取
- 
-方式二：OpenAI兼容方式接入，配置如下：
-```json
-{
-  "bot_type": "chatGPT",
-  "model": "MiniMax-M1",
-  "open_ai_api_base": "https://api.minimaxi.com/v1",
-  "open_ai_api_key": ""
-}
-```
-- `bot_type`: OpenAI兼容方式
-- `model`: 可填`MiniMax-M1、MiniMax-Text-01`，参考[API文档](https://platform.minimaxi.com/document/%E5%AF%B9%E8%AF%9D?key=66701d281d57f38758d581d0#QklxsNSbaf6kM4j6wjO5eEek)
-- `open_ai_api_base`: MiniMax平台API的 BASE URL
-- `open_ai_api_key`: MiniMax平台的API-KEY，在 [控制台](https://platform.minimaxi.com/user-center/basic-information/interface-key) 创建
-</details>
-
 <details>
 <summary>ModelScope</summary>
 
@@ -606,10 +608,12 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
 
 以下对可接入通道的配置方式进行说明，应用通道代码在项目的 `channel/` 目录下。
 
-<details>
-<summary>Web</summary>
+支持同时可接入多个通道，配置时可通过逗号进行分割，例如 `"channel_type": "feishu,dingtalk"`。
 
-项目启动后默认运行web通道，配置如下：
+<details>
+<summary>1. Web</summary>
+
+项目启动后会默认运行Web控制台，配置如下：
 
 ```json
 {
@@ -617,49 +621,65 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
     "web_port": 9899
 }
 ```
+
 - `web_port`: 默认为 9899，可按需更改，需要服务器防火墙和安全组放行该端口
-- 如本地运行，启动后请访问 `http://localhost:port/chat` ；如服务器运行，请访问 `http://ip:port/chat` 
+- 如本地运行，启动后请访问 `http://localhost:9899/chat` ；如服务器运行，请访问 `http://ip:9899/chat` 
 > 注：请将上述 url 中的 ip 或者 port 替换为实际的值
 </details>
 
 <details>
-<summary>Terminal</summary>
+<summary>2. Feishu - 飞书</summary>
 
-修改 `config.json` 中的 `channel_type` 字段：
+飞书支持两种事件接收模式：WebSocket 长连接（推荐）和 Webhook。
+
+**方式一：WebSocket 模式（推荐，无需公网 IP）**
 
 ```json
 {
-    "channel_type": "terminal"
+    "channel_type": "feishu",
+    "feishu_app_id": "APP_ID",
+    "feishu_app_secret": "APP_SECRET",
+    "feishu_event_mode": "websocket"
 }
 ```
 
-运行后可在终端与机器人进行对话。
+**方式二：Webhook 模式（需要公网 IP）**
+
+```json
+{
+    "channel_type": "feishu",
+    "feishu_app_id": "APP_ID",
+    "feishu_app_secret": "APP_SECRET",
+    "feishu_token": "VERIFICATION_TOKEN",
+    "feishu_event_mode": "webhook",
+    "feishu_port": 9891
+}
+```
+
+- `feishu_event_mode`: 事件接收模式，`websocket`（推荐）或 `webhook`
+- WebSocket 模式需安装依赖：`pip3 install lark-oapi`
+
+详细步骤和参数说明参考 [飞书接入](https://docs.link-ai.tech/cow/multi-platform/feishu)
 
 </details>
 
 <details>
-<summary>微信公众号</summary>
+<summary>3. DingTalk - 钉钉</summary>
 
-本项目支持订阅号和服务号两种公众号，通过服务号(`wechatmp_service`)体验更佳。将下列配置加入 `config.json`：
+钉钉需要在开放平台创建智能机器人应用，将以下配置填入 `config.json`：
 
 ```json
 {
-    "channel_type": "wechatmp",
-    "wechatmp_token": "TOKEN",
-    "wechatmp_port": 80,
-    "wechatmp_app_id": "APPID",
-    "wechatmp_app_secret": "APPSECRET",
-    "wechatmp_aes_key": ""
+    "channel_type": "dingtalk",
+    "dingtalk_client_id": "CLIENT_ID",
+    "dingtalk_client_secret": "CLIENT_SECRET"
 }
 ```
-- `channel_type`: 个人订阅号为`wechatmp`，企业服务号为`wechatmp_service`
-
-详细步骤和参数说明参考 [微信公众号接入](https://docs.link-ai.tech/cow/multi-platform/wechat-mp)
-
+详细步骤和参数说明参考 [钉钉接入](https://docs.link-ai.tech/cow/multi-platform/dingtalk)
 </details>
 
 <details>
-<summary>企业微信应用</summary>
+<summary>4. WeCom App - 企业微信应用</summary>
 
 企业微信自建应用接入需在后台创建应用并启用消息回调，配置示例：
 
@@ -679,35 +699,53 @@ API Key创建：在 [控制台](https://aistudio.google.com/app/apikey?hl=zh-cn)
 </details>
 
 <details>
-<summary>钉钉</summary>
+<summary>5. WeChat MP - 微信公众号</summary>
 
-钉钉需要在开放平台创建智能机器人应用，将以下配置填入 `config.json`：
+本项目支持订阅号和服务号两种公众号，通过服务号（`wechatmp_service`）体验更佳。
+
+**个人订阅号（wechatmp）**
 
 ```json
 {
-    "channel_type": "dingtalk",
-    "dingtalk_client_id": "CLIENT_ID",
-    "dingtalk_client_secret": "CLIENT_SECRET"
+    "channel_type": "wechatmp",
+    "wechatmp_token": "TOKEN",
+    "wechatmp_port": 80,
+    "wechatmp_app_id": "APPID",
+    "wechatmp_app_secret": "APPSECRET",
+    "wechatmp_aes_key": ""
 }
 ```
-详细步骤和参数说明参考 [钉钉接入](https://docs.link-ai.tech/cow/multi-platform/dingtalk)
+
+**企业服务号（wechatmp_service）**
+
+```json
+{
+    "channel_type": "wechatmp_service",
+    "wechatmp_token": "TOKEN",
+    "wechatmp_port": 80,
+    "wechatmp_app_id": "APPID",
+    "wechatmp_app_secret": "APPSECRET",
+    "wechatmp_aes_key": ""
+}
+```
+
+详细步骤和参数说明参考 [微信公众号接入](https://docs.link-ai.tech/cow/multi-platform/wechat-mp)
+
 </details>
 
 <details>
-<summary>飞书</summary>
+<summary>6. Terminal - 终端</summary>
 
-通过自建应用接入AI相关能力到飞书应用中，默认已是飞书的企业用户，且具有企业管理权限，将以下配置填入 `config.json`：：
+修改 `config.json` 中的 `channel_type` 字段：
 
 ```json
 {
-    "channel_type": "feishu",
-    "feishu_app_id": "APP_ID",
-    "feishu_app_secret": "APP_SECRET",
-    "feishu_token": "VERIFICATION_TOKEN",
-    "feishu_port": 80
+    "channel_type": "terminal"
 }
 ```
-详细步骤和参数说明参考 [飞书接入](https://docs.link-ai.tech/cow/multi-platform/feishu)
+
+运行后可在终端与机器人进行对话。
+
 </details>
 
 <br/>
@@ -727,7 +765,7 @@ FAQs： <https://github.com/zhayujie/chatgpt-on-wechat/wiki/FAQs>
 
 # 🛠️ 开发
 
-欢迎接入更多应用通道，参考 [Terminal代码](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/terminal/terminal_channel.py) 新增自定义通道，实现接收和发送消息逻辑即可完成接入。 同时欢迎贡献新的插件，参考 [插件开发文档](https://github.com/zhayujie/chatgpt-on-wechat/tree/master/plugins)。
+欢迎接入更多应用通道，参考 [飞书通道](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/channel/feishu/feishu_channel.py) 新增自定义通道，实现接收和发送消息逻辑即可完成接入。 同时欢迎贡献新的Skills，参考 [Skill创造器说明](https://github.com/zhayujie/chatgpt-on-wechat/blob/master/skills/skill-creator/SKILL.md)。
 
 # ✉ 联系
 

agent/chat/__init__.py

@@ -0,0 +1,3 @@
+from agent.chat.service import ChatService
+
+__all__ = ["ChatService"]

agent/chat/service.py

@@ -0,0 +1,169 @@
+"""
+ChatService - Wraps the Agent stream execution to produce CHAT protocol chunks.
+
+Translates agent events (message_update, message_end, tool_execution_end, etc.)
+into the CHAT socket protocol format (content chunks with segment_id, tool_calls chunks).
+"""
+
+import time
+from typing import Callable, Optional
+
+from common.log import logger
+
+
+class ChatService:
+    """
+    High-level service that runs an Agent for a given query and streams
+    the results as CHAT protocol chunks via a callback.
+
+    Usage:
+        svc = ChatService(agent_bridge)
+        svc.run(query, session_id, send_chunk_fn)
+    """
+
+    def __init__(self, agent_bridge):
+        """
+        :param agent_bridge: AgentBridge instance (manages agent lifecycle)
+        """
+        self.agent_bridge = agent_bridge
+
+    def run(self, query: str, session_id: str, send_chunk_fn: Callable[[dict], None]):
+        """
+        Run the agent for *query* and stream results back via *send_chunk_fn*.
+
+        The method blocks until the agent finishes. After it returns the SDK
+        will automatically send the final (streaming=false) message.
+
+        :param query: user query text
+        :param session_id: session identifier for agent isolation
+        :param send_chunk_fn: callable(chunk_data: dict) to send a streaming chunk
+        """
+        agent = self.agent_bridge.get_agent(session_id=session_id)
+        if agent is None:
+            raise RuntimeError("Failed to initialise agent for the session")
+
+        # State shared between the event callback and this method
+        state = _StreamState()
+
+        def on_event(event: dict):
+            """Translate agent events into CHAT protocol chunks."""
+            event_type = event.get("type")
+            data = event.get("data", {})
+
+            if event_type == "message_update":
+                # Incremental text delta
+                delta = data.get("delta", "")
+                if delta:
+                    send_chunk_fn({
+                        "chunk_type": "content",
+                        "delta": delta,
+                        "segment_id": state.segment_id,
+                    })
+
+            elif event_type == "message_end":
+                # A content segment finished.
+                tool_calls = data.get("tool_calls", [])
+                if tool_calls:
+                    # After tool_calls are executed the next content will be
+                    # a new segment; collect tool results until turn_end.
+                    state.pending_tool_results = []
+
+            elif event_type == "tool_execution_end":
+                tool_name = data.get("tool_name", "")
+                arguments = data.get("arguments", {})
+                result = data.get("result", "")
+                status = data.get("status", "unknown")
+                execution_time = data.get("execution_time", 0)
+                elapsed_str = f"{execution_time:.2f}s"
+
+                # Serialise result to string if needed
+                if not isinstance(result, str):
+                    import json
+                    try:
+                        result = json.dumps(result, ensure_ascii=False)
+                    except Exception:
+                        result = str(result)
+
+                tool_info = {
+                    "name": tool_name,
+                    "arguments": arguments,
+                    "result": result,
+                    "status": status,
+                    "elapsed": elapsed_str,
+                }
+
+                if state.pending_tool_results is not None:
+                    state.pending_tool_results.append(tool_info)
+
+            elif event_type == "turn_end":
+                has_tool_calls = data.get("has_tool_calls", False)
+                if has_tool_calls and state.pending_tool_results:
+                    # Flush collected tool results as a single tool_calls chunk
+                    send_chunk_fn({
+                        "chunk_type": "tool_calls",
+                        "tool_calls": state.pending_tool_results,
+                    })
+                    state.pending_tool_results = None
+                    # Next content belongs to a new segment
+                    state.segment_id += 1
+
+        # Run the agent with our event callback ---------------------------
+        logger.info(f"[ChatService] Starting agent run: session={session_id}, query={query[:80]}")
+
+        from config import conf
+        max_context_turns = conf().get("agent_max_context_turns", 30)
+
+        # Get full system prompt with skills
+        full_system_prompt = agent.get_full_system_prompt()
+
+        # Create a copy of messages for this execution
+        with agent.messages_lock:
+            messages_copy = agent.messages.copy()
+            original_length = len(agent.messages)
+
+        from agent.protocol.agent_stream import AgentStreamExecutor
+
+        executor = AgentStreamExecutor(
+            agent=agent,
+            model=agent.model,
+            system_prompt=full_system_prompt,
+            tools=agent.tools,
+            max_turns=agent.max_steps,
+            on_event=on_event,
+            messages=messages_copy,
+            max_context_turns=max_context_turns,
+        )
+
+        try:
+            response = executor.run_stream(query)
+        except Exception:
+            # If executor cleared messages (context overflow), sync back
+            if len(executor.messages) == 0:
+                with agent.messages_lock:
+                    agent.messages.clear()
+                    logger.info("[ChatService] Cleared agent message history after executor recovery")
+            raise
+
+        # Append only the NEW messages from this execution (thread-safe)
+        with agent.messages_lock:
+            new_messages = executor.messages[original_length:]
+            agent.messages.extend(new_messages)
+
+        # Store executor reference for files_to_send access
+        agent.stream_executor = executor
+
+        # Execute post-process tools
+        agent._execute_post_process_tools()
+
+        logger.info(f"[ChatService] Agent run completed: session={session_id}")
+
+
+
+class _StreamState:
+    """Mutable state shared between the event callback and the run method."""
+
+    def __init__(self):
+        self.segment_id: int = 0
+        # None means we are not accumulating tool results right now.
+        # A list means we are in the middle of a tool-execution phase.
+        self.pending_tool_results: Optional[list] = None

agent/memory/__init__.py

@@ -1,11 +1,21 @@
 """
 Memory module for AgentMesh
 
-Provides long-term memory capabilities with hybrid search (vector + keyword)
+Provides both long-term memory (vector/keyword search) and short-term
+conversation history persistence (SQLite).
 """
 
 from agent.memory.manager import MemoryManager
 from agent.memory.config import MemoryConfig, get_default_memory_config, set_global_memory_config
 from agent.memory.embedding import create_embedding_provider
+from agent.memory.conversation_store import ConversationStore, get_conversation_store
 
-__all__ = ['MemoryManager', 'MemoryConfig', 'get_default_memory_config', 'set_global_memory_config', 'create_embedding_provider']
+__all__ = [
+    'MemoryManager',
+    'MemoryConfig',
+    'get_default_memory_config',
+    'set_global_memory_config',
+    'create_embedding_provider',
+    'ConversationStore',
+    'get_conversation_store',
+]

agent/memory/chunker.py

@@ -4,6 +4,7 @@ Text chunking utilities for memory
 Splits text into chunks with token limits and overlap
 """
 
+from __future__ import annotations
 from typing import List, Tuple
 from dataclasses import dataclass
 

agent/memory/config.py

@@ -4,18 +4,25 @@ Memory configuration module
 Provides global memory configuration with simplified workspace structure
 """
 
+from __future__ import annotations
 import os
 from dataclasses import dataclass, field
 from typing import Optional, List
 from pathlib import Path
 
 
+def _default_workspace():
+    """Get default workspace path with proper Windows support"""
+    from common.utils import expand_path
+    return expand_path("~/cow")
+
+
 @dataclass
 class MemoryConfig:
     """Configuration for memory storage and search"""
     
     # Storage paths (default: ~/cow)
-    workspace_root: str = field(default_factory=lambda: os.path.expanduser("~/cow"))
+    workspace_root: str = field(default_factory=_default_workspace)
     
     # Embedding config
     embedding_provider: str = "openai"  # "openai" | "local"

agent/memory/conversation_store.py

@@ -0,0 +1,618 @@
+"""
+Conversation history persistence using SQLite.
+
+Design:
+- sessions table: per-session metadata (channel_type, last_active, msg_count)
+- messages table: individual messages stored as JSON, append-only
+- Pruning: age-based only (sessions not updated within N days are deleted)
+- Thread-safe via a single in-process lock
+
+Storage path: ~/cow/sessions/conversations.db
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import threading
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from common.log import logger
+
+
+# ---------------------------------------------------------------------------
+# Schema
+# ---------------------------------------------------------------------------
+
+_DDL = """
+CREATE TABLE IF NOT EXISTS sessions (
+    session_id   TEXT    PRIMARY KEY,
+    channel_type TEXT    NOT NULL DEFAULT '',
+    created_at   INTEGER NOT NULL,
+    last_active  INTEGER NOT NULL,
+    msg_count    INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+    id           INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id   TEXT    NOT NULL,
+    seq          INTEGER NOT NULL,
+    role         TEXT    NOT NULL,
+    content      TEXT    NOT NULL,
+    created_at   INTEGER NOT NULL,
+    UNIQUE (session_id, seq)
+);
+
+CREATE INDEX IF NOT EXISTS idx_messages_session
+    ON messages (session_id, seq);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_last_active
+    ON sessions (last_active);
+"""
+
+# Migration: add channel_type column to existing databases that predate it.
+_MIGRATION_ADD_CHANNEL_TYPE = """
+ALTER TABLE sessions ADD COLUMN channel_type TEXT NOT NULL DEFAULT '';
+"""
+
+DEFAULT_MAX_AGE_DAYS: int = 30
+
+
+def _is_visible_user_message(content: Any) -> bool:
+    """
+    Return True when a user-role message represents actual user input
+    (not an internal tool_result injected by the agent loop).
+    """
+    if isinstance(content, str):
+        return bool(content.strip())
+    if isinstance(content, list):
+        return any(
+            isinstance(b, dict) and b.get("type") == "text"
+            for b in content
+        )
+    return False
+
+
+def _extract_display_text(content: Any) -> str:
+    """
+    Extract the human-readable text portion from a message content value.
+    Returns an empty string for tool_use / tool_result blocks.
+    """
+    if isinstance(content, str):
+        return content.strip()
+    if isinstance(content, list):
+        parts = [
+            b.get("text", "")
+            for b in content
+            if isinstance(b, dict) and b.get("type") == "text"
+        ]
+        return "\n".join(p for p in parts if p).strip()
+    return ""
+
+
+def _extract_tool_calls(content: Any) -> List[Dict[str, Any]]:
+    """
+    Extract tool_use blocks from an assistant message content.
+    Returns a list of {name, arguments} dicts (result filled in later).
+    """
+    if not isinstance(content, list):
+        return []
+    return [
+        {"id": b.get("id", ""), "name": b.get("name", ""), "arguments": b.get("input", {})}
+        for b in content
+        if isinstance(b, dict) and b.get("type") == "tool_use"
+    ]
+
+
+def _extract_tool_results(content: Any) -> Dict[str, str]:
+    """
+    Extract tool_result blocks from a user message, keyed by tool_use_id.
+    """
+    if not isinstance(content, list):
+        return {}
+    results = {}
+    for b in content:
+        if not isinstance(b, dict) or b.get("type") != "tool_result":
+            continue
+        tool_id = b.get("tool_use_id", "")
+        result_content = b.get("content", "")
+        if isinstance(result_content, list):
+            result_content = "\n".join(
+                rb.get("text", "") for rb in result_content
+                if isinstance(rb, dict) and rb.get("type") == "text"
+            )
+        results[tool_id] = str(result_content)
+    return results
+
+
+def _group_into_display_turns(
+    rows: List[tuple],
+) -> List[Dict[str, Any]]:
+    """
+    Convert raw (role, content_json, created_at) DB rows into display turns.
+
+    One display turn = one visible user message  +  one merged assistant reply.
+    All intermediate assistant messages (those carrying tool_use) and the final
+    assistant text reply produced for the same user query are collapsed into a
+    single assistant turn, exactly matching the live SSE rendering where tools
+    and the final answer appear inside the same bubble.
+
+    Grouping rules:
+    - A visible user message starts a new group.
+    - tool_result user messages are internal; their content is attached to the
+      matching tool_use entry via tool_use_id and they never become own turns.
+    - All assistant messages within a group are merged:
+        * tool_use blocks → tool_calls list (result filled from tool_results)
+        * text blocks → last non-empty text becomes the display content
+    """
+    # ------------------------------------------------------------------ #
+    # Pass 1: split rows into groups, each starting with a visible user msg
+    # ------------------------------------------------------------------ #
+    # group = (user_row | None, [subsequent_rows])
+    # user_row: (content, created_at)
+    groups: List[tuple] = []
+    cur_user: Optional[tuple] = None
+    cur_rest: List[tuple] = []
+    started = False
+
+    for role, raw_content, created_at in rows:
+        try:
+            content = json.loads(raw_content)
+        except Exception:
+            content = raw_content
+
+        if role == "user" and _is_visible_user_message(content):
+            if started:
+                groups.append((cur_user, cur_rest))
+            cur_user = (content, created_at)
+            cur_rest = []
+            started = True
+        else:
+            cur_rest.append((role, content, created_at))
+
+    if started:
+        groups.append((cur_user, cur_rest))
+
+    # ------------------------------------------------------------------ #
+    # Pass 2: build display turns from each group
+    # ------------------------------------------------------------------ #
+    turns: List[Dict[str, Any]] = []
+
+    for user_row, rest in groups:
+        # User turn
+        if user_row:
+            content, created_at = user_row
+            text = _extract_display_text(content)
+            if text:
+                turns.append({"role": "user", "content": text, "created_at": created_at})
+
+        # Collect all tool_calls and tool_results from the rest of the group
+        all_tool_calls: List[Dict[str, Any]] = []
+        tool_results: Dict[str, str] = {}
+        final_text = ""
+        final_ts: Optional[int] = None
+
+        for role, content, created_at in rest:
+            if role == "user":
+                tool_results.update(_extract_tool_results(content))
+            elif role == "assistant":
+                tcs = _extract_tool_calls(content)
+                all_tool_calls.extend(tcs)
+                t = _extract_display_text(content)
+                if t:
+                    final_text = t
+                final_ts = created_at
+
+        # Attach tool results to their matching tool_call entries
+        for tc in all_tool_calls:
+            tc["result"] = tool_results.get(tc.get("id", ""), "")
+
+        if final_text or all_tool_calls:
+            turns.append({
+                "role": "assistant",
+                "content": final_text,
+                "tool_calls": all_tool_calls,
+                "created_at": final_ts or (user_row[1] if user_row else 0),
+            })
+
+    return turns
+
+
+class ConversationStore:
+    """
+    SQLite-backed store for per-session conversation history.
+
+    Usage:
+        store = ConversationStore(db_path)
+        store.append_messages("user_123", new_messages, channel_type="feishu")
+        msgs = store.load_messages("user_123", max_turns=30)
+    """
+
+    def __init__(self, db_path: Path):
+        self._db_path = db_path
+        self._lock = threading.Lock()
+        self._init_db()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def load_messages(
+        self,
+        session_id: str,
+        max_turns: int = 30,
+    ) -> List[Dict[str, Any]]:
+        """
+        Load the most recent messages for a session, for injection into the LLM.
+
+        ALL message types (user text, assistant tool_use, tool_result) are returned
+        in their original JSON form so the LLM can reconstruct the full context.
+
+        max_turns is a *visible-turn* count: we count only user messages whose
+        content is actual user text (not tool_result blocks).  This prevents
+        tool-heavy sessions from exhausting the turn budget prematurely.
+
+        Args:
+            session_id: Unique session identifier.
+            max_turns: Maximum number of visible user-assistant turns to keep.
+
+        Returns:
+            Chronologically ordered list of message dicts (role, content).
+        """
+        with self._lock:
+            conn = self._connect()
+            try:
+                rows = conn.execute(
+                    """
+                    SELECT seq, role, content
+                    FROM messages
+                    WHERE session_id = ?
+                    ORDER BY seq DESC
+                    """,
+                    (session_id,),
+                ).fetchall()
+            finally:
+                conn.close()
+
+        if not rows:
+            return []
+
+        # Walk newest-to-oldest counting *visible* user turns (actual user text,
+        # not tool_result injections).  Record the seq of every visible user
+        # message so we can find a clean cut point later.
+        visible_turn_seqs: List[int] = []  # newest first
+        for seq, role, raw_content in rows:
+            if role != "user":
+                continue
+            try:
+                content = json.loads(raw_content)
+            except Exception:
+                content = raw_content
+            if _is_visible_user_message(content):
+                visible_turn_seqs.append(seq)
+
+        # Determine the seq of the oldest visible user message we want to keep.
+        # If the total turns fit within max_turns, keep everything.
+        if len(visible_turn_seqs) <= max_turns:
+            cutoff_seq = None  # keep all
+        else:
+            # The Nth visible user message (0-indexed) is the oldest we keep.
+            cutoff_seq = visible_turn_seqs[max_turns - 1]
+
+        # Build result in chronological order, starting from cutoff.
+        # IMPORTANT: we start exactly at cutoff_seq (the visible user message),
+        # never mid-group, so tool_use / tool_result pairs are always complete.
+        result = []
+        for seq, role, raw_content in reversed(rows):
+            if cutoff_seq is not None and seq < cutoff_seq:
+                continue
+            try:
+                content = json.loads(raw_content)
+            except Exception:
+                content = raw_content
+            result.append({"role": role, "content": content})
+        return result
+
+    def append_messages(
+        self,
+        session_id: str,
+        messages: List[Dict[str, Any]],
+        channel_type: str = "",
+    ) -> None:
+        """
+        Append new messages to a session's history.
+
+        Seq numbers continue from the session's current maximum, so
+        concurrent callers on distinct sessions never collide.
+
+        Args:
+            session_id: Unique session identifier.
+            messages: List of message dicts to append.
+            channel_type: Source channel (e.g. "feishu", "web", "wechat").
+                          Only written on session creation; ignored on update.
+        """
+        if not messages:
+            return
+
+        now = int(time.time())
+        with self._lock:
+            conn = self._connect()
+            try:
+                with conn:
+                    # INSERT OR IGNORE creates the row on first visit;
+                    # the UPDATE always refreshes last_active.
+                    # Avoids ON CONFLICT...DO UPDATE (requires SQLite >= 3.24).
+                    conn.execute(
+                        """
+                        INSERT OR IGNORE INTO sessions
+                            (session_id, channel_type, created_at, last_active, msg_count)
+                        VALUES (?, ?, ?, ?, 0)
+                        """,
+                        (session_id, channel_type, now, now),
+                    )
+                    conn.execute(
+                        "UPDATE sessions SET last_active = ? WHERE session_id = ?",
+                        (now, session_id),
+                    )
+
+                    # Determine starting seq for the new batch.
+                    row = conn.execute(
+                        "SELECT COALESCE(MAX(seq), -1) FROM messages WHERE session_id = ?",
+                        (session_id,),
+                    ).fetchone()
+                    next_seq = row[0] + 1
+
+                    for msg in messages:
+                        role = msg.get("role", "")
+                        content = json.dumps(
+                            msg.get("content", ""), ensure_ascii=False
+                        )
+                        conn.execute(
+                            """
+                            INSERT OR IGNORE INTO messages
+                                (session_id, seq, role, content, created_at)
+                            VALUES (?, ?, ?, ?, ?)
+                            """,
+                            (session_id, next_seq, role, content, now),
+                        )
+                        next_seq += 1
+
+                    conn.execute(
+                        """
+                        UPDATE sessions
+                        SET msg_count = (
+                            SELECT COUNT(*) FROM messages WHERE session_id = ?
+                        )
+                        WHERE session_id = ?
+                        """,
+                        (session_id, session_id),
+                    )
+            finally:
+                conn.close()
+
+    def clear_session(self, session_id: str) -> None:
+        """Delete all messages and the session record for a given session_id."""
+        with self._lock:
+            conn = self._connect()
+            try:
+                with conn:
+                    conn.execute(
+                        "DELETE FROM messages WHERE session_id = ?", (session_id,)
+                    )
+                    conn.execute(
+                        "DELETE FROM sessions WHERE session_id = ?", (session_id,)
+                    )
+            finally:
+                conn.close()
+
+    def cleanup_old_sessions(self, max_age_days: Optional[int] = None) -> int:
+        """
+        Delete sessions that have not been active within max_age_days.
+
+        Args:
+            max_age_days: Override the default retention period.
+
+        Returns:
+            Number of sessions deleted.
+        """
+        try:
+            from config import conf
+            max_age = max_age_days or conf().get(
+                "conversation_max_age_days", DEFAULT_MAX_AGE_DAYS
+            )
+        except Exception:
+            max_age = max_age_days or DEFAULT_MAX_AGE_DAYS
+
+        cutoff = int(time.time()) - max_age * 86400
+        deleted = 0
+
+        with self._lock:
+            conn = self._connect()
+            try:
+                with conn:
+                    stale = conn.execute(
+                        "SELECT session_id FROM sessions WHERE last_active < ?",
+                        (cutoff,),
+                    ).fetchall()
+                    for (sid,) in stale:
+                        conn.execute(
+                            "DELETE FROM messages WHERE session_id = ?", (sid,)
+                        )
+                        conn.execute(
+                            "DELETE FROM sessions WHERE session_id = ?", (sid,)
+                        )
+                        deleted += 1
+            finally:
+                conn.close()
+
+        if deleted:
+            logger.info(f"[ConversationStore] Pruned {deleted} expired sessions")
+        return deleted
+
+    def load_history_page(
+        self,
+        session_id: str,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> Dict[str, Any]:
+        """
+        Load a page of conversation history for UI display, grouped into turns.
+
+        Each "turn" maps to one of:
+          - A user message (role="user", content=str)
+          - An assistant message (role="assistant", content=str,
+            tool_calls=[{name, arguments, result}] when tools were used)
+
+        Internal tool_result user messages are merged into the preceding
+        assistant entry's tool_calls list and never appear as standalone items.
+
+        Pages are numbered from 1 (most recent).  Messages within a page are
+        returned in chronological order.
+
+        Returns:
+            {
+                "messages": [
+                    {
+                        "role": "user" | "assistant",
+                        "content": str,
+                        "tool_calls": [...],   # assistant only, may be []
+                        "created_at": int,
+                    },
+                    ...
+                ],
+                "total": <visible turn count>,
+                "page": <current page>,
+                "page_size": <page_size>,
+                "has_more": bool,
+            }
+        """
+        page = max(1, page)
+        with self._lock:
+            conn = self._connect()
+            try:
+                rows = conn.execute(
+                    """
+                    SELECT role, content, created_at
+                    FROM messages
+                    WHERE session_id = ?
+                    ORDER BY seq ASC
+                    """,
+                    (session_id,),
+                ).fetchall()
+            finally:
+                conn.close()
+
+        visible = _group_into_display_turns(rows)
+
+        total = len(visible)
+        offset = (page - 1) * page_size
+        page_items = list(reversed(visible))[offset: offset + page_size]
+        page_items = list(reversed(page_items))
+
+        return {
+            "messages": page_items,
+            "total": total,
+            "page": page,
+            "page_size": page_size,
+            "has_more": offset + page_size < total,
+        }
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Return basic stats keyed by channel_type, for monitoring."""
+        with self._lock:
+            conn = self._connect()
+            try:
+                total_sessions = conn.execute(
+                    "SELECT COUNT(*) FROM sessions"
+                ).fetchone()[0]
+                total_messages = conn.execute(
+                    "SELECT COUNT(*) FROM messages"
+                ).fetchone()[0]
+                by_channel = conn.execute(
+                    """
+                    SELECT channel_type, COUNT(*) as cnt
+                    FROM sessions
+                    GROUP BY channel_type
+                    ORDER BY cnt DESC
+                    """
+                ).fetchall()
+                return {
+                    "total_sessions": total_sessions,
+                    "total_messages": total_messages,
+                    "by_channel": {row[0] or "unknown": row[1] for row in by_channel},
+                }
+            finally:
+                conn.close()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _init_db(self) -> None:
+        self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        conn = self._connect()
+        try:
+            conn.executescript(_DDL)
+            conn.commit()
+            self._migrate(conn)
+        finally:
+            conn.close()
+
+    def _migrate(self, conn: sqlite3.Connection) -> None:
+        """Apply incremental schema migrations on existing databases."""
+        cols = {
+            row[1]
+            for row in conn.execute("PRAGMA table_info(sessions)").fetchall()
+        }
+        if "channel_type" not in cols:
+            try:
+                conn.execute(_MIGRATION_ADD_CHANNEL_TYPE)
+                conn.commit()
+                logger.info("[ConversationStore] Migrated: added channel_type column")
+            except Exception as e:
+                logger.warning(f"[ConversationStore] Migration failed: {e}")
+
+    def _connect(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(str(self._db_path), timeout=10)
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.execute("PRAGMA synchronous=NORMAL")
+        return conn
+
+
+# ---------------------------------------------------------------------------
+# Singleton
+# ---------------------------------------------------------------------------
+
+_store_instance: Optional[ConversationStore] = None
+_store_lock = threading.Lock()
+
+
+def get_conversation_store() -> ConversationStore:
+    """
+    Return the process-wide ConversationStore singleton.
+
+    Reuses the long-term memory database so the project stays with a single
+    SQLite file: ~/cow/memory/long-term/index.db
+    The conversation tables (sessions / messages) are separate from the
+    memory tables (memory_chunks / file_metadata) — no conflicts.
+    """
+    global _store_instance
+    if _store_instance is not None:
+        return _store_instance
+
+    with _store_lock:
+        if _store_instance is not None:
+            return _store_instance
+
+        try:
+            from agent.memory.config import get_default_memory_config
+            db_path = get_default_memory_config().get_db_path()
+        except Exception:
+            from common.utils import expand_path
+            db_path = Path(expand_path("~/cow")) / "memory" / "long-term" / "index.db"
+
+        _store_instance = ConversationStore(db_path)
+        logger.debug(f"[ConversationStore] Using shared DB at: {db_path}")
+        return _store_instance

agent/memory/embedding.py

@@ -45,8 +45,9 @@ class OpenAIEmbeddingProvider(EmbeddingProvider):
         self.api_key = api_key
         self.api_base = api_base or "https://api.openai.com/v1"
 
-        if not self.api_key:
-            raise ValueError("OpenAI API key is required")
+        # Validate API key
+        if not self.api_key or self.api_key in ["", "YOUR API KEY", "YOUR_API_KEY"]:
+            raise ValueError("OpenAI API key is not configured. Please set 'open_ai_api_key' in config.json")
 
         # Set dimensions based on model
         self._dimensions = 1536 if "small" in model else 3072
@@ -65,9 +66,21 @@ class OpenAIEmbeddingProvider(EmbeddingProvider):
             "model": self.model
         }
 
-        response = requests.post(url, headers=headers, json=data, timeout=30)
-        response.raise_for_status()
-        return response.json()
+        try:
+            response = requests.post(url, headers=headers, json=data, timeout=5)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.ConnectionError as e:
+            raise ConnectionError(f"Failed to connect to OpenAI API at {url}. Please check your network connection and api_base configuration. Error: {str(e)}")
+        except requests.exceptions.Timeout as e:
+            raise TimeoutError(f"OpenAI API request timed out after 10s. Please check your network connection. Error: {str(e)}")
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 401:
+                raise ValueError(f"Invalid OpenAI API key. Please check your 'open_ai_api_key' in config.json")
+            elif e.response.status_code == 429:
+                raise ValueError(f"OpenAI API rate limit exceeded. Please try again later.")
+            else:
+                raise ValueError(f"OpenAI API request failed: {e.response.status_code} - {e.response.text}")
 
     def embed(self, text: str) -> List[float]:
         """Generate embedding for text"""

agent/memory/manager.py

@@ -304,7 +304,7 @@ class MemoryManager:
     ):
         """Sync a single file"""
         # Compute file hash
-        content = file_path.read_text()
+        content = file_path.read_text(encoding='utf-8')
         file_hash = MemoryStorage.compute_hash(content)
         
         # Get relative path

agent/memory/service.py

@@ -0,0 +1,167 @@
+"""
+Memory service for handling memory query operations via cloud protocol.
+
+Provides a unified interface for listing and reading memory files,
+callable from the cloud client (LinkAI) or a future web console.
+
+Memory file layout (under workspace_root):
+    MEMORY.md               -> type: global
+    memory/2026-02-20.md    -> type: daily
+"""
+
+import os
+from datetime import datetime
+from typing import Dict, List, Optional
+from pathlib import Path
+from common.log import logger
+
+
+class MemoryService:
+    """
+    High-level service for memory file queries.
+    Operates directly on the filesystem — no MemoryManager dependency.
+    """
+
+    def __init__(self, workspace_root: str):
+        """
+        :param workspace_root: Workspace root directory (e.g. ~/cow)
+        """
+        self.workspace_root = workspace_root
+        self.memory_dir = os.path.join(workspace_root, "memory")
+
+    # ------------------------------------------------------------------
+    # list — paginated file metadata
+    # ------------------------------------------------------------------
+    def list_files(self, page: int = 1, page_size: int = 20) -> dict:
+        """
+        List all memory files with metadata (without content).
+
+        Returns::
+
+            {
+                "page": 1,
+                "page_size": 20,
+                "total": 15,
+                "list": [
+                    {"filename": "MEMORY.md", "type": "global", "size": 2048, "updated_at": "2026-02-20 10:00:00"},
+                    {"filename": "2026-02-20.md", "type": "daily", "size": 512, "updated_at": "2026-02-20 09:30:00"},
+                    ...
+                ]
+            }
+        """
+        files: List[dict] = []
+
+        # 1. Global memory — MEMORY.md in workspace root
+        global_path = os.path.join(self.workspace_root, "MEMORY.md")
+        if os.path.isfile(global_path):
+            files.append(self._file_info(global_path, "MEMORY.md", "global"))
+
+        # 2. Daily memory files — memory/*.md (sorted newest first)
+        if os.path.isdir(self.memory_dir):
+            daily_files = []
+            for name in os.listdir(self.memory_dir):
+                full = os.path.join(self.memory_dir, name)
+                if os.path.isfile(full) and name.endswith(".md"):
+                    daily_files.append((name, full))
+            # Sort by filename descending (newest date first)
+            daily_files.sort(key=lambda x: x[0], reverse=True)
+            for name, full in daily_files:
+                files.append(self._file_info(full, name, "daily"))
+
+        total = len(files)
+
+        # Paginate
+        start = (page - 1) * page_size
+        end = start + page_size
+        page_items = files[start:end]
+
+        return {
+            "page": page,
+            "page_size": page_size,
+            "total": total,
+            "list": page_items,
+        }
+
+    # ------------------------------------------------------------------
+    # content — read a single file
+    # ------------------------------------------------------------------
+    def get_content(self, filename: str) -> dict:
+        """
+        Read the full content of a memory file.
+
+        :param filename: File name, e.g. ``MEMORY.md`` or ``2026-02-20.md``
+        :return: dict with ``filename`` and ``content``
+        :raises FileNotFoundError: if the file does not exist
+        """
+        path = self._resolve_path(filename)
+        if not os.path.isfile(path):
+            raise FileNotFoundError(f"Memory file not found: {filename}")
+
+        with open(path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        return {
+            "filename": filename,
+            "content": content,
+        }
+
+    # ------------------------------------------------------------------
+    # dispatch — single entry point for protocol messages
+    # ------------------------------------------------------------------
+    def dispatch(self, action: str, payload: Optional[dict] = None) -> dict:
+        """
+        Dispatch a memory management action.
+
+        :param action: ``list`` or ``content``
+        :param payload: action-specific payload
+        :return: protocol-compatible response dict
+        """
+        payload = payload or {}
+        try:
+            if action == "list":
+                page = payload.get("page", 1)
+                page_size = payload.get("page_size", 20)
+                result_payload = self.list_files(page=page, page_size=page_size)
+                return {"action": action, "code": 200, "message": "success", "payload": result_payload}
+
+            elif action == "content":
+                filename = payload.get("filename")
+                if not filename:
+                    return {"action": action, "code": 400, "message": "filename is required", "payload": None}
+                result_payload = self.get_content(filename)
+                return {"action": action, "code": 200, "message": "success", "payload": result_payload}
+
+            else:
+                return {"action": action, "code": 400, "message": f"unknown action: {action}", "payload": None}
+
+        except FileNotFoundError as e:
+            return {"action": action, "code": 404, "message": str(e), "payload": None}
+        except Exception as e:
+            logger.error(f"[MemoryService] dispatch error: action={action}, error={e}")
+            return {"action": action, "code": 500, "message": str(e), "payload": None}
+
+    # ------------------------------------------------------------------
+    # internal helpers
+    # ------------------------------------------------------------------
+    def _resolve_path(self, filename: str) -> str:
+        """
+        Resolve a filename to its absolute path.
+
+        - ``MEMORY.md`` → ``{workspace_root}/MEMORY.md``
+        - ``2026-02-20.md`` → ``{workspace_root}/memory/2026-02-20.md``
+        """
+        if filename == "MEMORY.md":
+            return os.path.join(self.workspace_root, filename)
+        return os.path.join(self.memory_dir, filename)
+
+    @staticmethod
+    def _file_info(path: str, filename: str, file_type: str) -> dict:
+        """Build a file metadata dict."""
+        stat = os.stat(path)
+        updated_at = datetime.fromtimestamp(stat.st_mtime).strftime("%Y-%m-%d %H:%M:%S")
+        return {
+            "filename": filename,
+            "type": file_type,
+            "size": stat.st_size,
+            "updated_at": updated_at,
+        }

agent/memory/storage.py

@@ -4,6 +4,7 @@ Storage layer for memory using SQLite + FTS5
 Provides vector and keyword search capabilities
 """
 
+from __future__ import annotations
 import sqlite3
 import json
 import hashlib
@@ -70,7 +71,7 @@ class MemoryStorage:
             self.fts5_available = self._check_fts5_support()
             if not self.fts5_available:
                 from common.log import logger
-                logger.warning("[MemoryStorage] FTS5 not available, using LIKE-based keyword search")
+                logger.debug("[MemoryStorage] FTS5 not available, using LIKE-based keyword search")
             
             # Check database integrity
             try:
@@ -508,7 +509,7 @@ class MemoryStorage:
         """Destructor to ensure connection is closed"""
         try:
             self.close()
-        except:
+        except Exception:
             pass  # Ignore errors during cleanup
     
     # Helper methods

agent/prompt/builder.py

@@ -4,6 +4,7 @@ System Prompt Builder - 系统提示词构建器
 实现模块化的系统提示词构建，支持工具、技能、记忆等多个子系统
 """
 
+from __future__ import annotations
 import os
 from typing import List, Dict, Optional, Any
 from dataclasses import dataclass
@@ -48,10 +49,10 @@ class PromptBuilder:
         构建完整的系统提示词
         
         Args:
-            base_persona: 基础人格描述（会被context_files中的SOUL.md覆盖）
+            base_persona: 基础人格描述（会被context_files中的AGENT.md覆盖）
             user_identity: 用户身份信息
             tools: 工具列表
-            context_files: 上下文文件列表（SOUL.md, USER.md, README.md等）
+            context_files: 上下文文件列表（AGENT.md, USER.md, RULE.md等）
             skill_manager: 技能管理器
             memory_manager: 记忆管理器
             runtime_info: 运行时信息
@@ -98,13 +99,13 @@ def build_agent_system_prompt(
     3. 记忆系统 - 独立的记忆能力
     4. 工作空间 - 工作环境说明
     5. 用户身份 - 用户信息（可选）
-    6. 项目上下文 - SOUL.md, USER.md, AGENTS.md（定义人格和身份）
+    6. 项目上下文 - AGENT.md, USER.md, RULE.md（定义人格、身份、规则）
     7. 运行时信息 - 元信息（时间、模型等）
     
     Args:
         workspace_dir: 工作空间目录
         language: 语言 ("zh" 或 "en")
-        base_persona: 基础人格描述（已废弃，由SOUL.md定义）
+        base_persona: 基础人格描述（已废弃，由AGENT.md定义）
         user_identity: 用户身份信息
         tools: 工具列表
         context_files: 上下文文件列表
@@ -138,7 +139,7 @@ def build_agent_system_prompt(
     if user_identity:
         sections.extend(_build_user_identity_section(user_identity, language))
     
-    # 6. 项目上下文文件（SOUL.md, USER.md, AGENTS.md - 定义人格）
+    # 6. 项目上下文文件（AGENT.md, USER.md, RULE.md - 定义人格）
     if context_files:
         sections.extend(_build_context_files_section(context_files, language))
     
@@ -150,102 +151,72 @@ def build_agent_system_prompt(
 
 
 def _build_identity_section(base_persona: Optional[str], language: str) -> List[str]:
-    """构建基础身份section - 不再需要，身份由SOUL.md定义"""
-    # 不再生成基础身份section，完全由SOUL.md定义
+    """构建基础身份section - 不再需要，身份由AGENT.md定义"""
+    # 不再生成基础身份section，完全由AGENT.md定义
     return []
 
 
 def _build_tooling_section(tools: List[Any], language: str) -> List[str]:
-    """构建工具说明section"""
+    """Build tooling section with concise tool list and call style guide."""
+    # One-line summaries for known tools (details are in the tool schema)
+    core_summaries = {
+        "read": "读取文件内容",
+        "write": "创建或覆盖文件",
+        "edit": "精确编辑文件",
+        "ls": "列出目录内容",
+        "grep": "搜索文件内容",
+        "find": "按模式查找文件",
+        "bash": "执行shell命令",
+        "terminal": "管理后台进程",
+        "web_search": "网络搜索",
+        "web_fetch": "获取URL内容",
+        "browser": "控制浏览器",
+        "memory_search": "搜索记忆",
+        "memory_get": "读取记忆内容",
+        "env_config": "管理API密钥和技能配置",
+        "scheduler": "管理定时任务和提醒",
+        "send": "发送文件给用户",
+    }
+
+    # Preferred display order
+    tool_order = [
+        "read", "write", "edit", "ls", "grep", "find",
+        "bash", "terminal",
+        "web_search", "web_fetch", "browser",
+        "memory_search", "memory_get",
+        "env_config", "scheduler", "send",
+    ]
+
+    # Build name -> summary mapping for available tools
+    available = {}
+    for tool in tools:
+        name = tool.name if hasattr(tool, 'name') else str(tool)
+        available[name] = core_summaries.get(name, "")
+
+    # Generate tool lines: ordered tools first, then extras
+    tool_lines = []
+    for name in tool_order:
+        if name in available:
+            summary = available.pop(name)
+            tool_lines.append(f"- {name}: {summary}" if summary else f"- {name}")
+    for name in sorted(available):
+        summary = available[name]
+        tool_lines.append(f"- {name}: {summary}" if summary else f"- {name}")
+
     lines = [
         "## 工具系统",
         "",
-        "你可以使用以下工具来完成任务。工具名称是大小写敏感的，请严格按照列表中的名称调用。",
+        "可用工具（名称大小写敏感，严格按列表调用）:",
+        "\n".join(tool_lines),
         "",
-        "### 可用工具",
+        "工具调用风格：",
+        "",
+        "- 在多步骤任务、敏感操作或用户要求时简要解释决策过程",
+        "- 持续推进直到任务完成，完成后向用户报告结果。",
+        "- 回复中涉及密钥、令牌等敏感信息必须脱敏。",
         "",
     ]
-    
-    # 工具分类和排序
-    tool_categories = {
-        "文件操作": ["read", "write", "edit", "ls", "grep", "find"],
-        "命令执行": ["bash", "terminal"],
-        "网络搜索": ["web_search", "web_fetch", "browser"],
-        "记忆系统": ["memory_search", "memory_get"],
-        "其他": []
-    }
-    
-    # 构建工具映射
-    tool_map = {}
-    tool_descriptions = {
-        "read": "读取文件内容",
-        "write": "创建新文件或完全覆盖现有文件（会删除原内容！追加内容请用 edit）。注意：单次 write 内容不要超过 10KB，超大文件请分步创建",
-        "edit": "精确编辑文件（追加、修改、删除部分内容）",
-        "ls": "列出目录内容",
-        "grep": "在文件中搜索内容",
-        "find": "按照模式查找文件",
-        "bash": "执行shell命令",
-        "terminal": "管理后台进程",
-        "web_search": "网络搜索（使用搜索引擎）",
-        "web_fetch": "获取URL内容",
-        "browser": "控制浏览器",
-        "memory_search": "搜索记忆文件",
-        "memory_get": "获取记忆文件内容",
-        "calculator": "计算器",
-        "current_time": "获取当前时间",
-    }
-    
-    for tool in tools:
-        tool_name = tool.name if hasattr(tool, 'name') else str(tool)
-        tool_desc = tool.description if hasattr(tool, 'description') else tool_descriptions.get(tool_name, "")
-        tool_map[tool_name] = tool_desc
-    
-    # 按分类添加工具
-    for category, tool_names in tool_categories.items():
-        category_tools = [(name, tool_map.get(name, "")) for name in tool_names if name in tool_map]
-        if category_tools:
-            lines.append(f"**{category}**:")
-            for name, desc in category_tools:
-                if desc:
-                    lines.append(f"- `{name}`: {desc}")
-                else:
-                    lines.append(f"- `{name}`")
-                del tool_map[name]  # 移除已添加的工具
-            lines.append("")
-    
-    # 添加其他未分类的工具
-    if tool_map:
-        lines.append("**其他工具**:")
-        for name, desc in sorted(tool_map.items()):
-            if desc:
-                lines.append(f"- `{name}`: {desc}")
-            else:
-                lines.append(f"- `{name}`")
-        lines.append("")
-    
-    # 工具使用指南
-    lines.extend([
-        "### 工具调用风格",
-        "",
-        "默认规则: 对于常规、低风险的工具调用，直接调用即可，无需叙述。",
-        "",
-        "需要叙述的情况:",
-        "- 多步骤、复杂的任务",
-        "- 敏感操作（如删除文件）",
-        "- 用户明确要求解释过程",
-        "",
-        "叙述要求: 保持简洁、信息密度高，避免重复显而易见的步骤。",
-        "",
-        "完成标准:",
-        "- 确保用户的需求得到实际解决，而不仅仅是制定计划。",
-        "- 当任务需要多次工具调用时，持续推进直到完成, 解决完后向用户报告结果或回复用户的问题",
-        "- 每次工具调用后，评估是否已获得足够信息来推进或完成任务",
-        "- 避免重复调用相同的工具和相同参数获取相同的信息，除非用户明确要求",
-        "",
-        "**安全提醒**: 回复中涉及密钥、令牌、密码等敏感信息时，必须脱敏处理，禁止直接显示完整内容。",
-        "",
-    ])
-    
+
     return lines
 
 
@@ -264,26 +235,32 @@ def _build_skills_section(skill_manager: Any, tools: Optional[List[Any]], langua
                 break
     
     lines = [
-        "## 技能系统",
+        "## 技能系统（mandatory）",
         "",
         "在回复之前：扫描下方 <available_skills> 中的 <description> 条目。",
         "",
-        f"- 如果恰好有一个技能明确适用：使用 `{read_tool_name}` 工具读取其 <location> 路径下的 SKILL.md 文件，然后遵循它",
-        "- 如果多个技能都适用：选择最具体的一个，然后读取并遵循",
-        "- 如果没有明确适用的：不要读取任何 SKILL.md",
+        f"- 如果恰好有一个技能(Skill)明确适用：使用 `{read_tool_name}` 读取其 <location> 处的 SKILL.md，然后严格遵循它",
+        "- 如果多个技能都适用则选择最匹配的一个，如果没有明确适用的则不要读取任何 SKILL.md",
+        "- 读取 SKILL.md 后直接按其指令执行，无需多余的预检查",
         "",
-        "**约束**: 永远不要一次性读取多个技能；只在选择后再读取。",
+        "**注意**: 永远不要一次性读取多个技能，只在选择后再读取。技能和工具不同，必须先读取其SKILL.md并按照文件内容运行。",
         "",
+        "以下是可用技能："
     ]
     
     # 添加技能列表（通过skill_manager获取）
     try:
         skills_prompt = skill_manager.build_skills_prompt()
+        logger.debug(f"[PromptBuilder] Skills prompt length: {len(skills_prompt) if skills_prompt else 0}")
         if skills_prompt:
             lines.append(skills_prompt.strip())
             lines.append("")
+        else:
+            logger.warning("[PromptBuilder] No skills prompt generated - skills_prompt is empty")
     except Exception as e:
         logger.warning(f"Failed to build skills prompt: {e}")
+        import traceback
+        logger.debug(f"Skills prompt error traceback: {traceback.format_exc()}")
     
     return lines
 
@@ -368,7 +345,7 @@ def _build_workspace_section(workspace_dir: str, language: str, is_first_convers
         "**路径使用规则** (非常重要):",
         "",
         f"1. **相对路径的基准目录**: 所有相对路径都是相对于 `{workspace_dir}` 而言的",
-        f"   - ✅ 正确: 访问工作空间内的文件用相对路径，如 `SOUL.md`",
+        f"   - ✅ 正确: 访问工作空间内的文件用相对路径，如 `AGENT.md`",
         f"   - ❌ 错误: 用相对路径访问其他目录的文件 (如果它不在 `{workspace_dir}` 内)",
         "",
         "2. **访问其他目录**: 如果要访问工作空间之外的目录（如项目代码、系统文件），**必须使用绝对路径**",
@@ -385,14 +362,14 @@ def _build_workspace_section(workspace_dir: str, language: str, is_first_convers
         "",
         "以下文件在会话启动时**已经自动加载**到系统提示词的「项目上下文」section 中，你**无需再用 read 工具读取它们**：",
         "",
-        "- ✅ `SOUL.md`: 已加载 - Agent的人格设定",
+        "- ✅ `AGENT.md`: 已加载 - 你的人格和灵魂设定",
         "- ✅ `USER.md`: 已加载 - 用户的身份信息",
-        "- ✅ `AGENTS.md`: 已加载 - 工作空间使用指南",
+        "- ✅ `RULE.md`: 已加载 - 工作空间使用指南和规则",
         "",
         "**交流规范**:",
         "",
-        "- 在对话中，非必要不输出工作空间技术细节（如 SOUL.md、USER.md等文件名称，工具名称，配置等），除非用户明确询问",
-        "- 例如用自然表达如「我已记住」而非「已更新 MEMORY.md」",
+        "- 在对话中，不要直接输出工作空间中的技术细节，特别是不要输出 AGENT.md、USER.md、MEMORY.md 等文件名称",
+        "- 例如用自然表达例如「我已记住」而不是「已更新 MEMORY.md」",
         "",
     ]
     
@@ -404,15 +381,17 @@ def _build_workspace_section(workspace_dir: str, language: str, is_first_convers
             "这是你的第一次对话！进行以下流程：",
             "",
             "1. **表达初次启动的感觉** - 像是第一次睁开眼看到世界，带着好奇和期待",
-            "2. **简短打招呼后，询问核心问题**：",
+            "2. **简短介绍能力**：一行说明你能帮助解答问题、管理计算机、创造技能，且拥有长期记忆能不断成长",
+            "3. **询问核心问题**：",
             "   - 你希望给我起个什么名字？",
             "   - 我该怎么称呼你？",
-            "   - 你希望我们是什么样的交流风格？（需要举例，如：专业严谨、轻松幽默、温暖友好等）",
-            "3. **语言风格**：温暖但不过度诗意，带点科技感，保持清晰",
-            "4. **问题格式**：用分点或换行，让问题清晰易读",
-            "5. 收到回复后，用 `write` 工具保存到 USER.md 和 SOUL.md",
+            "   - 你希望我们是什么样的交流风格？（一行列举选项：如专业严谨、轻松幽默、温暖友好、简洁高效等）",
+            "4. **风格要求**：温暖自然、简洁清晰，整体控制在 100 字以内",
+            "5. 收到回复后，用 `write` 工具保存到 USER.md 和 AGENT.md",
             "",
-            "**注意事项**:",
+            "**重要提醒**:",
+            "- AGENT.md、USER.md、RULE.md 已经在系统提示词中加载，无需再次读取。不要将这些文件名直接发送给用户",
+            "- 能力介绍和交流风格选项都只要一行，保持精简",
             "- 不要问太多其他信息（职业、时区等可以后续自然了解）",
             "",
         ])
@@ -425,9 +404,9 @@ def _build_context_files_section(context_files: List[ContextFile], language: str
     if not context_files:
         return []
     
-    # 检查是否有SOUL.md
-    has_soul = any(
-        f.path.lower().endswith('soul.md') or 'soul.md' in f.path.lower()
+    # 检查是否有AGENT.md
+    has_agent = any(
+        f.path.lower().endswith('agent.md') or 'agent.md' in f.path.lower()
         for f in context_files
     )
     
@@ -438,8 +417,8 @@ def _build_context_files_section(context_files: List[ContextFile], language: str
         "",
     ]
     
-    if has_soul:
-        lines.append("如果存在 `SOUL.md`，请体现其中定义的人格和语气。避免僵硬、模板化的回复；遵循其指导，除非有更高优先级的指令覆盖它。")
+    if has_agent:
+        lines.append("如果存在 `AGENT.md`，请体现其中定义的人格和语气。避免僵硬、模板化的回复；遵循其指导，除非有更高优先级的指令覆盖它。")
         lines.append("")
     
     # 添加每个文件的内容
@@ -453,7 +432,7 @@ def _build_context_files_section(context_files: List[ContextFile], language: str
 
 
 def _build_runtime_section(runtime_info: Dict[str, Any], language: str) -> List[str]:
-    """构建运行时信息section"""
+    """构建运行时信息section - 支持动态时间"""
     if not runtime_info:
         return []
     
@@ -463,7 +442,17 @@ def _build_runtime_section(runtime_info: Dict[str, Any], language: str) -> List[
     ]
     
     # Add current time if available
-    if runtime_info.get("current_time"):
+    # Support dynamic time via callable function
+    if callable(runtime_info.get("_get_current_time")):
+        try:
+            time_info = runtime_info["_get_current_time"]()
+            time_line = f"当前时间: {time_info['time']} {time_info['weekday']} ({time_info['timezone']})"
+            lines.append(time_line)
+            lines.append("")
+        except Exception as e:
+            logger.warning(f"[PromptBuilder] Failed to get dynamic time: {e}")
+    elif runtime_info.get("current_time"):
+        # Fallback to static time for backward compatibility
         time_str = runtime_info["current_time"]
         weekday = runtime_info.get("weekday", "")
         timezone = runtime_info.get("timezone", "")

agent/prompt/workspace.py

@@ -4,6 +4,7 @@ Workspace Management - 工作空间管理模块
 负责初始化工作空间、创建模板文件、加载上下文文件
 """
 
+from __future__ import annotations
 import os
 import json
 from typing import List, Optional, Dict
@@ -14,9 +15,9 @@ from .builder import ContextFile
 
 
 # 默认文件名常量
-DEFAULT_SOUL_FILENAME = "SOUL.md"
+DEFAULT_AGENT_FILENAME = "AGENT.md"
 DEFAULT_USER_FILENAME = "USER.md"
-DEFAULT_AGENTS_FILENAME = "AGENTS.md"
+DEFAULT_RULE_FILENAME = "RULE.md"
 DEFAULT_MEMORY_FILENAME = "MEMORY.md"
 DEFAULT_STATE_FILENAME = ".agent_state.json"
 
@@ -24,9 +25,9 @@ DEFAULT_STATE_FILENAME = ".agent_state.json"
 @dataclass
 class WorkspaceFiles:
     """工作空间文件路径"""
-    soul_path: str
+    agent_path: str
     user_path: str
-    agents_path: str
+    rule_path: str
     memory_path: str
     memory_dir: str
     state_path: str
@@ -47,29 +48,33 @@ def ensure_workspace(workspace_dir: str, create_templates: bool = True) -> Works
     os.makedirs(workspace_dir, exist_ok=True)
     
     # 定义文件路径
-    soul_path = os.path.join(workspace_dir, DEFAULT_SOUL_FILENAME)
+    agent_path = os.path.join(workspace_dir, DEFAULT_AGENT_FILENAME)
     user_path = os.path.join(workspace_dir, DEFAULT_USER_FILENAME)
-    agents_path = os.path.join(workspace_dir, DEFAULT_AGENTS_FILENAME)
+    rule_path = os.path.join(workspace_dir, DEFAULT_RULE_FILENAME)
     memory_path = os.path.join(workspace_dir, DEFAULT_MEMORY_FILENAME)  # MEMORY.md 在根目录
     memory_dir = os.path.join(workspace_dir, "memory")  # 每日记忆子目录
     state_path = os.path.join(workspace_dir, DEFAULT_STATE_FILENAME)  # 状态文件
     
     # 创建memory子目录
     os.makedirs(memory_dir, exist_ok=True)
+
+    # 创建skills子目录 (for workspace-level skills installed by agent)
+    skills_dir = os.path.join(workspace_dir, "skills")
+    os.makedirs(skills_dir, exist_ok=True)
     
     # 如果需要，创建模板文件
     if create_templates:
-        _create_template_if_missing(soul_path, _get_soul_template())
+        _create_template_if_missing(agent_path, _get_agent_template())
         _create_template_if_missing(user_path, _get_user_template())
-        _create_template_if_missing(agents_path, _get_agents_template())
+        _create_template_if_missing(rule_path, _get_rule_template())
         _create_template_if_missing(memory_path, _get_memory_template())
         
         logger.debug(f"[Workspace] Initialized workspace at: {workspace_dir}")
     
     return WorkspaceFiles(
-        soul_path=soul_path,
+        agent_path=agent_path,
         user_path=user_path,
-        agents_path=agents_path,
+        rule_path=rule_path,
         memory_path=memory_path,
         memory_dir=memory_dir,
         state_path=state_path
@@ -90,9 +95,9 @@ def load_context_files(workspace_dir: str, files_to_load: Optional[List[str]] =
     if files_to_load is None:
         # 默认加载的文件（按优先级排序）
         files_to_load = [
-            DEFAULT_SOUL_FILENAME,
+            DEFAULT_AGENT_FILENAME,
             DEFAULT_USER_FILENAME,
-            DEFAULT_AGENTS_FILENAME,
+            DEFAULT_RULE_FILENAME,
         ]
     
     context_files = []
@@ -159,9 +164,9 @@ def _is_template_placeholder(content: str) -> bool:
 
 # ============= 模板内容 =============
 
-def _get_soul_template() -> str:
+def _get_agent_template() -> str:
     """Agent人格设定模板"""
-    return """# SOUL.md - 我是谁？
+    return """# AGENT.md - 我是谁？
 
 *在首次对话时与用户一起填写这个文件，定义你的身份和性格。*
 
@@ -230,9 +235,9 @@ def _get_user_template() -> str:
 """
 
 
-def _get_agents_template() -> str:
-    """工作空间指南模板"""
-    return """# AGENTS.md - 工作空间指南
+def _get_rule_template() -> str:
+    """工作空间规则模板"""
+    return """# RULE.md - 工作空间规则
 
 这个文件夹是你的家。好好对待它。
 
@@ -258,9 +263,8 @@ def _get_agents_template() -> str:
 - **记忆是有限的** - 如果你想记住某事，写入文件
 - "记在心里"不会在会话重启后保留，文件才会
 - 当有人说"记住这个" → 更新 `MEMORY.md` 或 `memory/YYYY-MM-DD.md`
-- 当你学到教训 → 更新 AGENTS.md 或相关技能
-- 当你犯错 → 记录下来，这样未来的你不会重复
-- **文字 > 大脑** 📝
+- 当你学到教训 → 更新 RULE.md 或相关技能
+- 当你犯错 → 记录下来，这样未来的你不会重复，**文字 > 大脑** 📝
 
 ### 存储规则
 
@@ -278,7 +282,7 @@ def _get_agents_template() -> str:
 
 ## 工作空间演化
 
-这个工作空间会随着你的使用而不断成长。当你学到新东西、发现更好的方式，或者犯错后改正时，记录下来。
+这个工作空间会随着你的使用而不断成长。当你学到新东西、发现更好的方式，或者犯错后改正时，记录下来。你可以随时更新这个规则文件。
 """
 
 

agent/protocol/agent.py

@@ -1,4 +1,5 @@
 import json
+import os
 import time
 import threading
 
@@ -13,7 +14,8 @@ class Agent:
     def __init__(self, system_prompt: str, description: str = "AI Agent", model: LLMModel = None,
                  tools=None, output_mode="print", max_steps=100, max_context_tokens=None, 
                  context_reserve_tokens=None, memory_manager=None, name: str = None,
-                 workspace_dir: str = None, skill_manager=None, enable_skills: bool = True):
+                 workspace_dir: str = None, skill_manager=None, enable_skills: bool = True,
+                 runtime_info: dict = None):
         """
         Initialize the Agent with system prompt, model, description.
 
@@ -31,6 +33,7 @@ class Agent:
         :param workspace_dir: Optional workspace directory for workspace-specific skills
         :param skill_manager: Optional SkillManager instance (will be created if None and enable_skills=True)
         :param enable_skills: Whether to enable skills support (default: True)
+        :param runtime_info: Optional runtime info dict (with _get_current_time callable for dynamic time)
         """
         self.name = name or "Agent"
         self.system_prompt = system_prompt
@@ -48,6 +51,7 @@ class Agent:
         self.memory_manager = memory_manager  # Memory manager for auto memory flush
         self.workspace_dir = workspace_dir  # Workspace directory
         self.enable_skills = enable_skills  # Skills enabled flag
+        self.runtime_info = runtime_info  # Runtime info for dynamic time update
         
         # Initialize skill manager
         self.skill_manager = None
@@ -58,7 +62,8 @@ class Agent:
                 # Auto-create skill manager
                 try:
                     from agent.skills import SkillManager
-                    self.skill_manager = SkillManager(workspace_dir=workspace_dir)
+                    custom_dir = os.path.join(workspace_dir, "skills") if workspace_dir else None
+                    self.skill_manager = SkillManager(custom_dir=custom_dir)
                     logger.debug(f"Initialized SkillManager with {len(self.skill_manager.skills)} skills")
                 except Exception as e:
                     logger.warning(f"Failed to initialize SkillManager: {e}")
@@ -96,18 +101,98 @@ class Agent:
     def get_full_system_prompt(self, skill_filter=None) -> str:
         """
         Get the full system prompt including skills.
-        
+
         Note: Skills are now built into the system prompt by PromptBuilder,
         so we just return the base prompt directly. This method is kept for
         backward compatibility.
-        
+
         :param skill_filter: Optional list of skill names to include (deprecated)
         :return: Complete system prompt
         """
-        # Skills are now included in system_prompt by PromptBuilder
-        # No need to append them here
-        return self.system_prompt
+        prompt = self.system_prompt
+
+        # Rebuild tool list section to reflect current self.tools
+        prompt = self._rebuild_tool_list_section(prompt)
+
+        # If runtime_info contains dynamic time function, rebuild runtime section
+        if self.runtime_info and callable(self.runtime_info.get('_get_current_time')):
+            prompt = self._rebuild_runtime_section(prompt)
+
+        return prompt
     
+    def _rebuild_runtime_section(self, prompt: str) -> str:
+        """
+        Rebuild runtime info section with current time.
+        
+        This method dynamically updates the runtime info section by calling
+        the _get_current_time function from runtime_info.
+        
+        :param prompt: Original system prompt
+        :return: Updated system prompt with current runtime info
+        """
+        try:
+            # Get current time dynamically
+            time_info = self.runtime_info['_get_current_time']()
+            
+            # Build new runtime section
+            runtime_lines = [
+                "\n## 运行时信息\n",
+                "\n",
+                f"当前时间: {time_info['time']} {time_info['weekday']} ({time_info['timezone']})\n",
+                "\n"
+            ]
+            
+            # Add other runtime info
+            runtime_parts = []
+            if self.runtime_info.get("model"):
+                runtime_parts.append(f"模型={self.runtime_info['model']}")
+            if self.runtime_info.get("workspace"):
+                # Replace backslashes with forward slashes for Windows paths
+                workspace_path = str(self.runtime_info['workspace']).replace('\\', '/')
+                runtime_parts.append(f"工作空间={workspace_path}")
+            if self.runtime_info.get("channel") and self.runtime_info.get("channel") != "web":
+                runtime_parts.append(f"渠道={self.runtime_info['channel']}")
+            
+            if runtime_parts:
+                runtime_lines.append("运行时: " + " | ".join(runtime_parts) + "\n")
+                runtime_lines.append("\n")
+            
+            new_runtime_section = "".join(runtime_lines)
+            
+            # Find and replace the runtime section
+            import re
+            pattern = r'\n## 运行时信息\s*\n.*?(?=\n##|\Z)'
+            updated_prompt = re.sub(pattern, new_runtime_section.rstrip('\n'), prompt, flags=re.DOTALL)
+            
+            return updated_prompt
+        except Exception as e:
+            logger.warning(f"Failed to rebuild runtime section: {e}")
+            return prompt
+
+    def _rebuild_tool_list_section(self, prompt: str) -> str:
+        """
+        Rebuild the tool list inside the '## 工具系统' section so that it
+        always reflects the current ``self.tools`` (handles dynamic add/remove
+        of conditional tools like web_search).
+        """
+        import re
+        from agent.prompt.builder import _build_tooling_section
+
+        try:
+            if not self.tools:
+                return prompt
+
+            new_lines = _build_tooling_section(self.tools, "zh")
+            new_section = "\n".join(new_lines).rstrip("\n")
+
+            # Replace existing tooling section
+            pattern = r'## 工具系统\s*\n.*?(?=\n## |\Z)'
+            updated = re.sub(pattern, new_section, prompt, count=1, flags=re.DOTALL)
+            return updated
+        except Exception as e:
+            logger.warning(f"Failed to rebuild tool list section: {e}")
+            return prompt
+
     def refresh_skills(self):
         """Refresh the loaded skills."""
         if self.skill_manager:
@@ -193,27 +278,67 @@ class Agent:
 
     def _estimate_message_tokens(self, message: dict) -> int:
         """
-        Estimate token count for a message using chars/4 heuristic.
-        This is a conservative estimate (tends to overestimate).
+        Estimate token count for a message.
+
+        Uses chars/3 for Chinese-heavy content and chars/4 for ASCII-heavy content,
+        plus per-block overhead for tool_use / tool_result structures.
 
         :param message: Message dict with 'role' and 'content'
         :return: Estimated token count
         """
         content = message.get('content', '')
         if isinstance(content, str):
-            return max(1, len(content) // 4)
+            return max(1, self._estimate_text_tokens(content))
         elif isinstance(content, list):
-            # Handle multi-part content (text + images)
-            total_chars = 0
+            total_tokens = 0
             for part in content:
-                if isinstance(part, dict) and part.get('type') == 'text':
-                    total_chars += len(part.get('text', ''))
-                elif isinstance(part, dict) and part.get('type') == 'image':
-                    # Estimate images as ~1200 tokens
-                    total_chars += 4800
-            return max(1, total_chars // 4)
+                if not isinstance(part, dict):
+                    continue
+                block_type = part.get('type', '')
+                if block_type == 'text':
+                    total_tokens += self._estimate_text_tokens(part.get('text', ''))
+                elif block_type == 'image':
+                    total_tokens += 1200
+                elif block_type == 'tool_use':
+                    # tool_use has id + name + input (JSON-encoded)
+                    total_tokens += 50  # overhead for structure
+                    input_data = part.get('input', {})
+                    if isinstance(input_data, dict):
+                        import json
+                        input_str = json.dumps(input_data, ensure_ascii=False)
+                        total_tokens += self._estimate_text_tokens(input_str)
+                elif block_type == 'tool_result':
+                    # tool_result has tool_use_id + content
+                    total_tokens += 30  # overhead for structure
+                    result_content = part.get('content', '')
+                    if isinstance(result_content, str):
+                        total_tokens += self._estimate_text_tokens(result_content)
+                else:
+                    # Unknown block type, estimate conservatively
+                    total_tokens += 10
+            return max(1, total_tokens)
         return 1
 
+    @staticmethod
+    def _estimate_text_tokens(text: str) -> int:
+        """
+        Estimate token count for a text string.
+
+        Chinese / CJK characters typically use ~1.5 tokens each,
+        while ASCII uses ~0.25 tokens per char (4 chars/token).
+        We use a weighted average based on the character mix.
+
+        :param text: Input text
+        :return: Estimated token count
+        """
+        if not text:
+            return 0
+        # Count non-ASCII characters (CJK, emoji, etc.)
+        non_ascii = sum(1 for c in text if ord(c) > 127)
+        ascii_count = len(text) - non_ascii
+        # CJK chars: ~1.5 tokens each; ASCII: ~0.25 tokens per char
+        return int(non_ascii * 1.5 + ascii_count * 0.25) + 1
+
     def _find_tool(self, tool_name: str):
         """Find and return a tool with the specified name"""
         for tool in self.tools:
@@ -370,7 +495,17 @@ class Agent:
         )
 
         # Execute
-        response = executor.run_stream(user_message)
+        try:
+            response = executor.run_stream(user_message)
+        except Exception:
+            # If executor cleared its messages (context overflow / message format error),
+            # sync that back to the Agent's own message list so the next request
+            # starts fresh instead of hitting the same overflow forever.
+            if len(executor.messages) == 0:
+                with self.messages_lock:
+                    self.messages.clear()
+                    logger.info("[Agent] Cleared Agent message history after executor recovery")
+            raise
 
         # Append only the NEW messages from this execution (thread-safe)
         # This allows concurrent requests to both contribute to history

agent/protocol/agent_stream.py

@@ -5,7 +5,7 @@ Provides streaming output, event system, and complete tool-call loop
 """
 import json
 import time
-from typing import List, Dict, Any, Optional, Callable
+from typing import List, Dict, Any, Optional, Callable, Tuple
 
 from agent.protocol.models import LLMRequest, LLMModel
 from agent.tools.base_tool import BaseTool, ToolResult
@@ -76,6 +76,20 @@ class AgentStreamExecutor:
                 })
             except Exception as e:
                 logger.error(f"Event callback error: {e}")
+    
+    def _filter_think_tags(self, text: str) -> str:
+        """
+        Remove <think> and </think> tags but keep the content inside.
+        Some LLM providers (e.g., MiniMax) may return thinking process wrapped in <think> tags.
+        We only remove the tags themselves, keeping the actual thinking content.
+        """
+        if not text:
+            return text
+        import re
+        # Remove only the <think> and </think> tags, keep the content
+        text = re.sub(r'<think>', '', text)
+        text = re.sub(r'</think>', '', text)
+        return text
 
     def _hash_args(self, args: dict) -> str:
         """Generate a simple hash for tool arguments"""
@@ -84,9 +98,9 @@ class AgentStreamExecutor:
         args_str = json.dumps(args, sort_keys=True, ensure_ascii=False)
         return hashlib.md5(args_str.encode()).hexdigest()[:8]
     
-    def _check_consecutive_failures(self, tool_name: str, args: dict) -> tuple[bool, str, bool]:
+    def _check_consecutive_failures(self, tool_name: str, args: dict) -> Tuple[bool, str, bool]:
         """
-        Check if tool has failed too many times consecutively
+        Check if tool has failed too many times consecutively or called repeatedly with same args
         
         Returns:
             (should_stop, reason, is_critical)
@@ -96,6 +110,19 @@ class AgentStreamExecutor:
         """
         args_hash = self._hash_args(args)
         
+        # Count consecutive calls (both success and failure) for same tool + args
+        # This catches infinite loops where tool succeeds but LLM keeps calling it
+        same_args_calls = 0
+        for name, ahash, success in reversed(self.tool_failure_history):
+            if name == tool_name and ahash == args_hash:
+                same_args_calls += 1
+            else:
+                break  # Different tool or args, stop counting
+        
+        # Stop at 5 consecutive calls with same args (whether success or failure)
+        if same_args_calls >= 5:
+            return True, f"工具 '{tool_name}' 使用相同参数已被调用 {same_args_calls} 次，停止执行以防止无限循环。如果需要查看配置，结果已在之前的调用中返回。", False
+        
         # Count consecutive failures for same tool + args
         same_args_failures = 0
         for name, ahash, success in reversed(self.tool_failure_history):
@@ -171,7 +198,7 @@ class AgentStreamExecutor:
         try:
             while turn < self.max_turns:
                 turn += 1
-                logger.debug(f"第 {turn} 轮")
+                logger.info(f"[Agent] 第 {turn} 轮")
                 self._emit_event("turn_start", {"turn": turn})
 
                 # Check if memory flush is needed (before calling LLM)
@@ -248,9 +275,14 @@ class AgentStreamExecutor:
                 # Log tool calls with arguments
                 tool_calls_str = []
                 for tc in tool_calls:
-                    args_str = ', '.join([f"{k}={v}" for k, v in tc['arguments'].items()])
-                    if args_str:
-                        tool_calls_str.append(f"{tc['name']}({args_str})")
+                    # Safely handle None or missing arguments
+                    args = tc.get('arguments') or {}
+                    if isinstance(args, dict):
+                        args_str = ', '.join([f"{k}={v}" for k, v in args.items()])
+                        if args_str:
+                            tool_calls_str.append(f"{tc['name']}({args_str})")
+                        else:
+                            tool_calls_str.append(tc['name'])
                     else:
                         tool_calls_str.append(tc['name'])
                 logger.info(f"🔧 {', '.join(tool_calls_str)}")
@@ -264,6 +296,19 @@ class AgentStreamExecutor:
                         result = self._execute_tool(tool_call)
                         tool_results.append(result)
                         
+                        # Debug: Check if tool is being called repeatedly with same args
+                        if turn > 2:
+                            # Check last N tool calls for repeats
+                            repeat_count = sum(
+                                1 for name, ahash, _ in self.tool_failure_history[-10:]
+                                if name == tool_call["name"] and ahash == self._hash_args(tool_call["arguments"])
+                            )
+                            if repeat_count >= 3:
+                                logger.warning(
+                                    f"⚠️  Tool '{tool_call['name']}' has been called {repeat_count} times "
+                                    f"with same arguments. This may indicate a loop."
+                                )
+                        
                         # Check if this is a file to send (from read tool)
                         if result.get("status") == "success" and isinstance(result.get("result"), dict):
                             result_data = result.get("result")
@@ -291,7 +336,7 @@ class AgentStreamExecutor:
                         # Build tool result block (Claude format)
                         # Format content in a way that's easy for LLM to understand
                         is_error = result.get("status") == "error"
-                        
+
                         if is_error:
                             # For errors, provide clear error message
                             result_content = f"Error: {result.get('result', 'Unknown error')}"
@@ -304,7 +349,16 @@ class AgentStreamExecutor:
                         else:
                             # Fallback to full JSON
                             result_content = json.dumps(result, ensure_ascii=False)
-                        
+
+                        # Truncate excessively large tool results for the current turn
+                        # Historical turns will be further truncated in _trim_messages()
+                        MAX_CURRENT_TURN_RESULT_CHARS = 50000
+                        if len(result_content) > MAX_CURRENT_TURN_RESULT_CHARS:
+                            truncated_len = len(result_content)
+                            result_content = result_content[:MAX_CURRENT_TURN_RESULT_CHARS] + \
+                                f"\n\n[Output truncated: {truncated_len} chars total, showing first {MAX_CURRENT_TURN_RESULT_CHARS} chars]"
+                            logger.info(f"📎 Truncated tool result for '{tool_call['name']}': {truncated_len} -> {MAX_CURRENT_TURN_RESULT_CHARS} chars")
+
                         tool_result_block = {
                             "type": "tool_result",
                             "tool_use_id": tool_call["id"],
@@ -326,6 +380,33 @@ class AgentStreamExecutor:
                             "role": "user",
                             "content": tool_result_blocks
                         })
+                        
+                        # Detect potential infinite loop: same tool called multiple times with success
+                        # If detected, add a hint to LLM to stop calling tools and provide response
+                        if turn >= 3 and len(tool_calls) > 0:
+                            tool_name = tool_calls[0]["name"]
+                            args_hash = self._hash_args(tool_calls[0]["arguments"])
+                            
+                            # Count recent successful calls with same tool+args
+                            recent_success_count = 0
+                            for name, ahash, success in reversed(self.tool_failure_history[-10:]):
+                                if name == tool_name and ahash == args_hash and success:
+                                    recent_success_count += 1
+                            
+                            # If tool was called successfully 3+ times with same args, add hint to stop loop
+                            if recent_success_count >= 3:
+                                logger.warning(
+                                    f"⚠️  Detected potential loop: '{tool_name}' called {recent_success_count} times "
+                                    f"with same args. Adding hint to LLM to provide final response."
+                                )
+                                # Add a gentle hint message to guide LLM to respond
+                                self.messages.append({
+                                    "role": "user",
+                                    "content": [{
+                                        "type": "text",
+                                        "text": "工具已成功执行并返回结果。请基于这些信息向用户做出回复，不要重复调用相同的工具。"
+                                    }]
+                                })
                     elif tool_calls:
                         # If we have tool_calls but no tool_result_blocks (unexpected error),
                         # create error results for all tool calls to maintain message integrity
@@ -389,7 +470,7 @@ class AgentStreamExecutor:
             raise
 
         finally:
-            logger.debug(f"🏁 完成({turn}轮)")
+            logger.info(f"[Agent] 🏁 完成 ({turn}轮)")
             self._emit_event("agent_end", {"final_response": final_response})
 
             # 每轮对话结束后增加计数（用户消息+AI回复=1轮）
@@ -398,7 +479,8 @@ class AgentStreamExecutor:
 
         return final_response
 
-    def _call_llm_stream(self, retry_on_empty=True, retry_count=0, max_retries=3) -> tuple[str, List[Dict]]:
+    def _call_llm_stream(self, retry_on_empty=True, retry_count=0, max_retries=3,
+                         _overflow_retry: bool = False) -> Tuple[str, List[Dict]]:
         """
         Call LLM with streaming and automatic retry on errors
         
@@ -406,6 +488,7 @@ class AgentStreamExecutor:
             retry_on_empty: Whether to retry once if empty response is received
             retry_count: Current retry attempt (internal use)
             max_retries: Maximum number of retries for API errors
+            _overflow_retry: Internal flag indicating this is a retry after context overflow
         
         Returns:
             (response_text, tool_calls)
@@ -418,17 +501,7 @@ class AgentStreamExecutor:
 
         # Prepare messages
         messages = self._prepare_messages()
-        
-        # Debug: log message structure
-        logger.debug(f"Sending {len(messages)} messages to LLM")
-        for i, msg in enumerate(messages):
-            role = msg.get("role", "unknown")
-            content = msg.get("content", "")
-            if isinstance(content, list):
-                content_types = [c.get("type") for c in content if isinstance(c, dict)]
-                logger.debug(f"  Message {i}: role={role}, content_blocks={content_types}")
-            else:
-                logger.debug(f"  Message {i}: role={role}, content_length={len(str(content))}")
+        logger.info(f"Sending {len(messages)} messages to LLM")
 
         # Prepare tool definitions (OpenAI/Claude format)
         tools_schema = None
@@ -501,7 +574,7 @@ class AgentStreamExecutor:
                         raise Exception(f"{error_msg} (Status: {status_code}, Code: {error_code}, Type: {error_type})")
 
                 # Parse chunk
-                if isinstance(chunk, dict) and "choices" in chunk:
+                if isinstance(chunk, dict) and chunk.get("choices"):
                     choice = chunk["choices"][0]
                     delta = choice.get("delta", {})
                     
@@ -510,14 +583,22 @@ class AgentStreamExecutor:
                     if finish_reason:
                         stop_reason = finish_reason
 
+                    # Skip reasoning_content (internal thinking from models like GLM-5)
+                    reasoning_delta = delta.get("reasoning_content") or ""
+                    # if reasoning_delta:
+                    #     logger.debug(f"🧠 [thinking] {reasoning_delta[:100]}...")
+
                     # Handle text content
-                    if "content" in delta and delta["content"]:
-                        content_delta = delta["content"]
-                        full_content += content_delta
-                        self._emit_event("message_update", {"delta": content_delta})
+                    content_delta = delta.get("content") or ""
+                    if content_delta:
+                        # Filter out <think> tags from content
+                        filtered_delta = self._filter_think_tags(content_delta)
+                        full_content += filtered_delta
+                        if filtered_delta:  # Only emit if there's content after filtering
+                            self._emit_event("message_update", {"delta": filtered_delta})
 
                     # Handle tool calls
-                    if "tool_calls" in delta:
+                    if "tool_calls" in delta and delta["tool_calls"]:
                         for tc_delta in delta["tool_calls"]:
                             index = tc_delta.get("index", 0)
 
@@ -564,10 +645,23 @@ class AgentStreamExecutor:
             if is_context_overflow or is_message_format_error:
                 error_type = "context overflow" if is_context_overflow else "message format error"
                 logger.error(f"💥 {error_type} detected: {e}")
-                # Clear message history to recover
+
+                # Strategy: try aggressive trimming first, only clear as last resort
+                if is_context_overflow and not _overflow_retry:
+                    trimmed = self._aggressive_trim_for_overflow()
+                    if trimmed:
+                        logger.warning("🔄 Aggressively trimmed context, retrying...")
+                        return self._call_llm_stream(
+                            retry_on_empty=retry_on_empty,
+                            retry_count=retry_count,
+                            max_retries=max_retries,
+                            _overflow_retry=True
+                        )
+
+                # Aggressive trim didn't help or this is a message format error
+                # -> clear everything
                 logger.warning("🔄 Clearing conversation history to recover")
                 self.messages.clear()
-                # Raise special exception with user-friendly message
                 if is_context_overflow:
                     raise Exception(
                         "抱歉，对话历史过长导致上下文溢出。我已清空历史记录，请重新描述你的需求。"
@@ -577,7 +671,10 @@ class AgentStreamExecutor:
                         "抱歉，之前的对话出现了问题。我已清空历史记录，请重新发送你的消息。"
                     )
             
-            # Check if error is retryable (timeout, connection, rate limit, server busy, etc.)
+            # Check if error is rate limit (429)
+            is_rate_limit = '429' in error_str_lower or 'rate limit' in error_str_lower
+            
+            # Check if error is retryable (timeout, connection, server busy, etc.)
             is_retryable = any(keyword in error_str_lower for keyword in [
                 'timeout', 'timed out', 'connection', 'network', 
                 'rate limit', 'overloaded', 'unavailable', 'busy', 'retry',
@@ -585,7 +682,12 @@ class AgentStreamExecutor:
             ])
             
             if is_retryable and retry_count < max_retries:
-                wait_time = (retry_count + 1) * 2  # Exponential backoff: 2s, 4s, 6s
+                # Rate limit needs longer wait time
+                if is_rate_limit:
+                    wait_time = 30 + (retry_count * 15)  # 30s, 45s, 60s for rate limit
+                else:
+                    wait_time = (retry_count + 1) * 2  # 2s, 4s, 6s for other errors
+                
                 logger.warning(f"⚠️ LLM API error (attempt {retry_count + 1}/{max_retries}): {e}")
                 logger.info(f"Retrying in {wait_time}s...")
                 time.sleep(wait_time)
@@ -605,19 +707,30 @@ class AgentStreamExecutor:
         tool_calls = []
         for idx in sorted(tool_calls_buffer.keys()):
             tc = tool_calls_buffer[idx]
+
+            # Ensure tool call has a valid ID (some providers return empty/None IDs)
+            tool_id = tc.get("id") or ""
+            if not tool_id:
+                import uuid
+                tool_id = f"call_{uuid.uuid4().hex[:24]}"
+
             try:
-                arguments = json.loads(tc["arguments"]) if tc["arguments"] else {}
+                # Safely get arguments, handle None case
+                args_str = tc.get("arguments") or ""
+                arguments = json.loads(args_str) if args_str else {}
             except json.JSONDecodeError as e:
-                args_preview = tc['arguments'][:200] if len(tc['arguments']) > 200 else tc['arguments']
+                # Handle None or invalid arguments safely
+                args_str = tc.get('arguments') or ""
+                args_preview = args_str[:200] if len(args_str) > 200 else args_str
                 logger.error(f"Failed to parse tool arguments for {tc['name']}")
-                logger.error(f"Arguments length: {len(tc['arguments'])} chars")
+                logger.error(f"Arguments length: {len(args_str)} chars")
                 logger.error(f"Arguments preview: {args_preview}...")
                 logger.error(f"JSON decode error: {e}")
-                
+
                 # Return a clear error message to the LLM instead of empty dict
                 # This helps the LLM understand what went wrong
                 tool_calls.append({
-                    "id": tc["id"],
+                    "id": tool_id,
                     "name": tc["name"],
                     "arguments": {},
                     "_parse_error": f"Invalid JSON in tool arguments: {args_preview}... Error: {str(e)}. Tip: For large content, consider splitting into smaller chunks or using a different approach."
@@ -625,7 +738,7 @@ class AgentStreamExecutor:
                 continue
 
             tool_calls.append({
-                "id": tc["id"],
+                "id": tool_id,
                 "name": tc["name"],
                 "arguments": arguments
             })
@@ -646,6 +759,9 @@ class AgentStreamExecutor:
                 max_retries=max_retries
             )
 
+        # Filter full_content one more time (in case tags were split across chunks)
+        full_content = self._filter_think_tags(full_content)
+        
         # Add assistant message to history (Claude format uses content blocks)
         assistant_msg = {"role": "assistant", "content": []}
 
@@ -661,9 +777,9 @@ class AgentStreamExecutor:
             for tc in tool_calls:
                 assistant_msg["content"].append({
                     "type": "tool_use",
-                    "id": tc["id"],
-                    "name": tc["name"],
-                    "input": tc["arguments"]
+                    "id": tc.get("id", ""),
+                    "name": tc.get("name", ""),
+                    "input": tc.get("arguments", {})
                 })
         
         # Only append if content is not empty
@@ -866,10 +982,164 @@ class AgentStreamExecutor:
             for msg in turn['messages']
         )
 
+    def _truncate_historical_tool_results(self):
+        """
+        Truncate tool_result content in historical messages to reduce context size.
+
+        Current turn results are kept at 30K chars (truncated at creation time).
+        Historical turn results are further truncated to 10K chars here.
+        This runs before token-based trimming so that we first shrink oversized
+        results, potentially avoiding the need to drop entire turns.
+        """
+        MAX_HISTORY_RESULT_CHARS = 20000
+
+        if len(self.messages) < 2:
+            return
+
+        # Find where the last user text message starts (= current turn boundary)
+        # We skip the current turn's messages to preserve their full content
+        current_turn_start = len(self.messages)
+        for i in range(len(self.messages) - 1, -1, -1):
+            msg = self.messages[i]
+            if msg.get("role") == "user":
+                content = msg.get("content", [])
+                if isinstance(content, list) and any(
+                    isinstance(b, dict) and b.get("type") == "text" for b in content
+                ):
+                    current_turn_start = i
+                    break
+                elif isinstance(content, str):
+                    current_turn_start = i
+                    break
+
+        truncated_count = 0
+        for i in range(current_turn_start):
+            msg = self.messages[i]
+            if msg.get("role") != "user":
+                continue
+            content = msg.get("content", [])
+            if not isinstance(content, list):
+                continue
+
+            for block in content:
+                if not isinstance(block, dict) or block.get("type") != "tool_result":
+                    continue
+                result_str = block.get("content", "")
+                if isinstance(result_str, str) and len(result_str) > MAX_HISTORY_RESULT_CHARS:
+                    original_len = len(result_str)
+                    block["content"] = result_str[:MAX_HISTORY_RESULT_CHARS] + \
+                        f"\n\n[Historical output truncated: {original_len} -> {MAX_HISTORY_RESULT_CHARS} chars]"
+                    truncated_count += 1
+
+        if truncated_count > 0:
+            logger.info(f"📎 Truncated {truncated_count} historical tool result(s) to {MAX_HISTORY_RESULT_CHARS} chars")
+
+    def _aggressive_trim_for_overflow(self) -> bool:
+        """
+        Aggressively trim context when a real overflow error is returned by the API.
+
+        This method goes beyond normal _trim_messages by:
+        1. Truncating all tool results (including current turn) to a small limit
+        2. Keeping only the last 5 complete conversation turns
+        3. Truncating overly long user messages
+
+        Returns:
+            True if messages were trimmed (worth retrying), False if nothing left to trim
+        """
+        if not self.messages:
+            return False
+
+        original_count = len(self.messages)
+
+        # Step 1: Aggressively truncate ALL tool results to 5K chars
+        AGGRESSIVE_LIMIT = 10000
+        truncated = 0
+        for msg in self.messages:
+            content = msg.get("content", [])
+            if not isinstance(content, list):
+                continue
+            for block in content:
+                if not isinstance(block, dict):
+                    continue
+                # Truncate tool_result blocks
+                if block.get("type") == "tool_result":
+                    result_str = block.get("content", "")
+                    if isinstance(result_str, str) and len(result_str) > AGGRESSIVE_LIMIT:
+                        block["content"] = (
+                            result_str[:AGGRESSIVE_LIMIT]
+                            + f"\n\n[Truncated for context recovery: "
+                            f"{len(result_str)} -> {AGGRESSIVE_LIMIT} chars]"
+                        )
+                        truncated += 1
+                # Truncate tool_use input blocks (e.g. large write content)
+                if block.get("type") == "tool_use" and isinstance(block.get("input"), dict):
+                    input_str = json.dumps(block["input"], ensure_ascii=False)
+                    if len(input_str) > AGGRESSIVE_LIMIT:
+                        # Keep only a summary of the input
+                        for key, val in block["input"].items():
+                            if isinstance(val, str) and len(val) > 1000:
+                                block["input"][key] = (
+                                    val[:1000]
+                                    + f"... [truncated {len(val)} chars]"
+                                )
+                        truncated += 1
+
+        # Step 2: Truncate overly long user text messages (e.g. pasted content)
+        USER_MSG_LIMIT = 10000
+        for msg in self.messages:
+            if msg.get("role") != "user":
+                continue
+            content = msg.get("content", [])
+            if isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict) and block.get("type") == "text":
+                        text = block.get("text", "")
+                        if len(text) > USER_MSG_LIMIT:
+                            block["text"] = (
+                                text[:USER_MSG_LIMIT]
+                                + f"\n\n[Message truncated for context recovery: "
+                                f"{len(text)} -> {USER_MSG_LIMIT} chars]"
+                            )
+                            truncated += 1
+            elif isinstance(content, str) and len(content) > USER_MSG_LIMIT:
+                msg["content"] = (
+                    content[:USER_MSG_LIMIT]
+                    + f"\n\n[Message truncated for context recovery: "
+                    f"{len(content)} -> {USER_MSG_LIMIT} chars]"
+                )
+                truncated += 1
+
+        # Step 3: Keep only the last 5 complete turns
+        turns = self._identify_complete_turns()
+        if len(turns) > 5:
+            kept_turns = turns[-5:]
+            new_messages = []
+            for turn in kept_turns:
+                new_messages.extend(turn["messages"])
+            removed = len(turns) - 5
+            self.messages[:] = new_messages
+            logger.info(
+                f"🔧 Aggressive trim: removed {removed} old turns, "
+                f"truncated {truncated} large blocks, "
+                f"{original_count} -> {len(self.messages)} messages"
+            )
+            return True
+
+        if truncated > 0:
+            logger.info(
+                f"🔧 Aggressive trim: truncated {truncated} large blocks "
+                f"(no turns removed, only {len(turns)} turn(s) left)"
+            )
+            return True
+
+        # Nothing left to trim
+        logger.warning("🔧 Aggressive trim: nothing to trim, will clear history")
+        return False
+
     def _trim_messages(self):
         """
         智能清理消息历史，保持对话完整性
-        
+
         使用完整轮次作为清理单位，确保：
         1. 不会在对话中间截断
         2. 工具调用链（tool_use + tool_result）保持完整
@@ -878,6 +1148,9 @@ class AgentStreamExecutor:
         if not self.messages or not self.agent:
             return
 
+        # Step 0: Truncate large tool results in historical turns (30K -> 10K)
+        self._truncate_historical_tool_results()
+
         # Step 1: 识别完整轮次
         turns = self._identify_complete_turns()
         

agent/protocol/result.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import time
 import uuid
 from dataclasses import dataclass, field

agent/protocol/task.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import time
 import uuid
 from dataclasses import dataclass, field

agent/skills/__init__.py

@@ -15,6 +15,7 @@ from agent.skills.types import (
 )
 from agent.skills.loader import SkillLoader
 from agent.skills.manager import SkillManager
+from agent.skills.service import SkillService
 from agent.skills.formatter import format_skills_for_prompt
 
 __all__ = [
@@ -25,5 +26,6 @@ __all__ = [
     "LoadSkillsResult",
     "SkillLoader",
     "SkillManager",
+    "SkillService",
     "format_skills_for_prompt",
 ]

agent/skills/formatter.py

@@ -23,18 +23,15 @@ def format_skills_for_prompt(skills: List[Skill]) -> str:
         return ""
     
     lines = [
-        "\n\nThe following skills provide specialized instructions for specific tasks.",
-        "Use the read tool to load a skill's file when the task matches its description.",
         "",
         "<available_skills>",
     ]
-    
+
     for skill in visible_skills:
         lines.append("  <skill>")
         lines.append(f"    <name>{_escape_xml(skill.name)}</name>")
         lines.append(f"    <description>{_escape_xml(skill.description)}</description>")
         lines.append(f"    <location>{_escape_xml(skill.file_path)}</location>")
-        lines.append(f"    <base_dir>{_escape_xml(skill.base_dir)}</base_dir>")
         lines.append("  </skill>")
     
     lines.append("</available_skills>")

agent/skills/loader.py

@@ -12,25 +12,20 @@ from agent.skills.frontmatter import parse_frontmatter, parse_metadata, parse_bo
 
 class SkillLoader:
     """Loads skills from various directories."""
-    
-    def __init__(self, workspace_dir: Optional[str] = None):
-        """
-        Initialize the skill loader.
-        
-        :param workspace_dir: Agent workspace directory (for workspace-specific skills)
-        """
-        self.workspace_dir = workspace_dir
+
+    def __init__(self):
+        pass
     
     def load_skills_from_dir(self, dir_path: str, source: str) -> LoadSkillsResult:
         """
         Load skills from a directory.
-        
+
         Discovery rules:
         - Direct .md files in the root directory
         - Recursive SKILL.md files under subdirectories
-        
+
         :param dir_path: Directory path to scan
-        :param source: Source identifier (e.g., 'managed', 'workspace', 'bundled')
+        :param source: Source identifier ('builtin' or 'custom')
         :return: LoadSkillsResult with skills and diagnostics
         """
         skills = []
@@ -137,6 +132,18 @@ class SkillLoader:
         name = frontmatter.get('name', parent_dir_name)
         description = frontmatter.get('description', '')
         
+        # Normalize name (handle both string and list)
+        if isinstance(name, list):
+            name = name[0] if name else parent_dir_name
+        elif not isinstance(name, str):
+            name = str(name) if name else parent_dir_name
+        
+        # Normalize description (handle both string and list)
+        if isinstance(description, list):
+            description = ' '.join(str(d) for d in description if d)
+        elif not isinstance(description, str):
+            description = str(description) if description else ''
+        
         # Special handling for linkai-agent: dynamically load apps from config.json
         if name == 'linkai-agent':
             description = self._load_linkai_agent_description(skill_dir, description)
@@ -176,16 +183,14 @@ class SkillLoader:
         import json
         
         config_path = os.path.join(skill_dir, "config.json")
-        template_path = os.path.join(skill_dir, "config.json.template")
         
-        # Try to load config.json or fallback to template
-        config_file = config_path if os.path.exists(config_path) else template_path
-        
-        if not os.path.exists(config_file):
-            return default_description
+        # Without config.json, skip this skill entirely (return empty to trigger exclusion)
+        if not os.path.exists(config_path):
+            logger.debug(f"[SkillLoader] linkai-agent skipped: no config.json found")
+            return ""
         
         try:
-            with open(config_file, 'r', encoding='utf-8') as f:
+            with open(config_path, 'r', encoding='utf-8') as f:
                 config = json.load(f)
             
             apps = config.get("apps", [])
@@ -206,61 +211,49 @@ class SkillLoader:
     
     def load_all_skills(
         self,
-        managed_dir: Optional[str] = None,
-        workspace_skills_dir: Optional[str] = None,
-        extra_dirs: Optional[List[str]] = None,
+        builtin_dir: Optional[str] = None,
+        custom_dir: Optional[str] = None,
     ) -> Dict[str, SkillEntry]:
         """
-        Load skills from all configured locations with precedence.
-        
+        Load skills from builtin and custom directories.
+
         Precedence (lowest to highest):
-        1. Extra directories
-        2. Managed skills directory
-        3. Workspace skills directory
-        
-        :param managed_dir: Managed skills directory (e.g., ~/.cow/skills)
-        :param workspace_skills_dir: Workspace skills directory (e.g., workspace/skills)
-        :param extra_dirs: Additional directories to load skills from
+        1. builtin  — project root ``skills/``, shipped with the codebase
+        2. custom   — workspace ``skills/``, installed via cloud console or skill creator
+
+        Same-name custom skills override builtin ones.
+
+        :param builtin_dir: Built-in skills directory
+        :param custom_dir: Custom skills directory
         :return: Dictionary mapping skill name to SkillEntry
         """
         skill_map: Dict[str, SkillEntry] = {}
         all_diagnostics = []
-        
-        # Load from extra directories (lowest precedence)
-        if extra_dirs:
-            for extra_dir in extra_dirs:
-                if not os.path.exists(extra_dir):
-                    continue
-                result = self.load_skills_from_dir(extra_dir, source='extra')
-                all_diagnostics.extend(result.diagnostics)
-                for skill in result.skills:
-                    entry = self._create_skill_entry(skill)
-                    skill_map[skill.name] = entry
-        
-        # Load from managed directory
-        if managed_dir and os.path.exists(managed_dir):
-            result = self.load_skills_from_dir(managed_dir, source='managed')
+
+        # Load builtin skills (lower precedence)
+        if builtin_dir and os.path.exists(builtin_dir):
+            result = self.load_skills_from_dir(builtin_dir, source='builtin')
             all_diagnostics.extend(result.diagnostics)
             for skill in result.skills:
                 entry = self._create_skill_entry(skill)
                 skill_map[skill.name] = entry
-        
-        # Load from workspace directory (highest precedence)
-        if workspace_skills_dir and os.path.exists(workspace_skills_dir):
-            result = self.load_skills_from_dir(workspace_skills_dir, source='workspace')
+
+        # Load custom skills (higher precedence, overrides builtin)
+        if custom_dir and os.path.exists(custom_dir):
+            result = self.load_skills_from_dir(custom_dir, source='custom')
             all_diagnostics.extend(result.diagnostics)
             for skill in result.skills:
                 entry = self._create_skill_entry(skill)
                 skill_map[skill.name] = entry
-        
+
         # Log diagnostics
         if all_diagnostics:
             logger.debug(f"Skill loading diagnostics: {len(all_diagnostics)} issues")
-            for diag in all_diagnostics[:5]:  # Log first 5
+            for diag in all_diagnostics[:5]:
                 logger.debug(f"  - {diag}")
-        
-        logger.debug(f"Loaded {len(skill_map)} skills from all sources")
-        
+
+        logger.debug(f"Loaded {len(skill_map)} skills total")
+
         return skill_map
     
     def _create_skill_entry(self, skill: Skill) -> SkillEntry:

agent/skills/manager.py

@@ -3,6 +3,7 @@ Skill manager for managing skill lifecycle and operations.
 """
 
 import os
+import json
 from typing import Dict, List, Optional
 from pathlib import Path
 from common.log import logger
@@ -10,56 +11,131 @@ from agent.skills.types import Skill, SkillEntry, SkillSnapshot
 from agent.skills.loader import SkillLoader
 from agent.skills.formatter import format_skill_entries_for_prompt
 
+SKILLS_CONFIG_FILE = "skills_config.json"
+
 
 class SkillManager:
     """Manages skills for an agent."""
-    
+
     def __init__(
         self,
-        workspace_dir: Optional[str] = None,
-        managed_skills_dir: Optional[str] = None,
-        extra_dirs: Optional[List[str]] = None,
+        builtin_dir: Optional[str] = None,
+        custom_dir: Optional[str] = None,
         config: Optional[Dict] = None,
     ):
         """
         Initialize the skill manager.
-        
-        :param workspace_dir: Agent workspace directory
-        :param managed_skills_dir: Managed skills directory (e.g., ~/.cow/skills)
-        :param extra_dirs: Additional skill directories
+
+        :param builtin_dir: Built-in skills directory (project root ``skills/``)
+        :param custom_dir: Custom skills directory (workspace ``skills/``)
         :param config: Configuration dictionary
         """
-        self.workspace_dir = workspace_dir
-        self.managed_skills_dir = managed_skills_dir or self._get_default_managed_dir()
-        self.extra_dirs = extra_dirs or []
+        project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        self.builtin_dir = builtin_dir or os.path.join(project_root, 'skills')
+        self.custom_dir = custom_dir or os.path.join(project_root, 'workspace', 'skills')
         self.config = config or {}
-        
-        self.loader = SkillLoader(workspace_dir=workspace_dir)
+        self._skills_config_path = os.path.join(self.custom_dir, SKILLS_CONFIG_FILE)
+
+        # skills_config: full skill metadata keyed by name
+        # { "web-fetch": {"name": ..., "description": ..., "source": ..., "enabled": true}, ... }
+        self.skills_config: Dict[str, dict] = {}
+
+        self.loader = SkillLoader()
         self.skills: Dict[str, SkillEntry] = {}
-        
+
         # Load skills on initialization
         self.refresh_skills()
-    
-    def _get_default_managed_dir(self) -> str:
-        """Get the default managed skills directory."""
-        # Use project root skills directory as default
-        import os
-        project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-        return os.path.join(project_root, 'skills')
-    
+
     def refresh_skills(self):
-        """Reload all skills from configured directories."""
-        workspace_skills_dir = None
-        if self.workspace_dir:
-            workspace_skills_dir = os.path.join(self.workspace_dir, 'skills')
-        
+        """Reload all skills from builtin and custom directories, then sync config."""
         self.skills = self.loader.load_all_skills(
-            managed_dir=self.managed_skills_dir,
-            workspace_skills_dir=workspace_skills_dir,
-            extra_dirs=self.extra_dirs,
+            builtin_dir=self.builtin_dir,
+            custom_dir=self.custom_dir,
         )
-        
+        self._sync_skills_config()
         logger.debug(f"SkillManager: Loaded {len(self.skills)} skills")
+
+    # ------------------------------------------------------------------
+    # skills_config.json management
+    # ------------------------------------------------------------------
+    def _load_skills_config(self) -> Dict[str, dict]:
+        """Load skills_config.json from custom_dir. Returns empty dict if not found."""
+        if not os.path.exists(self._skills_config_path):
+            return {}
+        try:
+            with open(self._skills_config_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            if isinstance(data, dict):
+                return data
+        except Exception as e:
+            logger.warning(f"[SkillManager] Failed to load {SKILLS_CONFIG_FILE}: {e}")
+        return {}
+
+    def _save_skills_config(self):
+        """Persist skills_config to custom_dir/skills_config.json."""
+        os.makedirs(self.custom_dir, exist_ok=True)
+        try:
+            with open(self._skills_config_path, "w", encoding="utf-8") as f:
+                json.dump(self.skills_config, f, indent=4, ensure_ascii=False)
+        except Exception as e:
+            logger.error(f"[SkillManager] Failed to save {SKILLS_CONFIG_FILE}: {e}")
+
+    def _sync_skills_config(self):
+        """
+        Merge directory-scanned skills with the persisted config file.
+
+        - New skills discovered on disk are added with enabled=True.
+        - Skills that no longer exist on disk are removed.
+        - Existing entries preserve their enabled state; name/description/source
+          are refreshed from the latest scan.
+        """
+        saved = self._load_skills_config()
+        merged: Dict[str, dict] = {}
+
+        for name, entry in self.skills.items():
+            skill = entry.skill
+            prev = saved.get(name, {})
+            merged[name] = {
+                "name": name,
+                "description": skill.description,
+                "source": skill.source,
+                "enabled": prev.get("enabled", True),
+            }
+
+        self.skills_config = merged
+        self._save_skills_config()
+
+    def is_skill_enabled(self, name: str) -> bool:
+        """
+        Check if a skill is enabled according to skills_config.
+
+        :param name: skill name
+        :return: True if enabled (default True if not in config)
+        """
+        entry = self.skills_config.get(name)
+        if entry is None:
+            return True
+        return entry.get("enabled", True)
+
+    def set_skill_enabled(self, name: str, enabled: bool):
+        """
+        Set a skill's enabled state and persist.
+
+        :param name: skill name
+        :param enabled: True to enable, False to disable
+        """
+        if name not in self.skills_config:
+            raise ValueError(f"skill '{name}' not found in config")
+        self.skills_config[name]["enabled"] = enabled
+        self._save_skills_config()
+
+    def get_skills_config(self) -> Dict[str, dict]:
+        """
+        Return the full skills_config dict (for query API).
+
+        :return: copy of skills_config
+        """
+        return dict(self.skills_config)
     
     def get_skill(self, name: str) -> Optional[SkillEntry]:
         """
@@ -85,32 +161,43 @@ class SkillManager:
     ) -> List[SkillEntry]:
         """
         Filter skills based on criteria.
-        
+
         Simple rule: Skills are auto-enabled if requirements are met.
-        - Has required API keys → included
-        - Missing API keys → excluded
-        
+        - Has required API keys -> included
+        - Missing API keys -> excluded
+
         :param skill_filter: List of skill names to include (None = all)
-        :param include_disabled: Whether to include skills with disable_model_invocation=True
+        :param include_disabled: Whether to include disabled skills
         :return: Filtered list of skill entries
         """
         from agent.skills.config import should_include_skill
-        
+
         entries = list(self.skills.values())
-        
+
         # Check requirements (platform, binaries, env vars)
         entries = [e for e in entries if should_include_skill(e, self.config)]
-        
+
         # Apply skill filter
         if skill_filter is not None:
-            normalized = [name.strip() for name in skill_filter if name.strip()]
+            normalized = []
+            for item in skill_filter:
+                if isinstance(item, str):
+                    name = item.strip()
+                    if name:
+                        normalized.append(name)
+                elif isinstance(item, list):
+                    for subitem in item:
+                        if isinstance(subitem, str):
+                            name = subitem.strip()
+                            if name:
+                                normalized.append(name)
             if normalized:
                 entries = [e for e in entries if e.skill.name in normalized]
-        
-        # Filter out disabled skills unless explicitly requested
+
+        # Filter out disabled skills based on skills_config.json
         if not include_disabled:
-            entries = [e for e in entries if not e.skill.disable_model_invocation]
-        
+            entries = [e for e in entries if self.is_skill_enabled(e.skill.name)]
+
         return entries
     
     def build_skills_prompt(
@@ -123,8 +210,15 @@ class SkillManager:
         :param skill_filter: Optional list of skill names to include
         :return: Formatted skills prompt
         """
+        from common.log import logger
         entries = self.filter_skills(skill_filter=skill_filter, include_disabled=False)
-        return format_skill_entries_for_prompt(entries)
+        logger.debug(f"[SkillManager] Filtered {len(entries)} skills for prompt (total: {len(self.skills)})")
+        if entries:
+            skill_names = [e.skill.name for e in entries]
+            logger.debug(f"[SkillManager] Skills to include: {skill_names}")
+        result = format_skill_entries_for_prompt(entries)
+        logger.debug(f"[SkillManager] Generated prompt length: {len(result)}")
+        return result
     
     def build_skill_snapshot(
         self,

agent/skills/service.py

@@ -0,0 +1,204 @@
+"""
+Skill service for handling skill CRUD operations.
+
+This service provides a unified interface for managing skills, which can be
+called from the cloud control client (LinkAI), the local web console, or any
+other management entry point.
+"""
+
+import os
+import shutil
+from typing import Dict, List, Optional
+from common.log import logger
+from agent.skills.types import Skill, SkillEntry
+from agent.skills.manager import SkillManager
+
+try:
+    import requests
+except ImportError:
+    requests = None
+
+
+class SkillService:
+    """
+    High-level service for skill lifecycle management.
+    Wraps SkillManager and provides network-aware operations such as
+    downloading skill files from remote URLs.
+    """
+
+    def __init__(self, skill_manager: SkillManager):
+        """
+        :param skill_manager: The SkillManager instance to operate on
+        """
+        self.manager = skill_manager
+
+    # ------------------------------------------------------------------
+    # query
+    # ------------------------------------------------------------------
+    def query(self) -> List[dict]:
+        """
+        Query all skills and return a serialisable list.
+        Reads from skills_config.json (refreshes from disk if needed).
+
+        :return: list of skill info dicts
+        """
+        self.manager.refresh_skills()
+        config = self.manager.get_skills_config()
+        result = list(config.values())
+        logger.info(f"[SkillService] query: {len(result)} skills found")
+        return result
+
+    # ------------------------------------------------------------------
+    # add / install
+    # ------------------------------------------------------------------
+    def add(self, payload: dict) -> None:
+        """
+        Add (install) a skill from a remote payload.
+
+        The payload follows the socket protocol::
+
+            {
+                "name": "web_search",
+                "type": "url",
+                "enabled": true,
+                "files": [
+                    {"url": "https://...", "path": "README.md"},
+                    {"url": "https://...", "path": "scripts/main.py"}
+                ]
+            }
+
+        Files are downloaded and saved under the custom skills directory
+        using *name* as the sub-directory.
+
+        :param payload: skill add payload from server
+        """
+        name = payload.get("name")
+        if not name:
+            raise ValueError("skill name is required")
+
+        files = payload.get("files", [])
+        if not files:
+            raise ValueError("skill files list is empty")
+
+        skill_dir = os.path.join(self.manager.custom_dir, name)
+        os.makedirs(skill_dir, exist_ok=True)
+
+        for file_info in files:
+            url = file_info.get("url")
+            rel_path = file_info.get("path")
+            if not url or not rel_path:
+                logger.warning(f"[SkillService] add: skip invalid file entry {file_info}")
+                continue
+            dest = os.path.join(skill_dir, rel_path)
+            self._download_file(url, dest)
+
+        # Reload to pick up the new skill and sync config
+        self.manager.refresh_skills()
+        logger.info(f"[SkillService] add: skill '{name}' installed ({len(files)} files)")
+
+    # ------------------------------------------------------------------
+    # open / close (enable / disable)
+    # ------------------------------------------------------------------
+    def open(self, payload: dict) -> None:
+        """
+        Enable a skill by name.
+
+        :param payload: {"name": "skill_name"}
+        """
+        name = payload.get("name")
+        if not name:
+            raise ValueError("skill name is required")
+        self.manager.set_skill_enabled(name, enabled=True)
+        logger.info(f"[SkillService] open: skill '{name}' enabled")
+
+    def close(self, payload: dict) -> None:
+        """
+        Disable a skill by name.
+
+        :param payload: {"name": "skill_name"}
+        """
+        name = payload.get("name")
+        if not name:
+            raise ValueError("skill name is required")
+        self.manager.set_skill_enabled(name, enabled=False)
+        logger.info(f"[SkillService] close: skill '{name}' disabled")
+
+    # ------------------------------------------------------------------
+    # delete
+    # ------------------------------------------------------------------
+    def delete(self, payload: dict) -> None:
+        """
+        Delete a skill by removing its directory entirely.
+
+        :param payload: {"name": "skill_name"}
+        """
+        name = payload.get("name")
+        if not name:
+            raise ValueError("skill name is required")
+
+        skill_dir = os.path.join(self.manager.custom_dir, name)
+        if os.path.exists(skill_dir):
+            shutil.rmtree(skill_dir)
+            logger.info(f"[SkillService] delete: removed directory {skill_dir}")
+        else:
+            logger.warning(f"[SkillService] delete: skill directory not found: {skill_dir}")
+
+        # Refresh will remove the deleted skill from config automatically
+        self.manager.refresh_skills()
+        logger.info(f"[SkillService] delete: skill '{name}' deleted")
+
+    # ------------------------------------------------------------------
+    # dispatch - single entry point for protocol messages
+    # ------------------------------------------------------------------
+    def dispatch(self, action: str, payload: Optional[dict] = None) -> dict:
+        """
+        Dispatch a skill management action and return a protocol-compatible
+        response dict.
+
+        :param action: one of query / add / open / close / delete
+        :param payload: action-specific payload (may be None for query)
+        :return: dict with action, code, message, payload
+        """
+        payload = payload or {}
+        try:
+            if action == "query":
+                result_payload = self.query()
+                return {"action": action, "code": 200, "message": "success", "payload": result_payload}
+            elif action == "add":
+                self.add(payload)
+            elif action == "open":
+                self.open(payload)
+            elif action == "close":
+                self.close(payload)
+            elif action == "delete":
+                self.delete(payload)
+            else:
+                return {"action": action, "code": 400, "message": f"unknown action: {action}", "payload": None}
+            return {"action": action, "code": 200, "message": "success", "payload": None}
+        except Exception as e:
+            logger.error(f"[SkillService] dispatch error: action={action}, error={e}")
+            return {"action": action, "code": 500, "message": str(e), "payload": None}
+
+    # ------------------------------------------------------------------
+    # internal helpers
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _download_file(url: str, dest: str):
+        """
+        Download a file from *url* and save to *dest*.
+
+        :param url: remote file URL
+        :param dest: local destination path
+        """
+        if requests is None:
+            raise RuntimeError("requests library is required for downloading skill files")
+
+        dest_dir = os.path.dirname(dest)
+        if dest_dir:
+            os.makedirs(dest_dir, exist_ok=True)
+
+        resp = requests.get(url, timeout=60)
+        resp.raise_for_status()
+        with open(dest, "wb") as f:
+            f.write(resp.content)
+        logger.debug(f"[SkillService] downloaded {url} -> {dest}")

agent/skills/types.py

@@ -2,6 +2,7 @@
 Type definitions for skills system.
 """
 
+from __future__ import annotations
 from typing import Dict, List, Optional, Any
 from dataclasses import dataclass, field
 
@@ -44,7 +45,7 @@ class Skill:
     description: str
     file_path: str
     base_dir: str
-    source: str  # managed, workspace, bundled, etc.
+    source: str  # builtin or custom
     content: str  # Full markdown content
     disable_model_invocation: bool = False
     frontmatter: Dict[str, Any] = field(default_factory=dict)

agent/tools/__init__.py

@@ -45,16 +45,25 @@ def _import_optional_tools():
         )
     except Exception as e:
         logger.error(f"[Tools] Scheduler tool failed to load: {e}")
-    
-    
+
+    # WebSearch Tool (conditionally loaded based on API key availability at init time)
+    try:
+        from agent.tools.web_search.web_search import WebSearch
+        tools['WebSearch'] = WebSearch
+    except ImportError as e:
+        logger.error(f"[Tools] WebSearch not loaded - missing dependency: {e}")
+    except Exception as e:
+        logger.error(f"[Tools] WebSearch failed to load: {e}")
+
     return tools
 
 # Load optional tools
 _optional_tools = _import_optional_tools()
 EnvConfig = _optional_tools.get('EnvConfig')
 SchedulerTool = _optional_tools.get('SchedulerTool')
+WebSearch = _optional_tools.get('WebSearch')
 GoogleSearch = _optional_tools.get('GoogleSearch')
-FileSave = _optional_tools.get('FileSave') 
+FileSave = _optional_tools.get('FileSave')
 Terminal = _optional_tools.get('Terminal')
 
 
@@ -92,6 +101,7 @@ __all__ = [
     'MemoryGetTool',
     'EnvConfig',
     'SchedulerTool',
+    'WebSearch',
     # Optional tools (may be None if dependencies not available)
     # 'BrowserTool'
 ]

agent/tools/bash/bash.py

@@ -11,6 +11,7 @@ from typing import Dict, Any
 from agent.tools.base_tool import BaseTool, ToolResult
 from agent.tools.utils.truncate import truncate_tail, format_size, DEFAULT_MAX_LINES, DEFAULT_MAX_BYTES
 from common.log import logger
+from common.utils import expand_path
 
 
 class Bash(BaseTool):
@@ -19,10 +20,11 @@ class Bash(BaseTool):
     name: str = "bash"
     description: str = f"""Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last {DEFAULT_MAX_LINES} lines or {DEFAULT_MAX_BYTES // 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file.
 
-IMPORTANT SAFETY GUIDELINES:
-- You can freely create, modify, and delete files within the current workspace
-- For operations outside the workspace or potentially destructive commands (rm -rf, system commands, etc.), always explain what you're about to do and ask for user confirmation first
-- When in doubt, describe the command's purpose and ask for permission before executing"""
+ENVIRONMENT: All API keys from env_config are auto-injected. Use $VAR_NAME directly.
+
+SAFETY:
+- Freely create/modify/delete files within the workspace
+- For destructive and out-of-workspace commands, explain and confirm first"""
 
     params: dict = {
         "type": "object",
@@ -80,7 +82,7 @@ IMPORTANT SAFETY GUIDELINES:
             env = os.environ.copy()
             
             # Load environment variables from ~/.cow/.env if it exists
-            env_file = os.path.expanduser("~/.cow/.env")
+            env_file = expand_path("~/.cow/.env")
             if os.path.exists(env_file):
                 try:
                     from dotenv import dotenv_values
@@ -91,14 +93,12 @@ IMPORTANT SAFETY GUIDELINES:
                     logger.debug("[Bash] python-dotenv not installed, skipping .env loading")
                 except Exception as e:
                     logger.debug(f"[Bash] Failed to load .env: {e}")
-            
-            # Debug logging
-            logger.debug(f"[Bash] CWD: {self.cwd}")
-            logger.debug(f"[Bash] Command: {command[:500]}")
-            logger.debug(f"[Bash] OPENAI_API_KEY in env: {'OPENAI_API_KEY' in env}")
-            logger.debug(f"[Bash] SHELL: {env.get('SHELL', 'not set')}")
-            logger.debug(f"[Bash] Python executable: {sys.executable}")
-            logger.debug(f"[Bash] Process UID: {os.getuid()}")
+
+            # getuid() only exists on Unix-like systems
+            if hasattr(os, 'getuid'):
+                logger.debug(f"[Bash] Process UID: {os.getuid()}")
+            else:
+                logger.debug(f"[Bash] Process User: {os.environ.get('USERNAME', os.environ.get('USER', 'unknown'))}")
             
             # Execute command with inherited environment variables
             result = subprocess.run(

agent/tools/edit/edit.py

@@ -7,6 +7,7 @@ import os
 from typing import Dict, Any
 
 from agent.tools.base_tool import BaseTool, ToolResult
+from common.utils import expand_path
 from agent.tools.utils.diff import (
     strip_bom,
     detect_line_ending,
@@ -178,7 +179,7 @@ class Edit(BaseTool):
         :return: Absolute path
         """
         # Expand ~ to user home directory
-        path = os.path.expanduser(path)
+        path = expand_path(path)
         if os.path.isabs(path):
             return path
         return os.path.abspath(os.path.join(self.cwd, path))

agent/tools/env_config/env_config.py

@@ -9,6 +9,7 @@ from pathlib import Path
 
 from agent.tools.base_tool import BaseTool, ToolResult
 from common.log import logger
+from common.utils import expand_path
 
 
 # API Key 知识库：常见的环境变量及其描述
@@ -66,7 +67,7 @@ class EnvConfig(BaseTool):
     def __init__(self, config: dict = None):
         self.config = config or {}
         # Store env config in ~/.cow directory (outside workspace for security)
-        self.env_dir = os.path.expanduser("~/.cow")
+        self.env_dir = expand_path("~/.cow")
         self.env_path = os.path.join(self.env_dir, '.env')
         self.agent_bridge = self.config.get("agent_bridge")  # Reference to AgentBridge for hot reload
         # Don't create .env file in __init__ to avoid issues during tool discovery
@@ -201,7 +202,8 @@ class EnvConfig(BaseTool):
                         "key": key,
                         "value": self._mask_value(value),
                         "description": description,
-                        "exists": True
+                        "exists": True,
+                        "note": f"Value is masked for security. In bash, use ${key} directly — it is auto-injected."
                     })
                 else:
                     return ToolResult.success({

agent/tools/ls/ls.py

@@ -7,6 +7,7 @@ from typing import Dict, Any
 
 from agent.tools.base_tool import BaseTool, ToolResult
 from agent.tools.utils.truncate import truncate_head, format_size, DEFAULT_MAX_BYTES
+from common.utils import expand_path
 
 
 DEFAULT_LIMIT = 500
@@ -51,7 +52,7 @@ class Ls(BaseTool):
         absolute_path = self._resolve_path(path)
         
         # Security check: Prevent accessing sensitive config directory
-        env_config_dir = os.path.expanduser("~/.cow")
+        env_config_dir = expand_path("~/.cow")
         if os.path.abspath(absolute_path) == os.path.abspath(env_config_dir):
             return ToolResult.fail(
                 "Error: Access denied. API keys and credentials must be accessed through the env_config tool only."
@@ -93,7 +94,7 @@ class Ls(BaseTool):
                         results.append(entry + '/')
                     else:
                         results.append(entry)
-                except:
+                except Exception:
                     # Skip entries we can't stat
                     continue
             
@@ -133,7 +134,7 @@ class Ls(BaseTool):
     def _resolve_path(self, path: str) -> str:
         """Resolve path to absolute path"""
         # Expand ~ to user home directory
-        path = os.path.expanduser(path)
+        path = expand_path(path)
         if os.path.isabs(path):
             return path
         return os.path.abspath(os.path.join(self.cwd, path))

agent/tools/memory/memory_get.py

@@ -77,7 +77,7 @@ class MemoryGetTool(BaseTool):
             if not file_path.exists():
                 return ToolResult.fail(f"Error: File not found: {path}")
             
-            content = file_path.read_text()
+            content = file_path.read_text(encoding='utf-8')
             lines = content.split('\n')
             
             # Handle line range

agent/tools/read/read.py

@@ -9,6 +9,7 @@ from pathlib import Path
 
 from agent.tools.base_tool import BaseTool, ToolResult
 from agent.tools.utils.truncate import truncate_head, format_size, DEFAULT_MAX_LINES, DEFAULT_MAX_BYTES
+from common.utils import expand_path
 
 
 class Read(BaseTool):
@@ -66,10 +67,12 @@ class Read(BaseTool):
         :param args: Contains file path and optional offset/limit parameters
         :return: File content or error message
         """
-        path = args.get("path", "").strip()
+        # Support 'location' as alias for 'path' (LLM may use it from skill listing)
+        path = args.get("path", "") or args.get("location", "")
+        path = path.strip() if isinstance(path, str) else ""
         offset = args.get("offset")
         limit = args.get("limit")
-        
+
         if not path:
             return ToolResult.fail("Error: path parameter is required")
         
@@ -77,7 +80,7 @@ class Read(BaseTool):
         absolute_path = self._resolve_path(path)
         
         # Security check: Prevent reading sensitive config files
-        env_config_path = os.path.expanduser("~/.cow/.env")
+        env_config_path = expand_path("~/.cow/.env")
         if os.path.abspath(absolute_path) == os.path.abspath(env_config_path):
             return ToolResult.fail(
                 "Error: Access denied. API keys and credentials must be accessed through the env_config tool only."
@@ -129,7 +132,7 @@ class Read(BaseTool):
         :return: Absolute path
         """
         # Expand ~ to user home directory
-        path = os.path.expanduser(path)
+        path = expand_path(path)
         if os.path.isabs(path):
             return path
         return os.path.abspath(os.path.join(self.cwd, path))

agent/tools/scheduler/integration.py

@@ -6,6 +6,7 @@ import os
 from typing import Optional
 from config import conf
 from common.log import logger
+from common.utils import expand_path
 from bridge.context import Context, ContextType
 from bridge.reply import Reply, ReplyType
 
@@ -31,7 +32,7 @@ def init_scheduler(agent_bridge) -> bool:
         from agent.tools.scheduler.scheduler_service import SchedulerService
         
         # Get workspace from config
-        workspace_root = os.path.expanduser(conf().get("agent_workspace", "~/cow"))
+        workspace_root = expand_path(conf().get("agent_workspace", "~/cow"))
         store_path = os.path.join(workspace_root, "scheduler", "tasks.json")
         
         # Create task store
@@ -112,11 +113,15 @@ def _execute_agent_task(task: dict, agent_bridge):
         
         logger.info(f"[Scheduler] Task {task['id']}: Executing agent task '{task_description}'")
         
+        # Create a unique session_id for this scheduled task to avoid polluting user's conversation
+        # Format: scheduler_<receiver>_<task_id> to ensure isolation
+        scheduler_session_id = f"scheduler_{receiver}_{task['id']}"
+        
         # Create context for Agent
         context = Context(ContextType.TEXT, task_description)
         context["receiver"] = receiver
         context["isgroup"] = is_group
-        context["session_id"] = receiver
+        context["session_id"] = scheduler_session_id
         
         # Channel-specific setup
         if channel_type == "web":
@@ -140,7 +145,8 @@ def _execute_agent_task(task: dict, agent_bridge):
         context["is_scheduled_task"] = True
         
         try:
-            reply = agent_bridge.agent_reply(task_description, context=context, on_event=None, clear_history=True)
+            # Don't clear history - scheduler tasks use isolated session_id so they won't pollute user conversations
+            reply = agent_bridge.agent_reply(task_description, context=context, on_event=None, clear_history=False)
             
             if reply and reply.content:
                 # Send the reply via channel
@@ -378,6 +384,10 @@ def _execute_skill_call(task: dict, agent_bridge):
         
         logger.info(f"[Scheduler] Task {task['id']}: Executing skill '{skill_name}' with params {skill_params}")
         
+        # Create a unique session_id for this scheduled task to avoid polluting user's conversation
+        # Format: scheduler_<receiver>_<task_id> to ensure isolation
+        scheduler_session_id = f"scheduler_{receiver}_{task['id']}"
+        
         # Build a natural language query for the Agent to execute the skill
         # Format: "Use skill-name to do something with params"
         param_str = ", ".join([f"{k}={v}" for k, v in skill_params.items()])
@@ -389,7 +399,7 @@ def _execute_skill_call(task: dict, agent_bridge):
         context = Context(ContextType.TEXT, query)
         context["receiver"] = receiver
         context["isgroup"] = is_group
-        context["session_id"] = receiver
+        context["session_id"] = scheduler_session_id
         
         # Channel-specific setup
         if channel_type == "web":
@@ -402,7 +412,8 @@ def _execute_skill_call(task: dict, agent_bridge):
         
         # Use Agent to execute the skill
         try:
-            reply = agent_bridge.agent_reply(query, context=context, on_event=None, clear_history=True)
+            # Don't clear history - scheduler tasks use isolated session_id so they won't pollute user conversations
+            reply = agent_bridge.agent_reply(query, context=context, on_event=None, clear_history=False)
             
             if reply and reply.content:
                 content = reply.content
@@ -440,8 +451,7 @@ def attach_scheduler_to_tool(tool, context: Context = None):
     if context:
         tool.current_context = context
         
-        # Also set channel_type from config
-        channel_type = conf().get("channel_type", "unknown")
+        channel_type = context.get("channel_type") or conf().get("channel_type", "unknown")
         if not tool.config:
             tool.config = {}
         tool.config["channel_type"] = channel_type

agent/tools/scheduler/scheduler_service.py

@@ -147,7 +147,7 @@ class SchedulerService:
                     return False
             
             return now >= next_run
-        except:
+        except Exception:
             return False
     
     def _calculate_next_run(self, task: dict, from_time: datetime) -> Optional[datetime]:
@@ -195,7 +195,7 @@ class SchedulerService:
                 # Only return if in the future
                 if run_at > from_time:
                     return run_at
-            except:
+            except Exception:
                 pass
             return None
         

agent/tools/scheduler/scheduler_tool.py

@@ -20,7 +20,8 @@ class SchedulerTool(BaseTool):
     
     name: str = "scheduler"
     description: str = (
-        "创建、查询和管理定时任务。支持固定消息和AI任务两种类型。\n\n"
+        "创建、查询和管理定时任务（提醒、周期性任务等）。\n\n"
+        "⚠️ 重要：仅当需要「定时/提醒/每天/每周/X分钟后/X点」等延迟或周期执行时才使用此工具。"
         "使用方法：\n"
         "- 创建：action='create', name='任务名', message/ai_task='内容', schedule_type='once/interval/cron', schedule_value='...'\n"
         "- 查询：action='list' / action='get', task_id='任务ID'\n"
@@ -53,7 +54,7 @@ class SchedulerTool(BaseTool):
             },
             "ai_task": {
                 "type": "string",
-                "description": "AI任务描述 (与message二选一)，如'搜索今日新闻'、'查询天气'"
+                "description": "AI任务描述 (与message二选一)，用于定时让AI执行的任务"
             },
             "schedule_type": {
                 "type": "string",
@@ -423,7 +424,7 @@ class SchedulerTool(BaseTool):
             try:
                 dt = datetime.fromisoformat(run_at)
                 return f"一次性 ({dt.strftime('%Y-%m-%d %H:%M')})"
-            except:
+            except Exception:
                 return "一次性"
         
         return "未知"
@@ -437,6 +438,6 @@ class SchedulerTool(BaseTool):
                     return msg.other_user_nickname or "群聊"
                 else:
                     return msg.from_user_nickname or "用户"
-        except:
+        except Exception:
             pass
         return "未知"

agent/tools/scheduler/task_store.py

@@ -8,6 +8,7 @@ import threading
 from datetime import datetime
 from typing import Dict, List, Optional
 from pathlib import Path
+from common.utils import expand_path
 
 
 class TaskStore:
@@ -24,7 +25,7 @@ class TaskStore:
         """
         if store_path is None:
             # Default to ~/cow/scheduler/tasks.json
-            home = os.path.expanduser("~")
+            home = expand_path("~")
             store_path = os.path.join(home, "cow", "scheduler", "tasks.json")
         
         self.store_path = store_path
@@ -71,7 +72,7 @@ class TaskStore:
                         with open(self.store_path, 'r') as src:
                             with open(backup_path, 'w') as dst:
                                 dst.write(src.read())
-                    except:
+                    except Exception:
                         pass
                 
                 # Save tasks

agent/tools/send/send.py

@@ -7,6 +7,7 @@ from typing import Dict, Any
 from pathlib import Path
 
 from agent.tools.base_tool import BaseTool, ToolResult
+from common.utils import expand_path
 
 
 class Send(BaseTool):
@@ -102,7 +103,7 @@ class Send(BaseTool):
     
     def _resolve_path(self, path: str) -> str:
         """Resolve path to absolute path"""
-        path = os.path.expanduser(path)
+        path = expand_path(path)
         if os.path.isabs(path):
             return path
         return os.path.abspath(os.path.join(self.cwd, path))

agent/tools/utils/truncate.py

@@ -8,7 +8,7 @@ Truncation is based on two independent limits - whichever is hit first wins:
 Never returns partial lines (except bash tail truncation edge case).
 """
 
-from typing import Dict, Any, Optional, Literal
+from typing import Dict, Any, Optional, Literal, Tuple
 
 
 DEFAULT_MAX_LINES = 2000
@@ -278,7 +278,7 @@ def _truncate_string_to_bytes_from_end(text: str, max_bytes: int) -> str:
     return encoded[start:].decode('utf-8', errors='ignore')
 
 
-def truncate_line(line: str, max_chars: int = GREP_MAX_LINE_LENGTH) -> tuple[str, bool]:
+def truncate_line(line: str, max_chars: int = GREP_MAX_LINE_LENGTH) -> Tuple[str, bool]:
     """
     Truncate single line to max characters, add [truncated] suffix.
     Used for grep match lines.

agent/tools/web_search/__init__.py

@@ -0,0 +1,3 @@
+from agent.tools.web_search.web_search import WebSearch
+
+__all__ = ["WebSearch"]

agent/tools/web_search/web_search.py

@@ -0,0 +1,322 @@
+"""
+Web Search tool - Search the web using Bocha or LinkAI search API.
+Supports two backends with unified response format:
+  1. Bocha Search (primary, requires BOCHA_API_KEY)
+  2. LinkAI Search (fallback, requires LINKAI_API_KEY)
+"""
+
+import os
+import json
+from typing import Dict, Any, Optional
+
+import requests
+
+from agent.tools.base_tool import BaseTool, ToolResult
+from common.log import logger
+
+
+# Default timeout for API requests (seconds)
+DEFAULT_TIMEOUT = 30
+
+
+class WebSearch(BaseTool):
+    """Tool for searching the web using Bocha or LinkAI search API"""
+
+    name: str = "web_search"
+    description: str = (
+        "Search the web for current information, news, research topics, or any real-time data. "
+        "Returns web page titles, URLs, snippets, and optional summaries. "
+        "Use this when the user asks about recent events, needs fact-checking, or wants up-to-date information."
+    )
+
+    params: dict = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "Search query string"
+            },
+            "count": {
+                "type": "integer",
+                "description": "Number of results to return (1-50, default: 10)"
+            },
+            "freshness": {
+                "type": "string",
+                "description": (
+                    "Time range filter. Options: "
+                    "'noLimit' (default), 'oneDay', 'oneWeek', 'oneMonth', 'oneYear', "
+                    "or date range like '2025-01-01..2025-02-01'"
+                )
+            },
+            "summary": {
+                "type": "boolean",
+                "description": "Whether to include text summary for each result (default: false)"
+            }
+        },
+        "required": ["query"]
+    }
+
+    def __init__(self, config: dict = None):
+        self.config = config or {}
+        self._backend = None  # Will be resolved on first execute
+
+    @staticmethod
+    def is_available() -> bool:
+        """Check if web search is available (at least one API key is configured)"""
+        return bool(os.environ.get("BOCHA_API_KEY") or os.environ.get("LINKAI_API_KEY"))
+
+    def _resolve_backend(self) -> Optional[str]:
+        """
+        Determine which search backend to use.
+        Priority: Bocha > LinkAI
+
+        :return: 'bocha', 'linkai', or None
+        """
+        if os.environ.get("BOCHA_API_KEY"):
+            return "bocha"
+        if os.environ.get("LINKAI_API_KEY"):
+            return "linkai"
+        return None
+
+    def execute(self, args: Dict[str, Any]) -> ToolResult:
+        """
+        Execute web search
+
+        :param args: Search parameters (query, count, freshness, summary)
+        :return: Search results
+        """
+        query = args.get("query", "").strip()
+        if not query:
+            return ToolResult.fail("Error: 'query' parameter is required")
+
+        count = args.get("count", 10)
+        freshness = args.get("freshness", "noLimit")
+        summary = args.get("summary", False)
+
+        # Validate count
+        if not isinstance(count, int) or count < 1 or count > 50:
+            count = 10
+
+        # Resolve backend
+        backend = self._resolve_backend()
+        if not backend:
+            return ToolResult.fail(
+                "Error: No search API key configured. "
+                "Please set BOCHA_API_KEY or LINKAI_API_KEY using env_config tool.\n"
+                "  - Bocha Search: https://open.bocha.cn\n"
+                "  - LinkAI Search: https://link-ai.tech"
+            )
+
+        try:
+            if backend == "bocha":
+                return self._search_bocha(query, count, freshness, summary)
+            else:
+                return self._search_linkai(query, count, freshness)
+        except requests.Timeout:
+            return ToolResult.fail(f"Error: Search request timed out after {DEFAULT_TIMEOUT}s")
+        except requests.ConnectionError:
+            return ToolResult.fail("Error: Failed to connect to search API")
+        except Exception as e:
+            logger.error(f"[WebSearch] Unexpected error: {e}", exc_info=True)
+            return ToolResult.fail(f"Error: Search failed - {str(e)}")
+
+    def _search_bocha(self, query: str, count: int, freshness: str, summary: bool) -> ToolResult:
+        """
+        Search using Bocha API
+
+        :param query: Search query
+        :param count: Number of results
+        :param freshness: Time range filter
+        :param summary: Whether to include summary
+        :return: Formatted search results
+        """
+        api_key = os.environ.get("BOCHA_API_KEY", "")
+        url = "https://api.bocha.cn/v1/web-search"
+
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        }
+
+        payload = {
+            "query": query,
+            "count": count,
+            "freshness": freshness,
+            "summary": summary
+        }
+
+        logger.debug(f"[WebSearch] Bocha search: query='{query}', count={count}")
+
+        response = requests.post(url, headers=headers, json=payload, timeout=DEFAULT_TIMEOUT)
+
+        if response.status_code == 401:
+            return ToolResult.fail("Error: Invalid BOCHA_API_KEY. Please check your API key.")
+        if response.status_code == 403:
+            return ToolResult.fail("Error: Bocha API - insufficient balance. Please top up at https://open.bocha.cn")
+        if response.status_code == 429:
+            return ToolResult.fail("Error: Bocha API rate limit reached. Please try again later.")
+        if response.status_code != 200:
+            return ToolResult.fail(f"Error: Bocha API returned HTTP {response.status_code}")
+
+        data = response.json()
+
+        # Check API-level error code
+        api_code = data.get("code")
+        if api_code is not None and api_code != 200:
+            msg = data.get("msg") or "Unknown error"
+            return ToolResult.fail(f"Error: Bocha API error (code={api_code}): {msg}")
+
+        # Extract and format results
+        return self._format_bocha_results(data, query)
+
+    def _format_bocha_results(self, data: dict, query: str) -> ToolResult:
+        """
+        Format Bocha API response into unified result structure
+
+        :param data: Raw API response
+        :param query: Original query
+        :return: Formatted ToolResult
+        """
+        search_data = data.get("data", {})
+        web_pages = search_data.get("webPages", {})
+        pages = web_pages.get("value", [])
+
+        if not pages:
+            return ToolResult.success({
+                "query": query,
+                "backend": "bocha",
+                "total": 0,
+                "results": [],
+                "message": "No results found"
+            })
+
+        results = []
+        for page in pages:
+            result = {
+                "title": page.get("name", ""),
+                "url": page.get("url", ""),
+                "snippet": page.get("snippet", ""),
+                "siteName": page.get("siteName", ""),
+                "datePublished": page.get("datePublished") or page.get("dateLastCrawled", ""),
+            }
+            # Include summary only if present
+            if page.get("summary"):
+                result["summary"] = page["summary"]
+            results.append(result)
+
+        total = web_pages.get("totalEstimatedMatches", len(results))
+
+        return ToolResult.success({
+            "query": query,
+            "backend": "bocha",
+            "total": total,
+            "count": len(results),
+            "results": results
+        })
+
+    def _search_linkai(self, query: str, count: int, freshness: str) -> ToolResult:
+        """
+        Search using LinkAI plugin API
+
+        :param query: Search query
+        :param count: Number of results
+        :param freshness: Time range filter
+        :return: Formatted search results
+        """
+        api_key = os.environ.get("LINKAI_API_KEY", "")
+        url = "https://api.link-ai.tech/v1/plugin/execute"
+
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        }
+
+        payload = {
+            "code": "web-search",
+            "args": {
+                "query": query,
+                "count": count,
+                "freshness": freshness
+            }
+        }
+
+        logger.debug(f"[WebSearch] LinkAI search: query='{query}', count={count}")
+
+        response = requests.post(url, headers=headers, json=payload, timeout=DEFAULT_TIMEOUT)
+
+        if response.status_code == 401:
+            return ToolResult.fail("Error: Invalid LINKAI_API_KEY. Please check your API key.")
+        if response.status_code != 200:
+            return ToolResult.fail(f"Error: LinkAI API returned HTTP {response.status_code}")
+
+        data = response.json()
+
+        if not data.get("success"):
+            msg = data.get("message") or "Unknown error"
+            return ToolResult.fail(f"Error: LinkAI search failed: {msg}")
+
+        return self._format_linkai_results(data, query)
+
+    def _format_linkai_results(self, data: dict, query: str) -> ToolResult:
+        """
+        Format LinkAI API response into unified result structure.
+        LinkAI returns the search data in data.data field, which follows
+        the same Bing-compatible format as Bocha.
+
+        :param data: Raw API response
+        :param query: Original query
+        :return: Formatted ToolResult
+        """
+        raw_data = data.get("data", "")
+
+        # LinkAI may return data as a JSON string
+        if isinstance(raw_data, str):
+            try:
+                raw_data = json.loads(raw_data)
+            except (json.JSONDecodeError, TypeError):
+                # If data is plain text, return it as a single result
+                return ToolResult.success({
+                    "query": query,
+                    "backend": "linkai",
+                    "total": 1,
+                    "count": 1,
+                    "results": [{"content": raw_data}]
+                })
+
+        # If the response follows Bing-compatible structure
+        if isinstance(raw_data, dict):
+            web_pages = raw_data.get("webPages", {})
+            pages = web_pages.get("value", [])
+
+            if pages:
+                results = []
+                for page in pages:
+                    result = {
+                        "title": page.get("name", ""),
+                        "url": page.get("url", ""),
+                        "snippet": page.get("snippet", ""),
+                        "siteName": page.get("siteName", ""),
+                        "datePublished": page.get("datePublished") or page.get("dateLastCrawled", ""),
+                    }
+                    if page.get("summary"):
+                        result["summary"] = page["summary"]
+                    results.append(result)
+
+                total = web_pages.get("totalEstimatedMatches", len(results))
+                return ToolResult.success({
+                    "query": query,
+                    "backend": "linkai",
+                    "total": total,
+                    "count": len(results),
+                    "results": results
+                })
+
+        # Fallback: return raw data
+        return ToolResult.success({
+            "query": query,
+            "backend": "linkai",
+            "total": 1,
+            "count": 1,
+            "results": [{"content": str(raw_data)}]
+        })

agent/tools/write/write.py

@@ -8,6 +8,7 @@ from typing import Dict, Any
 from pathlib import Path
 
 from agent.tools.base_tool import BaseTool, ToolResult
+from common.utils import expand_path
 
 
 class Write(BaseTool):
@@ -90,7 +91,7 @@ class Write(BaseTool):
         :return: Absolute path
         """
         # Expand ~ to user home directory
-        path = os.path.expanduser(path)
+        path = expand_path(path)
         if os.path.isabs(path):
             return path
         return os.path.abspath(os.path.join(self.cwd, path))

app.py

@@ -7,11 +7,215 @@ import time
 
 from channel import channel_factory
 from common import const
-from config import load_config
+from common.log import logger
+from config import load_config, conf
 from plugins import *
 import threading
 
 
+_channel_mgr = None
+
+
+def get_channel_manager():
+    return _channel_mgr
+
+
+def _parse_channel_type(raw) -> list:
+    """
+    Parse channel_type config value into a list of channel names.
+    Supports:
+      - single string: "feishu"
+      - comma-separated string: "feishu, dingtalk"
+      - list: ["feishu", "dingtalk"]
+    """
+    if isinstance(raw, list):
+        return [ch.strip() for ch in raw if ch.strip()]
+    if isinstance(raw, str):
+        return [ch.strip() for ch in raw.split(",") if ch.strip()]
+    return []
+
+
+class ChannelManager:
+    """
+    Manage the lifecycle of multiple channels running concurrently.
+    Each channel.startup() runs in its own daemon thread.
+    The web channel is started as default console unless explicitly disabled.
+    """
+
+    def __init__(self):
+        self._channels = {}        # channel_name -> channel instance
+        self._threads = {}         # channel_name -> thread
+        self._primary_channel = None
+        self._lock = threading.Lock()
+
+    @property
+    def channel(self):
+        """Return the primary (first non-web) channel for backward compatibility."""
+        return self._primary_channel
+
+    def get_channel(self, channel_name: str):
+        return self._channels.get(channel_name)
+
+    def start(self, channel_names: list, first_start: bool = False):
+        """
+        Create and start one or more channels in sub-threads.
+        If first_start is True, plugins and linkai client will also be initialized.
+        """
+        with self._lock:
+            channels = []
+            for name in channel_names:
+                ch = channel_factory.create_channel(name)
+                self._channels[name] = ch
+                channels.append((name, ch))
+                if self._primary_channel is None and name != "web":
+                    self._primary_channel = ch
+
+            if self._primary_channel is None and channels:
+                self._primary_channel = channels[0][1]
+
+            if first_start:
+                PluginManager().load_plugins()
+
+                if conf().get("use_linkai"):
+                    try:
+                        from common import cloud_client
+                        threading.Thread(
+                            target=cloud_client.start,
+                            args=(self._primary_channel, self),
+                            daemon=True,
+                        ).start()
+                    except Exception:
+                        pass
+
+            # Start web console first so its logs print cleanly,
+            # then start remaining channels after a brief pause.
+            web_entry = None
+            other_entries = []
+            for entry in channels:
+                if entry[0] == "web":
+                    web_entry = entry
+                else:
+                    other_entries.append(entry)
+
+            ordered = ([web_entry] if web_entry else []) + other_entries
+            for i, (name, ch) in enumerate(ordered):
+                if i > 0 and name != "web":
+                    time.sleep(0.1)
+                t = threading.Thread(target=self._run_channel, args=(name, ch), daemon=True)
+                self._threads[name] = t
+                t.start()
+                logger.debug(f"[ChannelManager] Channel '{name}' started in sub-thread")
+
+    def _run_channel(self, name: str, channel):
+        try:
+            channel.startup()
+        except Exception as e:
+            logger.error(f"[ChannelManager] Channel '{name}' startup error: {e}")
+            logger.exception(e)
+
+    def stop(self, channel_name: str = None):
+        """
+        Stop channel(s). If channel_name is given, stop only that channel;
+        otherwise stop all channels.
+        """
+        # Pop under lock, then stop outside lock to avoid deadlock
+        with self._lock:
+            names = [channel_name] if channel_name else list(self._channels.keys())
+            to_stop = []
+            for name in names:
+                ch = self._channels.pop(name, None)
+                th = self._threads.pop(name, None)
+                to_stop.append((name, ch, th))
+            if channel_name and self._primary_channel is self._channels.get(channel_name):
+                self._primary_channel = None
+
+        for name, ch, th in to_stop:
+            if ch is None:
+                logger.warning(f"[ChannelManager] Channel '{name}' not found in managed channels")
+                if th and th.is_alive():
+                    self._interrupt_thread(th, name)
+                continue
+            logger.info(f"[ChannelManager] Stopping channel '{name}'...")
+            try:
+                if hasattr(ch, 'stop'):
+                    ch.stop()
+            except Exception as e:
+                logger.warning(f"[ChannelManager] Error during channel '{name}' stop: {e}")
+            if th and th.is_alive():
+                self._interrupt_thread(th, name)
+
+    @staticmethod
+    def _interrupt_thread(th: threading.Thread, name: str):
+        """Raise SystemExit in target thread to break blocking loops like start_forever."""
+        import ctypes
+        try:
+            tid = th.ident
+            if tid is None:
+                return
+            res = ctypes.pythonapi.PyThreadState_SetAsyncExc(
+                ctypes.c_ulong(tid), ctypes.py_object(SystemExit)
+            )
+            if res == 1:
+                logger.info(f"[ChannelManager] Interrupted thread for channel '{name}'")
+            elif res > 1:
+                ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_ulong(tid), None)
+                logger.warning(f"[ChannelManager] Failed to interrupt thread for channel '{name}'")
+        except Exception as e:
+            logger.warning(f"[ChannelManager] Thread interrupt error for '{name}': {e}")
+
+    def restart(self, new_channel_name: str):
+        """
+        Restart a single channel with a new channel type.
+        Can be called from any thread (e.g. linkai config callback).
+        """
+        logger.info(f"[ChannelManager] Restarting channel to '{new_channel_name}'...")
+        self.stop(new_channel_name)
+        _clear_singleton_cache(new_channel_name)
+        time.sleep(1)
+        self.start([new_channel_name], first_start=False)
+        logger.info(f"[ChannelManager] Channel restarted to '{new_channel_name}' successfully")
+
+
+def _clear_singleton_cache(channel_name: str):
+    """
+    Clear the singleton cache for the channel class so that
+    a new instance can be created with updated config.
+    """
+    cls_map = {
+        "wx": "channel.wechat.wechat_channel.WechatChannel",
+        "wxy": "channel.wechat.wechaty_channel.WechatyChannel",
+        "wcf": "channel.wechat.wcf_channel.WechatfChannel",
+        "web": "channel.web.web_channel.WebChannel",
+        "wechatmp": "channel.wechatmp.wechatmp_channel.WechatMPChannel",
+        "wechatmp_service": "channel.wechatmp.wechatmp_channel.WechatMPChannel",
+        "wechatcom_app": "channel.wechatcom.wechatcomapp_channel.WechatComAppChannel",
+        "wework": "channel.wework.wework_channel.WeworkChannel",
+        const.FEISHU: "channel.feishu.feishu_channel.FeiShuChanel",
+        const.DINGTALK: "channel.dingtalk.dingtalk_channel.DingTalkChanel",
+    }
+    module_path = cls_map.get(channel_name)
+    if not module_path:
+        return
+    try:
+        parts = module_path.rsplit(".", 1)
+        module_name, class_name = parts[0], parts[1]
+        import importlib
+        module = importlib.import_module(module_name)
+        wrapper = getattr(module, class_name, None)
+        if wrapper and hasattr(wrapper, '__closure__') and wrapper.__closure__:
+            for cell in wrapper.__closure__:
+                try:
+                    cell_contents = cell.cell_contents
+                    if isinstance(cell_contents, dict):
+                        cell_contents.clear()
+                        logger.debug(f"[ChannelManager] Cleared singleton cache for {class_name}")
+                        break
+                except ValueError:
+                    pass
+    except Exception as e:
+        logger.warning(f"[ChannelManager] Failed to clear singleton cache: {e}")
+
+
 def sigterm_handler_wrap(_signo):
     old_handler = signal.getsignal(_signo)
 
@@ -25,22 +229,8 @@ def sigterm_handler_wrap(_signo):
     signal.signal(_signo, func)
 
 
-def start_channel(channel_name: str):
-    channel = channel_factory.create_channel(channel_name)
-    if channel_name in ["wx", "wxy", "terminal", "wechatmp", "web", "wechatmp_service", "wechatcom_app", "wework",
-                        const.FEISHU, const.DINGTALK]:
-        PluginManager().load_plugins()
-
-    if conf().get("use_linkai"):
-        try:
-            from common import linkai_client
-            threading.Thread(target=linkai_client.start, args=(channel,)).start()
-        except Exception as e:
-            pass
-    channel.startup()
-
-
 def run():
+    global _channel_mgr
     try:
         # load config
         load_config()
@@ -49,33 +239,28 @@ def run():
         # kill signal
         sigterm_handler_wrap(signal.SIGTERM)
 
-        # create channel
-        channel_name = conf().get("channel_type", "wx")
+        # Parse channel_type into a list
+        raw_channel = conf().get("channel_type", "web")
 
         if "--cmd" in sys.argv:
-            channel_name = "terminal"
+            channel_names = ["terminal"]
+        else:
+            channel_names = _parse_channel_type(raw_channel)
+            if not channel_names:
+                channel_names = ["web"]
 
-        if channel_name == "wxy":
+        if "wxy" in channel_names:
             os.environ["WECHATY_LOG"] = "warn"
 
-        start_channel(channel_name)
-        
-        # 打印系统运行成功信息
-        logger.info("")
-        logger.info("=" * 50)
-        if conf().get("agent", False):
-            logger.info("✅ System started successfully!")
-            logger.info("🐮 Cow Agent is running")
-            logger.info(f"   Channel: {channel_name}")
-            logger.info(f"   Model: {conf().get('model', 'unknown')}")
-            logger.info(f"   Workspace: {conf().get('agent_workspace', '~/cow')}")
-        else:
-            logger.info("✅ System started successfully!")
-            logger.info("🤖 ChatBot is running")
-            logger.info(f"   Channel: {channel_name}")
-            logger.info(f"   Model: {conf().get('model', 'unknown')}")
-        logger.info("=" * 50)
-        logger.info("")
+        # Auto-start web console unless explicitly disabled
+        web_console_enabled = conf().get("web_console", True)
+        if web_console_enabled and "web" not in channel_names:
+            channel_names.append("web")
+
+        logger.info(f"[App] Starting channels: {channel_names}")
+
+        _channel_mgr = ChannelManager()
+        _channel_mgr.start(channel_names, first_start=True)
 
         while True:
             time.sleep(1)

bridge/agent_bridge.py

@@ -6,12 +6,15 @@ import os
 from typing import Optional, List
 
 from agent.protocol import Agent, LLMModel, LLMRequest
-from models.openai_compatible_bot import OpenAICompatibleBot
+from bridge.agent_event_handler import AgentEventHandler
+from bridge.agent_initializer import AgentInitializer
 from bridge.bridge import Bridge
 from bridge.context import Context
 from bridge.reply import Reply, ReplyType
 from common import const
 from common.log import logger
+from common.utils import expand_path
+from models.openai_compatible_bot import OpenAICompatibleBot
 
 
 def add_openai_compatible_support(bot_instance):
@@ -20,9 +23,12 @@ def add_openai_compatible_support(bot_instance):
     
     This allows any bot to gain tool calling capability without modifying its code,
     as long as it uses OpenAI-compatible API format.
+    
+    Note: Some bots like ZHIPUAIBot have native tool calling support and don't need enhancement.
     """
     if hasattr(bot_instance, 'call_with_tools'):
-        # Bot already has tool calling support
+        # Bot already has tool calling support (e.g., ZHIPUAIBot)
+        logger.debug(f"[AgentBridge] {type(bot_instance).__name__} already has native tool calling support")
         return bot_instance
 
     # Create a temporary mixin class that combines the bot with OpenAI compatibility
@@ -59,30 +65,67 @@ class AgentLLMModel(LLMModel):
     LLM Model adapter that uses COW's existing bot infrastructure
     """
 
+    _MODEL_BOT_TYPE_MAP = {
+        "wenxin": const.BAIDU, "wenxin-4": const.BAIDU,
+        "xunfei": const.XUNFEI, const.QWEN: const.QWEN,
+        const.MODELSCOPE: const.MODELSCOPE,
+    }
+    _MODEL_PREFIX_MAP = [
+        ("qwen", const.QWEN_DASHSCOPE), ("qwq", const.QWEN_DASHSCOPE), ("qvq", const.QWEN_DASHSCOPE),
+        ("gemini", const.GEMINI), ("glm", const.ZHIPU_AI), ("claude", const.CLAUDEAPI),
+        ("moonshot", const.MOONSHOT), ("kimi", const.MOONSHOT),
+        ("doubao", const.DOUBAO),
+    ]
+
     def __init__(self, bridge: Bridge, bot_type: str = "chat"):
-        # Get model name directly from config
         from config import conf
-        model_name = conf().get("model", const.GPT_41)
-        super().__init__(model=model_name)
+        super().__init__(model=conf().get("model", const.GPT_41))
         self.bridge = bridge
         self.bot_type = bot_type
         self._bot = None
-        self._use_linkai = conf().get("use_linkai", False) and conf().get("linkai_api_key")
-    
+        self._bot_model = None
+
+    @property
+    def model(self):
+        from config import conf
+        return conf().get("model", const.GPT_41)
+
+    @model.setter
+    def model(self, value):
+        pass
+
+    def _resolve_bot_type(self, model_name: str) -> str:
+        """Resolve bot type from model name, matching Bridge.__init__ logic."""
+        from config import conf
+        if conf().get("use_linkai", False) and conf().get("linkai_api_key"):
+            return const.LINKAI
+        if not model_name or not isinstance(model_name, str):
+            return const.CHATGPT
+        if model_name in self._MODEL_BOT_TYPE_MAP:
+            return self._MODEL_BOT_TYPE_MAP[model_name]
+        if model_name.lower().startswith("minimax") or model_name in ["abab6.5-chat"]:
+            return const.MiniMax
+        if model_name in [const.QWEN_TURBO, const.QWEN_PLUS, const.QWEN_MAX]:
+            return const.QWEN_DASHSCOPE
+        if model_name in [const.MOONSHOT, "moonshot-v1-8k", "moonshot-v1-32k", "moonshot-v1-128k"]:
+            return const.MOONSHOT
+        if model_name in [const.DEEPSEEK_CHAT, const.DEEPSEEK_REASONER]:
+            return const.CHATGPT
+        for prefix, btype in self._MODEL_PREFIX_MAP:
+            if model_name.startswith(prefix):
+                return btype
+        return const.CHATGPT
+
     @property
     def bot(self):
-        """Lazy load the bot and enhance it with tool calling if needed"""
-        if self._bot is None:
-            # If use_linkai is enabled, use LinkAI bot directly
-            if self._use_linkai:
-                self._bot = self.bridge.find_chat_bot(const.LINKAI)
-            else:
-                self._bot = self.bridge.get_bot(self.bot_type)
-                # Automatically add tool calling support if not present
-                self._bot = add_openai_compatible_support(self._bot)
-            
-            # Log bot info
-            bot_name = type(self._bot).__name__
+        """Lazy load the bot, re-create when model changes"""
+        from models.bot_factory import create_bot
+        cur_model = self.model
+        if self._bot is None or self._bot_model != cur_model:
+            bot_type = self._resolve_bot_type(cur_model)
+            self._bot = create_bot(bot_type)
+            self._bot = add_openai_compatible_support(self._bot)
+            self._bot_model = cur_model
         return self._bot
 
     def call(self, request: LLMRequest):
@@ -127,25 +170,30 @@ class AgentLLMModel(LLMModel):
         try:
             if hasattr(self.bot, 'call_with_tools'):
                 # Use tool-enabled streaming call if available
-                # Ensure max_tokens is an integer, use default if None
-                max_tokens = request.max_tokens if request.max_tokens is not None else 4096
-                
                 # Extract system prompt if present
                 system_prompt = getattr(request, 'system', None)
-                
+
                 # Build kwargs for call_with_tools
                 kwargs = {
                     'messages': request.messages,
                     'tools': getattr(request, 'tools', None),
                     'stream': True,
-                    'max_tokens': max_tokens,
                     'model': self.model  # Pass model parameter
                 }
-                
+
+                # Only pass max_tokens if explicitly set, let the bot use its default
+                if request.max_tokens is not None:
+                    kwargs['max_tokens'] = request.max_tokens
+
                 # Add system prompt if present
                 if system_prompt:
                     kwargs['system'] = system_prompt
-                
+
+                # Pass channel_type for linkai tracking
+                channel_type = getattr(self, 'channel_type', None)
+                if channel_type:
+                    kwargs['channel_type'] = channel_type
+
                 stream = self.bot.call_with_tools(**kwargs)
                 
                 # Convert stream format to our expected format
@@ -182,6 +230,9 @@ class AgentBridge:
         self.default_agent = None  # For backward compatibility (no session_id)
         self.agent: Optional[Agent] = None
         self.scheduler_initialized = False
+        
+        # Create helper instances
+        self.initializer = AgentInitializer(bridge, self)
     def create_agent(self, system_prompt: str, tools: List = None, **kwargs) -> Agent:
         """
         Create the super agent with COW integration
@@ -225,7 +276,8 @@ class AgentBridge:
             enable_skills=kwargs.get("enable_skills", True),  # Enable skills by default
             memory_manager=kwargs.get("memory_manager"),  # Pass memory manager
             max_context_tokens=kwargs.get("max_context_tokens"),
-            context_reserve_tokens=kwargs.get("context_reserve_tokens")
+            context_reserve_tokens=kwargs.get("context_reserve_tokens"),
+            runtime_info=kwargs.get("runtime_info")  # Pass runtime_info for dynamic time updates
         )
 
         # Log skill loading details
@@ -252,492 +304,19 @@ class AgentBridge:
         
         # Check if agent exists for this session
         if session_id not in self.agents:
-            logger.info(f"[AgentBridge] Creating new agent for session: {session_id}")
             self._init_agent_for_session(session_id)
         
         return self.agents[session_id]
     
     def _init_default_agent(self):
-        """Initialize default super agent with new prompt system"""
-        from config import conf
-        import os
-
-        # Get workspace from config
-        workspace_root = os.path.expanduser(conf().get("agent_workspace", "~/cow"))
-
-        # Migrate API keys from config.json to environment variables (if not already set)
-        self._migrate_config_to_env(workspace_root)
-        
-        # Load environment variables from secure .env file location
-        env_file = os.path.expanduser("~/.cow/.env")
-        if os.path.exists(env_file):
-            try:
-                from dotenv import load_dotenv
-                load_dotenv(env_file, override=True)
-                logger.info(f"[AgentBridge] Loaded environment variables from {env_file}")
-            except ImportError:
-                logger.warning("[AgentBridge] python-dotenv not installed, skipping .env file loading")
-            except Exception as e:
-                logger.warning(f"[AgentBridge] Failed to load .env file: {e}")
-
-        # Initialize workspace and create template files
-        from agent.prompt import ensure_workspace, load_context_files, PromptBuilder
-
-        workspace_files = ensure_workspace(workspace_root, create_templates=True)
-        logger.info(f"[AgentBridge] Workspace initialized at: {workspace_root}")
-
-        # Setup memory system
-        memory_manager = None
-        memory_tools = []
-
-        try:
-            # Try to initialize memory system
-            from agent.memory import MemoryManager, MemoryConfig
-            from agent.tools import MemorySearchTool, MemoryGetTool
-
-            # 从 config.json 读取 OpenAI 配置
-            openai_api_key = conf().get("open_ai_api_key", "")
-            openai_api_base = conf().get("open_ai_api_base", "")
-            
-            # 尝试初始化 OpenAI embedding provider
-            embedding_provider = None
-            if openai_api_key:
-                try:
-                    from agent.memory import create_embedding_provider
-                    embedding_provider = create_embedding_provider(
-                        provider="openai",
-                        model="text-embedding-3-small",
-                        api_key=openai_api_key,
-                        api_base=openai_api_base or "https://api.openai.com/v1"
-                    )
-                    logger.info(f"[AgentBridge] OpenAI embedding initialized")
-                except Exception as embed_error:
-                    logger.warning(f"[AgentBridge] OpenAI embedding failed: {embed_error}")
-                    logger.info(f"[AgentBridge] Using keyword-only search")
-            else:
-                logger.info(f"[AgentBridge] No OpenAI API key, using keyword-only search")
-            
-            # 创建 memory config
-            memory_config = MemoryConfig(workspace_root=workspace_root)
-            
-            # 创建 memory manager
-            memory_manager = MemoryManager(memory_config, embedding_provider=embedding_provider)
-            
-            # 初始化时执行一次 sync，确保数据库有数据
-            import asyncio
-            try:
-                # 尝试在当前事件循环中执行
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    # 如果事件循环正在运行，创建任务
-                    asyncio.create_task(memory_manager.sync())
-                    logger.info("[AgentBridge] Memory sync scheduled")
-                else:
-                    # 如果没有运行的循环，直接执行
-                    loop.run_until_complete(memory_manager.sync())
-                    logger.info("[AgentBridge] Memory synced successfully")
-            except RuntimeError:
-                # 没有事件循环，创建新的
-                asyncio.run(memory_manager.sync())
-                logger.info("[AgentBridge] Memory synced successfully")
-            except Exception as e:
-                logger.warning(f"[AgentBridge] Memory sync failed: {e}")
-            
-            # Create memory tools
-            memory_tools = [
-                MemorySearchTool(memory_manager),
-                MemoryGetTool(memory_manager)
-            ]
-            
-            logger.info(f"[AgentBridge] Memory system initialized")
-            
-        except Exception as e:
-            logger.warning(f"[AgentBridge] Memory system not available: {e}")
-            logger.info("[AgentBridge] Continuing without memory features")
-
-        # Use ToolManager to dynamically load all available tools
-        from agent.tools import ToolManager
-        tool_manager = ToolManager()
-        tool_manager.load_tools()
-
-        # Create tool instances for all available tools
-        tools = []
-        file_config = {
-            "cwd": workspace_root,
-            "memory_manager": memory_manager
-        } if memory_manager else {"cwd": workspace_root}
-
-        for tool_name in tool_manager.tool_classes.keys():
-            try:
-                # Special handling for EnvConfig tool - pass agent_bridge reference
-                if tool_name == "env_config":
-                    from agent.tools import EnvConfig
-                    tool = EnvConfig({
-                        "agent_bridge": self  # Pass self reference for hot reload
-                    })
-                else:
-                    tool = tool_manager.create_tool(tool_name)
-                
-                if tool:
-                    # Apply workspace config to file operation tools
-                    if tool_name in ['read', 'write', 'edit', 'bash', 'grep', 'find', 'ls']:
-                        tool.config = file_config
-                        tool.cwd = file_config.get("cwd", tool.cwd if hasattr(tool, 'cwd') else None)
-                        if 'memory_manager' in file_config:
-                            tool.memory_manager = file_config['memory_manager']
-                    tools.append(tool)
-                    logger.debug(f"[AgentBridge] Loaded tool: {tool_name}")
-            except Exception as e:
-                logger.warning(f"[AgentBridge] Failed to load tool {tool_name}: {e}")
-
-        # Add memory tools
-        if memory_tools:
-            tools.extend(memory_tools)
-            logger.info(f"[AgentBridge] Added {len(memory_tools)} memory tools")
-
-        # Initialize scheduler service (once)
-        if not self.scheduler_initialized:
-            try:
-                from agent.tools.scheduler.integration import init_scheduler
-                if init_scheduler(self):
-                    self.scheduler_initialized = True
-                    logger.info("[AgentBridge] Scheduler service initialized")
-            except Exception as e:
-                logger.warning(f"[AgentBridge] Failed to initialize scheduler: {e}")
-        
-        # Inject scheduler dependencies into SchedulerTool instances
-        if self.scheduler_initialized:
-            try:
-                from agent.tools.scheduler.integration import get_task_store, get_scheduler_service
-                from agent.tools import SchedulerTool
-                
-                task_store = get_task_store()
-                scheduler_service = get_scheduler_service()
-                
-                for tool in tools:
-                    if isinstance(tool, SchedulerTool):
-                        tool.task_store = task_store
-                        tool.scheduler_service = scheduler_service
-                        if not tool.config:
-                            tool.config = {}
-                        tool.config["channel_type"] = conf().get("channel_type", "unknown")
-                        logger.debug("[AgentBridge] Injected scheduler dependencies into SchedulerTool")
-            except Exception as e:
-                logger.warning(f"[AgentBridge] Failed to inject scheduler dependencies: {e}")
-
-        logger.info(f"[AgentBridge] Loaded {len(tools)} tools: {[t.name for t in tools]}")
-
-        # Load context files (SOUL.md, USER.md, etc.)
-        context_files = load_context_files(workspace_root)
-        logger.info(f"[AgentBridge] Loaded {len(context_files)} context files: {[f.path for f in context_files]}")
-
-        # Check if this is the first conversation
-        from agent.prompt.workspace import is_first_conversation, mark_conversation_started
-        is_first = is_first_conversation(workspace_root)
-        if is_first:
-            logger.info("[AgentBridge] First conversation detected")
-        
-        # Build system prompt using new prompt builder
-        prompt_builder = PromptBuilder(
-            workspace_dir=workspace_root,
-            language="zh"
-        )
-
-        # Get runtime info
-        runtime_info = {
-            "model": conf().get("model", "unknown"),
-            "workspace": workspace_root,
-            "channel": conf().get("channel_type", "unknown")  # Get from config
-        }
-
-        system_prompt = prompt_builder.build(
-            tools=tools,
-            context_files=context_files,
-            memory_manager=memory_manager,
-            runtime_info=runtime_info,
-            is_first_conversation=is_first
-        )
-        
-        # Mark conversation as started (will be saved after first user message)
-        if is_first:
-            mark_conversation_started(workspace_root)
-
-        logger.info("[AgentBridge] System prompt built successfully")
-
-        # Get cost control parameters from config
-        max_steps = conf().get("agent_max_steps", 20)
-        max_context_tokens = conf().get("agent_max_context_tokens", 50000)
-        
-        # Create agent with configured tools and workspace
-        agent = self.create_agent(
-            system_prompt=system_prompt,
-            tools=tools,
-            max_steps=max_steps,
-            output_mode="logger",
-            workspace_dir=workspace_root,  # Pass workspace to agent for skills loading
-            enable_skills=True,  # Enable skills auto-loading
-            max_context_tokens=max_context_tokens
-        )
-
-        # Attach memory manager to agent if available
-        if memory_manager:
-            agent.memory_manager = memory_manager
-            logger.info(f"[AgentBridge] Memory manager attached to agent")
-        
-        # Store as default agent
+        """Initialize default super agent"""
+        agent = self.initializer.initialize_agent(session_id=None)
         self.default_agent = agent
     
     def _init_agent_for_session(self, session_id: str):
-        """
-        Initialize agent for a specific session
-        Reuses the same configuration as default agent
-        """
-        from config import conf
-        import os
-
-        # Get workspace from config
-        workspace_root = os.path.expanduser(conf().get("agent_workspace", "~/cow"))
-
-        # Migrate API keys from config.json to environment variables (if not already set)
-        self._migrate_config_to_env(workspace_root)
-        
-        # Load environment variables from secure .env file location
-        env_file = os.path.expanduser("~/.cow/.env")
-        if os.path.exists(env_file):
-            try:
-                from dotenv import load_dotenv
-                load_dotenv(env_file, override=True)
-                logger.debug(f"[AgentBridge] Loaded environment variables from {env_file} for session {session_id}")
-            except ImportError:
-                logger.warning(f"[AgentBridge] python-dotenv not installed, skipping .env file loading for session {session_id}")
-            except Exception as e:
-                logger.warning(f"[AgentBridge] Failed to load .env file for session {session_id}: {e}")
-        
-        # Migrate API keys from config.json to environment variables (if not already set)
-        self._migrate_config_to_env(workspace_root)
-
-        # Initialize workspace
-        from agent.prompt import ensure_workspace, load_context_files, PromptBuilder
-
-        workspace_files = ensure_workspace(workspace_root, create_templates=True)
-
-        # Setup memory system
-        memory_manager = None
-        memory_tools = []
-
-        try:
-            from agent.memory import MemoryManager, MemoryConfig, create_embedding_provider
-            from agent.tools import MemorySearchTool, MemoryGetTool
-
-            # 从 config.json 读取 OpenAI 配置
-            openai_api_key = conf().get("open_ai_api_key", "")
-            openai_api_base = conf().get("open_ai_api_base", "")
-            
-            # 尝试初始化 OpenAI embedding provider
-            embedding_provider = None
-            if openai_api_key:
-                try:
-                    embedding_provider = create_embedding_provider(
-                        provider="openai",
-                        model="text-embedding-3-small",
-                        api_key=openai_api_key,
-                        api_base=openai_api_base or "https://api.openai.com/v1"
-                    )
-                    logger.debug(f"[AgentBridge] OpenAI embedding initialized for session {session_id}")
-                except Exception as embed_error:
-                    logger.warning(f"[AgentBridge] OpenAI embedding failed for session {session_id}: {embed_error}")
-                    logger.info(f"[AgentBridge] Using keyword-only search for session {session_id}")
-            else:
-                logger.debug(f"[AgentBridge] No OpenAI API key, using keyword-only search for session {session_id}")
-            
-            # 创建 memory config
-            memory_config = MemoryConfig(workspace_root=workspace_root)
-            
-            # 创建 memory manager
-            memory_manager = MemoryManager(memory_config, embedding_provider=embedding_provider)
-            
-            # 初始化时执行一次 sync，确保数据库有数据
-            import asyncio
-            try:
-                # 尝试在当前事件循环中执行
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
-                    # 如果事件循环正在运行，创建任务
-                    asyncio.create_task(memory_manager.sync())
-                    logger.debug(f"[AgentBridge] Memory sync scheduled for session {session_id}")
-                else:
-                    # 如果没有运行的循环，直接执行
-                    loop.run_until_complete(memory_manager.sync())
-                    logger.debug(f"[AgentBridge] Memory synced successfully for session {session_id}")
-            except RuntimeError:
-                # 没有事件循环，创建新的
-                asyncio.run(memory_manager.sync())
-                logger.debug(f"[AgentBridge] Memory synced successfully for session {session_id}")
-            except Exception as sync_error:
-                logger.warning(f"[AgentBridge] Memory sync failed for session {session_id}: {sync_error}")
-            
-            memory_tools = [
-                MemorySearchTool(memory_manager),
-                MemoryGetTool(memory_manager)
-            ]
-            
-        except Exception as e:
-            logger.warning(f"[AgentBridge] Memory system not available for session {session_id}: {e}")
-            import traceback
-            logger.warning(f"[AgentBridge] Memory init traceback: {traceback.format_exc()}")
-
-        # Load tools
-        from agent.tools import ToolManager
-        tool_manager = ToolManager()
-        tool_manager.load_tools()
-
-        tools = []
-        file_config = {
-            "cwd": workspace_root,
-            "memory_manager": memory_manager
-        } if memory_manager else {"cwd": workspace_root}
-
-        for tool_name in tool_manager.tool_classes.keys():
-            try:
-                tool = tool_manager.create_tool(tool_name)
-                if tool:
-                    if tool_name in ['read', 'write', 'edit', 'bash', 'grep', 'find', 'ls']:
-                        tool.config = file_config
-                        tool.cwd = file_config.get("cwd", tool.cwd if hasattr(tool, 'cwd') else None)
-                        if 'memory_manager' in file_config:
-                            tool.memory_manager = file_config['memory_manager']
-                    tools.append(tool)
-            except Exception as e:
-                logger.warning(f"[AgentBridge] Failed to load tool {tool_name} for session {session_id}: {e}")
-
-        if memory_tools:
-            tools.extend(memory_tools)
-        
-        # Initialize scheduler service (once, if not already initialized)
-        if not self.scheduler_initialized:
-            try:
-                from agent.tools.scheduler.integration import init_scheduler
-                if init_scheduler(self):
-                    self.scheduler_initialized = True
-                    logger.debug(f"[AgentBridge] Scheduler service initialized for session {session_id}")
-            except Exception as e:
-                logger.warning(f"[AgentBridge] Failed to initialize scheduler for session {session_id}: {e}")
-        
-        # Inject scheduler dependencies into SchedulerTool instances
-        if self.scheduler_initialized:
-            try:
-                from agent.tools.scheduler.integration import get_task_store, get_scheduler_service
-                from agent.tools import SchedulerTool
-                
-                task_store = get_task_store()
-                scheduler_service = get_scheduler_service()
-                
-                for tool in tools:
-                    if isinstance(tool, SchedulerTool):
-                        tool.task_store = task_store
-                        tool.scheduler_service = scheduler_service
-                        if not tool.config:
-                            tool.config = {}
-                        tool.config["channel_type"] = conf().get("channel_type", "unknown")
-                        logger.debug(f"[AgentBridge] Injected scheduler dependencies for session {session_id}")
-            except Exception as e:
-                logger.warning(f"[AgentBridge] Failed to inject scheduler dependencies for session {session_id}: {e}")
-
-        # Load context files
-        context_files = load_context_files(workspace_root)
-
-        # Initialize skill manager
-        skill_manager = None
-        try:
-            from agent.skills import SkillManager
-            skill_manager = SkillManager(workspace_dir=workspace_root)
-            logger.debug(f"[AgentBridge] Initialized SkillManager with {len(skill_manager.skills)} skills for session {session_id}")
-        except Exception as e:
-            logger.warning(f"[AgentBridge] Failed to initialize SkillManager for session {session_id}: {e}")
-
-        # Check if this is the first conversation
-        from agent.prompt.workspace import is_first_conversation, mark_conversation_started
-        is_first = is_first_conversation(workspace_root)
-        
-        # Build system prompt
-        prompt_builder = PromptBuilder(
-            workspace_dir=workspace_root,
-            language="zh"
-        )
-
-        # Get current time and timezone info
-        import datetime
-        import time
-        
-        now = datetime.datetime.now()
-        
-        # Get timezone info
-        try:
-            offset = -time.timezone if not time.daylight else -time.altzone
-            hours = offset // 3600
-            minutes = (offset % 3600) // 60
-            if minutes:
-                timezone_name = f"UTC{hours:+03d}:{minutes:02d}"
-            else:
-                timezone_name = f"UTC{hours:+03d}"
-        except Exception:
-            timezone_name = "UTC"
-        
-        # Chinese weekday mapping
-        weekday_map = {
-            'Monday': '星期一',
-            'Tuesday': '星期二',
-            'Wednesday': '星期三',
-            'Thursday': '星期四',
-            'Friday': '星期五',
-            'Saturday': '星期六',
-            'Sunday': '星期日'
-        }
-        weekday_zh = weekday_map.get(now.strftime("%A"), now.strftime("%A"))
-        
-        runtime_info = {
-            "model": conf().get("model", "unknown"),
-            "workspace": workspace_root,
-            "channel": conf().get("channel_type", "unknown"),
-            "current_time": now.strftime("%Y-%m-%d %H:%M:%S"),
-            "weekday": weekday_zh,
-            "timezone": timezone_name
-        }
-
-        system_prompt = prompt_builder.build(
-            tools=tools,
-            context_files=context_files,
-            skill_manager=skill_manager,
-            memory_manager=memory_manager,
-            runtime_info=runtime_info,
-            is_first_conversation=is_first
-        )
-        
-        if is_first:
-            mark_conversation_started(workspace_root)
-
-        # Get cost control parameters from config
-        max_steps = conf().get("agent_max_steps", 20)
-        max_context_tokens = conf().get("agent_max_context_tokens", 50000)
-
-        # Create agent for this session
-        agent = self.create_agent(
-            system_prompt=system_prompt,
-            tools=tools,
-            max_steps=max_steps,
-            output_mode="logger",
-            workspace_dir=workspace_root,
-            skill_manager=skill_manager,
-            enable_skills=True,
-            max_context_tokens=max_context_tokens
-        )
-
-        if memory_manager:
-            agent.memory_manager = memory_manager
-        
-        # Store agent for this session
+        """Initialize agent for a specific session"""
+        agent = self.initializer.initialize_agent(session_id=session_id)
         self.agents[session_id] = agent
-        logger.info(f"[AgentBridge] Agent created for session: {session_id}")
     
     def agent_reply(self, query: str, context: Context = None, 
                    on_event=None, clear_history: bool = False) -> Reply:
@@ -764,6 +343,9 @@ class AgentBridge:
             if not agent:
                 return Reply(ReplyType.ERROR, "Failed to initialize super agent")
             
+            # Create event handler for logging and channel communication
+            event_handler = AgentEventHandler(context=context, original_callback=on_event)
+            
             # Filter tools based on context
             original_tools = agent.tools
             filtered_tools = original_tools
@@ -785,17 +367,35 @@ class AgentBridge:
                                 logger.warning(f"[AgentBridge] Failed to attach context to scheduler: {e}")
                             break
             
+            # Pass channel_type to model so linkai requests carry it
+            if context and hasattr(agent, 'model'):
+                agent.model.channel_type = context.get("channel_type", "")
+
+            # Record message count before execution so we can diff new messages
+            with agent.messages_lock:
+                pre_run_len = len(agent.messages)
+
             try:
-                # Use agent's run_stream method
+                # Use agent's run_stream method with event handler
                 response = agent.run_stream(
                     user_message=query,
-                    on_event=on_event,
+                    on_event=event_handler.handle_event,
                     clear_history=clear_history
                 )
             finally:
                 # Restore original tools
                 if context and context.get("is_scheduled_task"):
                     agent.tools = original_tools
+
+                # Log execution summary
+                event_handler.log_summary()
+
+            # Persist new messages generated during this run
+            if session_id:
+                channel_type = (context.get("channel_type") or "") if context else ""
+                with agent.messages_lock:
+                    new_messages = agent.messages[pre_run_len:]
+                self._persist_messages(session_id, list(new_messages), channel_type)
             
             # Check if there are files to send (from read tool)
             if hasattr(agent, 'stream_executor') and hasattr(agent.stream_executor, 'files_to_send'):
@@ -843,17 +443,18 @@ class AgentBridge:
                 reply.text_content = text_response  # Store accompanying text
             return reply
         
-        # For documents (PDF, Excel, Word, PPT), use FILE type
-        if file_type == "document":
+        # For all file types (document, video, audio), use FILE type
+        if file_type in ["document", "video", "audio"]:
             file_url = f"file://{file_path}"
-            logger.info(f"[AgentBridge] Sending document: {file_url}")
+            logger.info(f"[AgentBridge] Sending {file_type}: {file_url}")
             reply = Reply(ReplyType.FILE, file_url)
             reply.file_name = file_info.get("file_name", os.path.basename(file_path))
+            # Attach text message if present
+            if text_response:
+                reply.text_content = text_response
             return reply
         
-        # For other files (video, audio), we need channel-specific handling
-        # For now, return text with file info
-        # TODO: Implement video/audio sending when channel supports it
+        # For other unknown file types, return text with file info
         message = text_response or file_info.get("message", "文件已准备")
         message += f"\n\n[文件: {file_info.get('file_name', file_path)}]"
         return Reply(ReplyType.TEXT, message)
@@ -878,7 +479,7 @@ class AgentBridge:
         }
         
         # Use fixed secure location for .env file
-        env_file = os.path.expanduser("~/.cow/.env")
+        env_file = expand_path("~/.cow/.env")
         
         # Read existing env vars from .env file
         existing_env_vars = {}
@@ -931,6 +532,32 @@ class AgentBridge:
             except Exception as e:
                 logger.warning(f"[AgentBridge] Failed to migrate API keys: {e}")
     
+    def _persist_messages(
+        self, session_id: str, new_messages: list, channel_type: str = ""
+    ) -> None:
+        """
+        Persist new messages to the conversation store after each agent run.
+
+        Failures are logged but never propagate — they must not interrupt replies.
+        """
+        if not new_messages:
+            return
+        try:
+            from config import conf
+            if not conf().get("conversation_persistence", True):
+                return
+        except Exception:
+            pass
+        try:
+            from agent.memory import get_conversation_store
+            get_conversation_store().append_messages(
+                session_id, new_messages, channel_type=channel_type
+            )
+        except Exception as e:
+            logger.warning(
+                f"[AgentBridge] Failed to persist messages for session={session_id}: {e}"
+            )
+
     def clear_session(self, session_id: str):
         """
         Clear a specific session's agent and conversation history
@@ -950,39 +577,70 @@ class AgentBridge:
     
     def refresh_all_skills(self) -> int:
         """
-        Refresh skills in all agent instances after environment variable changes.
-        This allows hot-reload of skills without restarting the agent.
-        
+        Refresh skills and conditional tools in all agent instances after
+        environment variable changes. This allows hot-reload without restarting.
+
         Returns:
             Number of agent instances refreshed
         """
         import os
         from dotenv import load_dotenv
         from config import conf
-        
+
         # Reload environment variables from .env file
-        workspace_root = os.path.expanduser(conf().get("agent_workspace", "~/cow"))
+        workspace_root = expand_path(conf().get("agent_workspace", "~/cow"))
         env_file = os.path.join(workspace_root, '.env')
-        
+
         if os.path.exists(env_file):
             load_dotenv(env_file, override=True)
             logger.info(f"[AgentBridge] Reloaded environment variables from {env_file}")
-        
+
         refreshed_count = 0
-        
-        # Refresh default agent
-        if self.default_agent and hasattr(self.default_agent, 'skill_manager'):
-            self.default_agent.skill_manager.refresh_skills()
-            refreshed_count += 1
-            logger.info("[AgentBridge] Refreshed skills in default agent")
-        
-        # Refresh all session agents
+
+        # Collect all agent instances to refresh
+        agents_to_refresh = []
+        if self.default_agent:
+            agents_to_refresh.append(("default", self.default_agent))
         for session_id, agent in self.agents.items():
-            if hasattr(agent, 'skill_manager'):
+            agents_to_refresh.append((session_id, agent))
+
+        for label, agent in agents_to_refresh:
+            # Refresh skills
+            if hasattr(agent, 'skill_manager') and agent.skill_manager:
                 agent.skill_manager.refresh_skills()
-                refreshed_count += 1
-        
+
+            # Refresh conditional tools (e.g. web_search depends on API keys)
+            self._refresh_conditional_tools(agent)
+
+            refreshed_count += 1
+
         if refreshed_count > 0:
-            logger.info(f"[AgentBridge] Refreshed skills in {refreshed_count} agent instance(s)")
-        
-        return refreshed_count
+            logger.info(f"[AgentBridge] Refreshed skills & tools in {refreshed_count} agent instance(s)")
+
+        return refreshed_count
+
+    @staticmethod
+    def _refresh_conditional_tools(agent):
+        """
+        Add or remove conditional tools based on current environment variables.
+        For example, web_search should only be present when BOCHA_API_KEY or
+        LINKAI_API_KEY is set.
+        """
+        try:
+            from agent.tools.web_search.web_search import WebSearch
+
+            has_tool = any(t.name == "web_search" for t in agent.tools)
+            available = WebSearch.is_available()
+
+            if available and not has_tool:
+                # API key was added - inject the tool
+                tool = WebSearch()
+                tool.model = agent.model
+                agent.tools.append(tool)
+                logger.info("[AgentBridge] web_search tool added (API key now available)")
+            elif not available and has_tool:
+                # API key was removed - remove the tool
+                agent.tools = [t for t in agent.tools if t.name != "web_search"]
+                logger.info("[AgentBridge] web_search tool removed (API key no longer available)")
+        except Exception as e:
+            logger.debug(f"[AgentBridge] Failed to refresh conditional tools: {e}")

bridge/agent_event_handler.py

@@ -0,0 +1,115 @@
+"""
+Agent Event Handler - Handles agent events and thinking process output
+"""
+
+from common.log import logger
+
+
+class AgentEventHandler:
+    """
+    Handles agent events and optionally sends intermediate messages to channel
+    """
+    
+    def __init__(self, context=None, original_callback=None):
+        """
+        Initialize event handler
+        
+        Args:
+            context: COW context (for accessing channel)
+            original_callback: Original event callback to chain
+        """
+        self.context = context
+        self.original_callback = original_callback
+        
+        # Get channel for sending intermediate messages
+        self.channel = None
+        if context:
+            self.channel = context.kwargs.get("channel") if hasattr(context, "kwargs") else None
+        
+        # Track current thinking for channel output
+        self.current_thinking = ""
+        self.turn_number = 0
+    
+    def handle_event(self, event):
+        """
+        Main event handler
+        
+        Args:
+            event: Event dict with type and data
+        """
+        event_type = event.get("type")
+        data = event.get("data", {})
+        
+        # Dispatch to specific handlers
+        if event_type == "turn_start":
+            self._handle_turn_start(data)
+        elif event_type == "message_update":
+            self._handle_message_update(data)
+        elif event_type == "message_end":
+            self._handle_message_end(data)
+        elif event_type == "tool_execution_start":
+            self._handle_tool_execution_start(data)
+        elif event_type == "tool_execution_end":
+            self._handle_tool_execution_end(data)
+        
+        # Call original callback if provided
+        if self.original_callback:
+            self.original_callback(event)
+    
+    def _handle_turn_start(self, data):
+        """Handle turn start event"""
+        self.turn_number = data.get("turn", 0)
+        self.has_tool_calls_in_turn = False
+        self.current_thinking = ""
+    
+    def _handle_message_update(self, data):
+        """Handle message update event (streaming text)"""
+        delta = data.get("delta", "")
+        self.current_thinking += delta
+    
+    def _handle_message_end(self, data):
+        """Handle message end event"""
+        tool_calls = data.get("tool_calls", [])
+        
+        # Only send thinking process if followed by tool calls
+        if tool_calls:
+            if self.current_thinking.strip():
+                logger.info(f"💭 {self.current_thinking.strip()[:200]}{'...' if len(self.current_thinking) > 200 else ''}")
+                # Send thinking process to channel
+                self._send_to_channel(f"{self.current_thinking.strip()}")
+        else:
+            # No tool calls = final response (logged at agent_stream level)
+            if self.current_thinking.strip():
+                logger.debug(f"💬 {self.current_thinking.strip()[:200]}{'...' if len(self.current_thinking) > 200 else ''}")
+        
+        self.current_thinking = ""
+    
+    def _handle_tool_execution_start(self, data):
+        """Handle tool execution start event - logged by agent_stream.py"""
+        pass
+    
+    def _handle_tool_execution_end(self, data):
+        """Handle tool execution end event - logged by agent_stream.py"""
+        pass
+    
+    def _send_to_channel(self, message):
+        """
+        Try to send intermediate message to channel.
+        Skipped in SSE mode because thinking text is already streamed via on_event.
+        """
+        if self.context and self.context.get("on_event"):
+            return
+
+        if self.channel:
+            try:
+                from bridge.reply import Reply, ReplyType
+                reply = Reply(ReplyType.TEXT, message)
+                self.channel._send(reply, self.context)
+            except Exception as e:
+                logger.debug(f"[AgentEventHandler] Failed to send to channel: {e}")
+    
+    def log_summary(self):
+        """Log execution summary - simplified"""
+        # Summary removed as per user request
+        # Real-time logging during execution is sufficient
+        pass

bridge/agent_initializer.py

@@ -0,0 +1,436 @@
+"""
+Agent Initializer - Handles agent initialization logic
+"""
+
+import os
+import asyncio
+import datetime
+import time
+from typing import Optional, List
+
+from agent.protocol import Agent
+from agent.tools import ToolManager
+from common.log import logger
+from common.utils import expand_path
+
+
+class AgentInitializer:
+    """
+    Handles agent initialization including:
+    - Workspace setup
+    - Memory system initialization  
+    - Tool loading
+    - System prompt building
+    """
+    
+    def __init__(self, bridge, agent_bridge):
+        """
+        Initialize agent initializer
+        
+        Args:
+            bridge: COW bridge instance
+            agent_bridge: AgentBridge instance (for create_agent method)
+        """
+        self.bridge = bridge
+        self.agent_bridge = agent_bridge
+    
+    def initialize_agent(self, session_id: Optional[str] = None) -> Agent:
+        """
+        Initialize agent for a session
+        
+        Args:
+            session_id: Session ID (None for default agent)
+        
+        Returns:
+            Initialized agent instance
+        """
+        from config import conf
+        
+        # Get workspace from config
+        workspace_root = expand_path(conf().get("agent_workspace", "~/cow"))
+        
+        # Migrate API keys
+        self._migrate_config_to_env(workspace_root)
+        
+        # Load environment variables
+        self._load_env_file()
+        
+        # Initialize workspace
+        from agent.prompt import ensure_workspace, load_context_files, PromptBuilder
+        workspace_files = ensure_workspace(workspace_root, create_templates=True)
+        
+        if session_id is None:
+            logger.info(f"[AgentInitializer] Workspace initialized at: {workspace_root}")
+        
+        # Setup memory system
+        memory_manager, memory_tools = self._setup_memory_system(workspace_root, session_id)
+        
+        # Load tools
+        tools = self._load_tools(workspace_root, memory_manager, memory_tools, session_id)
+        
+        # Initialize scheduler if needed
+        self._initialize_scheduler(tools, session_id)
+        
+        # Load context files
+        context_files = load_context_files(workspace_root)
+        
+        # Initialize skill manager
+        skill_manager = self._initialize_skill_manager(workspace_root, session_id)
+        
+        # Check if first conversation
+        from agent.prompt.workspace import is_first_conversation, mark_conversation_started
+        is_first = is_first_conversation(workspace_root)
+        
+        # Build system prompt
+        prompt_builder = PromptBuilder(workspace_dir=workspace_root, language="zh")
+        runtime_info = self._get_runtime_info(workspace_root)
+        
+        system_prompt = prompt_builder.build(
+            tools=tools,
+            context_files=context_files,
+            skill_manager=skill_manager,
+            memory_manager=memory_manager,
+            runtime_info=runtime_info,
+            is_first_conversation=is_first
+        )
+        
+        if is_first:
+            mark_conversation_started(workspace_root)
+        
+        # Get cost control parameters
+        from config import conf
+        max_steps = conf().get("agent_max_steps", 20)
+        max_context_tokens = conf().get("agent_max_context_tokens", 50000)
+        
+        # Create agent
+        agent = self.agent_bridge.create_agent(
+            system_prompt=system_prompt,
+            tools=tools,
+            max_steps=max_steps,
+            output_mode="logger",
+            workspace_dir=workspace_root,
+            skill_manager=skill_manager,
+            enable_skills=True,
+            max_context_tokens=max_context_tokens,
+            runtime_info=runtime_info  # Pass runtime_info for dynamic time updates
+        )
+        
+        # Attach memory manager
+        if memory_manager:
+            agent.memory_manager = memory_manager
+
+        # Restore persisted conversation history for this session
+        if session_id:
+            self._restore_conversation_history(agent, session_id)
+
+        return agent
+
+    def _restore_conversation_history(self, agent, session_id: str) -> None:
+        """
+        Load persisted conversation messages from SQLite and inject them
+        into the agent's in-memory message list.
+
+        Only runs when conversation persistence is enabled (default: True).
+        Respects agent_max_context_turns to limit how many turns are loaded.
+        """
+        from config import conf
+        if not conf().get("conversation_persistence", True):
+            return
+
+        try:
+            from agent.memory import get_conversation_store
+            store = get_conversation_store()
+            # On restore, load at most min(10, max_turns // 2) turns so that
+            # a long-running session does not immediately fill the context window
+            # after a restart.  The full max_turns budget is reserved for the
+            # live conversation that follows.
+            max_turns = conf().get("agent_max_context_turns", 30)
+            restore_turns = max(4, max_turns // 5)
+            saved = store.load_messages(session_id, max_turns=restore_turns)
+            if saved:
+                with agent.messages_lock:
+                    agent.messages = saved
+                logger.debug(
+                    f"[AgentInitializer] Restored {len(saved)} messages "
+                    f"({restore_turns} turns cap) for session={session_id}"
+                )
+        except Exception as e:
+            logger.warning(
+                f"[AgentInitializer] Failed to restore conversation history for "
+                f"session={session_id}: {e}"
+            )
+    
+    def _load_env_file(self):
+        """Load environment variables from .env file"""
+        env_file = expand_path("~/.cow/.env")
+        if os.path.exists(env_file):
+            try:
+                from dotenv import load_dotenv
+                load_dotenv(env_file, override=True)
+            except ImportError:
+                logger.warning("[AgentInitializer] python-dotenv not installed")
+            except Exception as e:
+                logger.warning(f"[AgentInitializer] Failed to load .env file: {e}")
+    
+    def _setup_memory_system(self, workspace_root: str, session_id: Optional[str] = None):
+        """
+        Setup memory system
+        
+        Returns:
+            (memory_manager, memory_tools) tuple
+        """
+        memory_manager = None
+        memory_tools = []
+        
+        try:
+            from agent.memory import MemoryManager, MemoryConfig, create_embedding_provider
+            from agent.tools import MemorySearchTool, MemoryGetTool
+            from config import conf
+            
+            # Get OpenAI config
+            openai_api_key = conf().get("open_ai_api_key", "")
+            openai_api_base = conf().get("open_ai_api_base", "")
+            
+            # Initialize embedding provider
+            embedding_provider = None
+            if openai_api_key and openai_api_key not in ["", "YOUR API KEY", "YOUR_API_KEY"]:
+                try:
+                    embedding_provider = create_embedding_provider(
+                        provider="openai",
+                        model="text-embedding-3-small",
+                        api_key=openai_api_key,
+                        api_base=openai_api_base or "https://api.openai.com/v1"
+                    )
+                    if session_id is None:
+                        logger.info("[AgentInitializer] OpenAI embedding initialized")
+                except Exception as e:
+                    logger.warning(f"[AgentInitializer] OpenAI embedding failed: {e}")
+            
+            # Create memory manager
+            memory_config = MemoryConfig(workspace_root=workspace_root)
+            memory_manager = MemoryManager(memory_config, embedding_provider=embedding_provider)
+            
+            # Sync memory
+            self._sync_memory(memory_manager, session_id)
+            
+            # Create memory tools
+            memory_tools = [
+                MemorySearchTool(memory_manager),
+                MemoryGetTool(memory_manager)
+            ]
+            
+            if session_id is None:
+                logger.info("[AgentInitializer] Memory system initialized")
+        
+        except Exception as e:
+            logger.warning(f"[AgentInitializer] Memory system not available: {e}")
+        
+        return memory_manager, memory_tools
+    
+    def _sync_memory(self, memory_manager, session_id: Optional[str] = None):
+        """Sync memory database"""
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_closed():
+                raise RuntimeError("Event loop is closed")
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        
+        try:
+            if loop.is_running():
+                asyncio.create_task(memory_manager.sync())
+            else:
+                loop.run_until_complete(memory_manager.sync())
+        except Exception as e:
+            logger.warning(f"[AgentInitializer] Memory sync failed: {e}")
+    
+    def _load_tools(self, workspace_root: str, memory_manager, memory_tools: List, session_id: Optional[str] = None):
+        """Load all tools"""
+        tool_manager = ToolManager()
+        tool_manager.load_tools()
+        
+        tools = []
+        file_config = {
+            "cwd": workspace_root,
+            "memory_manager": memory_manager
+        } if memory_manager else {"cwd": workspace_root}
+        
+        for tool_name in tool_manager.tool_classes.keys():
+            try:
+                # Skip web_search if no API key is available
+                if tool_name == "web_search":
+                    from agent.tools.web_search.web_search import WebSearch
+                    if not WebSearch.is_available():
+                        logger.debug("[AgentInitializer] WebSearch skipped - no BOCHA_API_KEY or LINKAI_API_KEY")
+                        continue
+
+                # Special handling for EnvConfig tool
+                if tool_name == "env_config":
+                    from agent.tools import EnvConfig
+                    tool = EnvConfig({"agent_bridge": self.agent_bridge})
+                else:
+                    tool = tool_manager.create_tool(tool_name)
+
+                if tool:
+                    # Apply workspace config to file operation tools
+                    if tool_name in ['read', 'write', 'edit', 'bash', 'grep', 'find', 'ls']:
+                        tool.config = file_config
+                        tool.cwd = file_config.get("cwd", getattr(tool, 'cwd', None))
+                        if 'memory_manager' in file_config:
+                            tool.memory_manager = file_config['memory_manager']
+                    tools.append(tool)
+            except Exception as e:
+                logger.warning(f"[AgentInitializer] Failed to load tool {tool_name}: {e}")
+        
+        # Add memory tools
+        if memory_tools:
+            tools.extend(memory_tools)
+            if session_id is None:
+                logger.info(f"[AgentInitializer] Added {len(memory_tools)} memory tools")
+        
+        if session_id is None:
+            logger.info(f"[AgentInitializer] Loaded {len(tools)} tools: {[t.name for t in tools]}")
+        
+        return tools
+    
+    def _initialize_scheduler(self, tools: List, session_id: Optional[str] = None):
+        """Initialize scheduler service if needed"""
+        if not self.agent_bridge.scheduler_initialized:
+            try:
+                from agent.tools.scheduler.integration import init_scheduler
+                if init_scheduler(self.agent_bridge):
+                    self.agent_bridge.scheduler_initialized = True
+                    if session_id is None:
+                        logger.info("[AgentInitializer] Scheduler service initialized")
+            except Exception as e:
+                logger.warning(f"[AgentInitializer] Failed to initialize scheduler: {e}")
+        
+        # Inject scheduler dependencies
+        if self.agent_bridge.scheduler_initialized:
+            try:
+                from agent.tools.scheduler.integration import get_task_store, get_scheduler_service
+                from agent.tools import SchedulerTool
+                from config import conf
+                
+                task_store = get_task_store()
+                scheduler_service = get_scheduler_service()
+                
+                for tool in tools:
+                    if isinstance(tool, SchedulerTool):
+                        tool.task_store = task_store
+                        tool.scheduler_service = scheduler_service
+                        if not tool.config:
+                            tool.config = {}
+                        raw_ct = conf().get("channel_type", "unknown")
+                        if isinstance(raw_ct, list):
+                            ct = raw_ct[0] if raw_ct else "unknown"
+                        elif isinstance(raw_ct, str) and "," in raw_ct:
+                            ct = raw_ct.split(",")[0].strip()
+                        else:
+                            ct = raw_ct
+                        tool.config["channel_type"] = ct
+            except Exception as e:
+                logger.warning(f"[AgentInitializer] Failed to inject scheduler dependencies: {e}")
+    
+    def _initialize_skill_manager(self, workspace_root: str, session_id: Optional[str] = None):
+        """Initialize skill manager"""
+        try:
+            from agent.skills import SkillManager
+            skill_manager = SkillManager(custom_dir=os.path.join(workspace_root, "skills"))
+            return skill_manager
+        except Exception as e:
+            logger.warning(f"[AgentInitializer] Failed to initialize SkillManager: {e}")
+            return None
+    
+    def _get_runtime_info(self, workspace_root: str):
+        """Get runtime information with dynamic time support"""
+        from config import conf
+        
+        def get_current_time():
+            """Get current time dynamically - called each time system prompt is accessed"""
+            now = datetime.datetime.now()
+            
+            # Get timezone info
+            try:
+                offset = -time.timezone if not time.daylight else -time.altzone
+                hours = offset // 3600
+                minutes = (offset % 3600) // 60
+                timezone_name = f"UTC{hours:+03d}:{minutes:02d}" if minutes else f"UTC{hours:+03d}"
+            except Exception:
+                timezone_name = "UTC"
+            
+            # Chinese weekday mapping
+            weekday_map = {
+                'Monday': '星期一', 'Tuesday': '星期二', 'Wednesday': '星期三',
+                'Thursday': '星期四', 'Friday': '星期五', 'Saturday': '星期六', 'Sunday': '星期日'
+            }
+            weekday_zh = weekday_map.get(now.strftime("%A"), now.strftime("%A"))
+            
+            return {
+                'time': now.strftime("%Y-%m-%d %H:%M:%S"),
+                'weekday': weekday_zh,
+                'timezone': timezone_name
+            }
+        
+        return {
+            "model": conf().get("model", "unknown"),
+            "workspace": workspace_root,
+            "channel": ", ".join(conf().get("channel_type")) if isinstance(conf().get("channel_type"), list) else conf().get("channel_type", "unknown"),
+            "_get_current_time": get_current_time  # Dynamic time function
+        }
+    
+    def _migrate_config_to_env(self, workspace_root: str):
+        """Migrate API keys from config.json to .env file"""
+        from config import conf
+        
+        key_mapping = {
+            "open_ai_api_key": "OPENAI_API_KEY",
+            "open_ai_api_base": "OPENAI_API_BASE",
+            "gemini_api_key": "GEMINI_API_KEY",
+            "claude_api_key": "CLAUDE_API_KEY",
+            "linkai_api_key": "LINKAI_API_KEY",
+        }
+        
+        env_file = expand_path("~/.cow/.env")
+        
+        # Read existing env vars
+        existing_env_vars = {}
+        if os.path.exists(env_file):
+            try:
+                with open(env_file, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        line = line.strip()
+                        if line and not line.startswith('#') and '=' in line:
+                            key, _ = line.split('=', 1)
+                            existing_env_vars[key.strip()] = True
+            except Exception as e:
+                logger.warning(f"[AgentInitializer] Failed to read .env file: {e}")
+        
+        # Check which keys need migration
+        keys_to_migrate = {}
+        for config_key, env_key in key_mapping.items():
+            if env_key in existing_env_vars:
+                continue
+            value = conf().get(config_key, "")
+            if value and value.strip():
+                keys_to_migrate[env_key] = value.strip()
+        
+        # Write new keys
+        if keys_to_migrate:
+            try:
+                env_dir = os.path.dirname(env_file)
+                if not os.path.exists(env_dir):
+                    os.makedirs(env_dir, exist_ok=True)
+                if not os.path.exists(env_file):
+                    open(env_file, 'a').close()
+                
+                with open(env_file, 'a', encoding='utf-8') as f:
+                    f.write('\n# Auto-migrated from config.json\n')
+                    for key, value in keys_to_migrate.items():
+                        f.write(f'{key}={value}\n')
+                        os.environ[key] = value
+                
+                logger.info(f"[AgentInitializer] Migrated {len(keys_to_migrate)} API keys to .env: {list(keys_to_migrate.keys())}")
+            except Exception as e:
+                logger.warning(f"[AgentInitializer] Failed to migrate API keys: {e}")

bridge/bridge.py

@@ -24,6 +24,13 @@ class Bridge(object):
             self.btype["chat"] = bot_type
         else:
             model_type = conf().get("model") or const.GPT_41_MINI
+            
+            # Ensure model_type is string to prevent AttributeError when using startswith()
+            # This handles cases where numeric model names (e.g., "1") are parsed as integers from YAML
+            if not isinstance(model_type, str):
+                logger.warning(f"[Bridge] model_type is not a string: {model_type} (type: {type(model_type).__name__}), converting to string")
+                model_type = str(model_type)
+            
             if model_type in ["text-davinci-003"]:
                 self.btype["chat"] = const.OPEN_AI
             if conf().get("use_azure_chatgpt", False):
@@ -36,6 +43,9 @@ class Bridge(object):
                 self.btype["chat"] = const.QWEN
             if model_type in [const.QWEN_TURBO, const.QWEN_PLUS, const.QWEN_MAX]:
                 self.btype["chat"] = const.QWEN_DASHSCOPE
+            # Support Qwen3 and other DashScope models
+            if model_type and (model_type.startswith("qwen") or model_type.startswith("qwq") or model_type.startswith("qvq")):
+                self.btype["chat"] = const.QWEN_DASHSCOPE
             if model_type and model_type.startswith("gemini"):
                 self.btype["chat"] = const.GEMINI
             if model_type and model_type.startswith("glm"):
@@ -43,16 +53,19 @@ class Bridge(object):
             if model_type and model_type.startswith("claude"):
                 self.btype["chat"] = const.CLAUDEAPI
 
-            if model_type in ["claude"]:
-                self.btype["chat"] = const.CLAUDEAI
-
             if model_type in [const.MOONSHOT, "moonshot-v1-8k", "moonshot-v1-32k", "moonshot-v1-128k"]:
                 self.btype["chat"] = const.MOONSHOT
+            if model_type and model_type.startswith("kimi"):
+                self.btype["chat"] = const.MOONSHOT
+
+            if model_type and model_type.startswith("doubao"):
+                self.btype["chat"] = const.DOUBAO
 
             if model_type in [const.MODELSCOPE]:
                 self.btype["chat"] = const.MODELSCOPE
             
-            if model_type in ["abab6.5-chat"]:
+            # MiniMax models
+            if model_type and (model_type in ["abab6.5-chat", "abab6.5"] or model_type.lower().startswith("minimax")):
                 self.btype["chat"] = const.MiniMax
 
             if conf().get("use_linkai") and conf().get("linkai_api_key"):

channel/channel.py

@@ -19,6 +19,12 @@ class Channel(object):
         """
         raise NotImplementedError
 
+    def stop(self):
+        """
+        stop channel gracefully, called before restart
+        """
+        pass
+
     def handle_text(self, msg):
         """
         process received msg
@@ -51,11 +57,14 @@ class Channel(object):
                 if context and "channel_type" not in context:
                     context["channel_type"] = self.channel_type
 
+                # Read on_event callback injected by the channel (e.g. web SSE)
+                on_event = context.get("on_event") if context else None
+
                 # Use agent bridge to handle the query
                 return Bridge().fetch_agent_reply(
                     query=query,
                     context=context,
-                    on_event=None,
+                    on_event=on_event,
                     clear_history=False
                 )
             except Exception as e:

channel/chat_channel.py

@@ -24,11 +24,16 @@ handler_pool = ThreadPoolExecutor(max_workers=8)  # 处理消息的线程池
 class ChatChannel(Channel):
     name = None  # 登录的用户名
     user_id = None  # 登录的用户id
-    futures = {}  # 记录每个session_id提交到线程池的future对象, 用于重置会话时把没执行的future取消掉，正在执行的不会被取消
-    sessions = {}  # 用于控制并发，每个session_id同时只能有一个context在处理
-    lock = threading.Lock()  # 用于控制对sessions的访问
 
     def __init__(self):
+        # Instance-level attributes so each channel subclass has its own
+        # independent session queue and lock. Previously these were class-level,
+        # which caused contexts from one channel (e.g. Feishu) to be consumed
+        # by another channel's consume() thread (e.g. Web), leading to errors
+        # like "No request_id found in context".
+        self.futures = {}
+        self.sessions = {}
+        self.lock = threading.Lock()
         _thread = threading.Thread(target=self.consume)
         _thread.setDaemon(True)
         _thread.start()
@@ -37,9 +42,8 @@ class ChatChannel(Channel):
     def _compose_context(self, ctype: ContextType, content, **kwargs):
         context = Context(ctype, content)
         context.kwargs = kwargs
-        # context首次传入时，origin_ctype是None,
-        # 引入的起因是：当输入语音时，会嵌套生成两个context，第一步语音转文本，第二步通过文本生成文字回复。
-        # origin_ctype用于第二步文本回复时，判断是否需要匹配前缀，如果是私聊的语音，就不需要匹配前缀
+        if "channel_type" not in context:
+            context["channel_type"] = self.channel_type
         if "origin_ctype" not in context:
             context["origin_ctype"] = ctype
         # context首次传入时，receiver是None，根据类型设置receiver

channel/dingtalk/dingtalk_channel.py

@@ -21,6 +21,7 @@ from dingtalk_stream.card_replier import CardReplier
 from bridge.context import Context, ContextType
 from bridge.reply import Reply, ReplyType
 from channel.chat_channel import ChatChannel
+from common.utils import expand_path
 from channel.dingtalk.dingtalk_message import DingTalkMessage
 from common.expired_dict import ExpiredDict
 from common.log import logger
@@ -89,13 +90,9 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
     dingtalk_client_secret = conf().get('dingtalk_client_secret')
 
     def setup_logger(self):
-        logger = logging.getLogger()
-        handler = logging.StreamHandler()
-        handler.setFormatter(
-            logging.Formatter('%(asctime)s %(name)-8s %(levelname)-8s %(message)s [%(filename)s:%(lineno)d]'))
-        logger.addHandler(handler)
-        logger.setLevel(logging.INFO)
-        return logger
+        # Suppress verbose logs from dingtalk_stream SDK
+        logging.getLogger("dingtalk_stream").setLevel(logging.WARNING)
+        return logging.getLogger("DingTalk")
 
     def __init__(self):
         super().__init__()
@@ -103,6 +100,9 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
         self.logger = self.setup_logger()
         # 历史消息id暂存，用于幂等控制
         self.receivedMsgs = ExpiredDict(conf().get("expires_in_seconds", 3600))
+        self._stream_client = None
+        self._running = False
+        self._event_loop = None
         logger.debug("[DingTalk] client_id={}, client_secret={} ".format(
             self.dingtalk_client_id, self.dingtalk_client_secret))
         # 无需群校验和前缀
@@ -116,11 +116,54 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
         self._robot_code = None
 
     def startup(self):
+        import asyncio
+        self.dingtalk_client_id = conf().get('dingtalk_client_id')
+        self.dingtalk_client_secret = conf().get('dingtalk_client_secret')
+        self._running = True
         credential = dingtalk_stream.Credential(self.dingtalk_client_id, self.dingtalk_client_secret)
         client = dingtalk_stream.DingTalkStreamClient(credential)
+        self._stream_client = client
         client.register_callback_handler(dingtalk_stream.chatbot.ChatbotMessage.TOPIC, self)
-        logger.info("[DingTalk] ✅ Stream connected, ready to receive messages")
-        client.start_forever()
+        logger.info("[DingTalk] ✅ Stream client initialized, ready to receive messages")
+        _first_connect = True
+        while self._running:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            self._event_loop = loop
+            try:
+                if not _first_connect:
+                    logger.info("[DingTalk] Reconnecting...")
+                _first_connect = False
+                loop.run_until_complete(client.start())
+            except (KeyboardInterrupt, SystemExit):
+                logger.info("[DingTalk] Startup loop received stop signal, exiting")
+                break
+            except Exception as e:
+                if not self._running:
+                    break
+                logger.warning(f"[DingTalk] Stream connection error: {e}, reconnecting in 3s...")
+                time.sleep(3)
+            finally:
+                self._event_loop = None
+                try:
+                    loop.close()
+                except Exception:
+                    pass
+        logger.info("[DingTalk] Startup loop exited")
+
+    def stop(self):
+        import asyncio
+        logger.info("[DingTalk] stop() called, setting _running=False")
+        self._running = False
+        loop = self._event_loop
+        if loop and not loop.is_closed():
+            try:
+                loop.call_soon_threadsafe(loop.stop)
+                logger.info("[DingTalk] Sent stop signal to event loop")
+            except Exception as e:
+                logger.warning(f"[DingTalk] Error stopping event loop: {e}")
+        self._stream_client = None
+        logger.info("[DingTalk] stop() completed")
     
     def get_access_token(self):
         """
@@ -276,7 +319,7 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
                 
                 # 保存到临时文件
                 file_name = os.path.basename(file_path) or f"media_{uuid.uuid4()}"
-                workspace_root = os.path.expanduser(conf().get("agent_workspace", "~/cow"))
+                workspace_root = expand_path(conf().get("agent_workspace", "~/cow"))
                 tmp_dir = os.path.join(workspace_root, "tmp")
                 os.makedirs(tmp_dir, exist_ok=True)
                 temp_file = os.path.join(tmp_dir, file_name)
@@ -457,23 +500,21 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
     async def process(self, callback: dingtalk_stream.CallbackMessage):
         try:
             incoming_message = dingtalk_stream.ChatbotMessage.from_dict(callback.data)
-            
+
             # 缓存 robot_code，用于后续图片下载
             if hasattr(incoming_message, 'robot_code'):
                 self._robot_code_cache = incoming_message.robot_code
-            
-            # Debug: 打印完整的 event 数据
-            logger.debug(f"[DingTalk] ===== Incoming Message Debug =====")
-            logger.debug(f"[DingTalk] callback.data keys: {callback.data.keys() if hasattr(callback.data, 'keys') else 'N/A'}")
-            logger.debug(f"[DingTalk] incoming_message attributes: {dir(incoming_message)}")
-            logger.debug(f"[DingTalk] robot_code: {getattr(incoming_message, 'robot_code', 'N/A')}")
-            logger.debug(f"[DingTalk] chatbot_corp_id: {getattr(incoming_message, 'chatbot_corp_id', 'N/A')}")
-            logger.debug(f"[DingTalk] chatbot_user_id: {getattr(incoming_message, 'chatbot_user_id', 'N/A')}")
-            logger.debug(f"[DingTalk] conversation_id: {getattr(incoming_message, 'conversation_id', 'N/A')}")
-            logger.debug(f"[DingTalk] Raw callback.data: {callback.data}")
-            logger.debug(f"[DingTalk] =====================================")
-            
-            image_download_handler = self  # 传入方法所在的类实例
+
+            # Filter out stale messages from before channel startup (offline backlog)
+            create_at = getattr(incoming_message, 'create_at', None)
+            if create_at:
+                msg_age_s = time.time() - int(create_at) / 1000
+                if msg_age_s > 60:
+                    logger.warning(f"[DingTalk] stale msg filtered (age={msg_age_s:.0f}s), "
+                                   f"msg_id={getattr(incoming_message, 'message_id', 'N/A')}")
+                    return AckMessage.STATUS_OK, 'OK'
+
+            image_download_handler = self
             dingtalk_msg = DingTalkMessage(incoming_message, image_download_handler)
 
             if dingtalk_msg.is_group:
@@ -482,8 +523,7 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
                 self.handle_single(dingtalk_msg)
             return AckMessage.STATUS_OK, 'OK'
         except Exception as e:
-            logger.error(f"[DingTalk] process error: {e}")
-            logger.exception(e)  # 打印完整堆栈跟踪
+            logger.error(f"[DingTalk] process error: {e}", exc_info=True)
             return AckMessage.STATUS_SYSTEM_EXCEPTION, 'ERROR'
 
     @time_checker
@@ -607,7 +647,7 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
 
 
     def send(self, reply: Reply, context: Context):
-        logger.info(f"[DingTalk] send() called with reply.type={reply.type}, content_length={len(str(reply.content))}")
+        logger.debug(f"[DingTalk] send() called with reply.type={reply.type}, content_length={len(str(reply.content))}")
         receiver = context["receiver"]
         
         # Check if msg exists (for scheduled tasks, msg might be None)
@@ -647,7 +687,7 @@ class DingTalkChanel(ChatChannel, dingtalk_stream.ChatbotHandler):
             robot_code = msg.robot_code
             if robot_code and robot_code != self._robot_code:
                 self._robot_code = robot_code
-                logger.info(f"[DingTalk] Cached robot_code: {robot_code}")
+                logger.debug(f"[DingTalk] Cached robot_code: {robot_code}")
         
         isgroup = msg.is_group
         incoming_message = msg.incoming_message

channel/dingtalk/dingtalk_message.py

@@ -9,6 +9,7 @@ from channel.chat_message import ChatMessage
 # -*- coding=utf-8 -*-
 from common.log import logger
 from common.tmp_dir import TmpDir
+from common.utils import expand_path
 from config import conf
 
 
@@ -49,7 +50,7 @@ class DingTalkMessage(ChatMessage):
                 download_url = image_download_handler.get_image_download_url(download_code)
                 
                 # 下载到工作空间 tmp 目录
-                workspace_root = os.path.expanduser(conf().get("agent_workspace", "~/cow"))
+                workspace_root = expand_path(conf().get("agent_workspace", "~/cow"))
                 tmp_dir = os.path.join(workspace_root, "tmp")
                 os.makedirs(tmp_dir, exist_ok=True)
                 
@@ -67,7 +68,7 @@ class DingTalkMessage(ChatMessage):
                 self.ctype = ContextType.TEXT
                 
                 # 下载到工作空间 tmp 目录
-                workspace_root = os.path.expanduser(conf().get("agent_workspace", "~/cow"))
+                workspace_root = expand_path(conf().get("agent_workspace", "~/cow"))
                 tmp_dir = os.path.join(workspace_root, "tmp")
                 os.makedirs(tmp_dir, exist_ok=True)
                 

channel/feishu/README.md

@@ -140,6 +140,23 @@ python3 app.py
 
 **解决**: 安装依赖 `pip install lark-oapi`
 
+### SSL证书验证失败
+
+```
+[Lark][ERROR] connect failed, err:[SSL:CERTIFICATE_VERIFY_FAILED] certificate verify failed: self signed certificate in certificate chain
+```
+
+**原因**: 网络环境中存在自签名证书或SSL中间人代理(如企业代理、VPN等)
+
+**解决**: 程序会自动检测SSL证书验证失败，并自动重试禁用证书验证的连接。无需手动配置。
+
+当遇到证书错误时，日志会显示：
+```
+[FeiShu] SSL certificate verification disabled due to certificate error. This may happen when using corporate proxy or self-signed certificates.
+```
+
+这是正常现象，程序会自动处理并继续运行。
+
 ### Webhook模式端口被占用
 
 ```

channel/feishu/feishu_channel.py

@@ -12,7 +12,9 @@
 """
 
 import json
+import logging
 import os
+import ssl
 import threading
 # -*- coding=utf-8 -*-
 import uuid
@@ -31,6 +33,9 @@ from common.log import logger
 from common.singleton import singleton
 from config import conf
 
+# Suppress verbose logs from Lark SDK
+logging.getLogger("Lark").setLevel(logging.WARNING)
+
 URL_VERIFICATION = "url_verification"
 
 # 尝试导入飞书SDK,如果未安装则websocket模式不可用
@@ -55,6 +60,9 @@ class FeiShuChanel(ChatChannel):
         super().__init__()
         # 历史消息id暂存，用于幂等控制
         self.receivedMsgs = ExpiredDict(60 * 60 * 7.1)
+        self._http_server = None
+        self._ws_client = None
+        self._ws_thread = None
         logger.debug("[FeiShu] app_id={}, app_secret={}, verification_token={}, event_mode={}".format(
             self.feishu_app_id, self.feishu_app_secret, self.feishu_token, self.feishu_event_mode))
         # 无需群校验和前缀
@@ -67,11 +75,46 @@ class FeiShuChanel(ChatChannel):
             raise Exception("lark_oapi not installed")
 
     def startup(self):
+        self.feishu_app_id = conf().get('feishu_app_id')
+        self.feishu_app_secret = conf().get('feishu_app_secret')
+        self.feishu_token = conf().get('feishu_token')
+        self.feishu_event_mode = conf().get('feishu_event_mode', 'websocket')
         if self.feishu_event_mode == 'websocket':
             self._startup_websocket()
         else:
             self._startup_webhook()
 
+    def stop(self):
+        import ctypes
+        logger.info("[FeiShu] stop() called")
+        ws_client = self._ws_client
+        self._ws_client = None
+        ws_thread = self._ws_thread
+        self._ws_thread = None
+        # Interrupt the ws thread first so its blocking start() unblocks
+        if ws_thread and ws_thread.is_alive():
+            try:
+                tid = ws_thread.ident
+                if tid:
+                    res = ctypes.pythonapi.PyThreadState_SetAsyncExc(
+                        ctypes.c_ulong(tid), ctypes.py_object(SystemExit)
+                    )
+                    if res == 1:
+                        logger.info("[FeiShu] Interrupted ws thread via ctypes")
+                    elif res > 1:
+                        ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_ulong(tid), None)
+            except Exception as e:
+                logger.warning(f"[FeiShu] Error interrupting ws thread: {e}")
+        # lark.ws.Client has no stop() method; thread interruption above is sufficient
+        if self._http_server:
+            try:
+                self._http_server.stop()
+                logger.info("[FeiShu] HTTP server stopped")
+            except Exception as e:
+                logger.warning(f"[FeiShu] Error stopping HTTP server: {e}")
+            self._http_server = None
+        logger.info("[FeiShu] stop() completed")
+
     def _startup_webhook(self):
         """启动HTTP服务器接收事件(webhook模式)"""
         logger.debug("[FeiShu] Starting in webhook mode...")
@@ -80,7 +123,14 @@ class FeiShuChanel(ChatChannel):
         )
         app = web.application(urls, globals(), autoreload=False)
         port = conf().get("feishu_port", 9891)
-        web.httpserver.runsimple(app.wsgifunc(), ("0.0.0.0", port))
+        func = web.httpserver.StaticMiddleware(app.wsgifunc())
+        func = web.httpserver.LogMiddleware(func)
+        server = web.httpserver.WSGIServer(("0.0.0.0", port), func)
+        self._http_server = server
+        try:
+            server.start()
+        except (KeyboardInterrupt, SystemExit):
+            server.stop()
 
     def _startup_websocket(self):
         """启动长连接接收事件(websocket模式)"""
@@ -107,27 +157,63 @@ class FeiShuChanel(ChatChannel):
             .register_p2_im_message_receive_v1(handle_message_event) \
             .build()
 
-        # 创建长连接客户端
-        ws_client = lark.ws.Client(
-            self.feishu_app_id,
-            self.feishu_app_secret,
-            event_handler=event_handler,
-            log_level=lark.LogLevel.DEBUG if conf().get("debug") else lark.LogLevel.INFO
-        )
+        def start_client_with_retry():
+            """Run ws client in this thread with its own event loop to avoid conflicts."""
+            import asyncio
+            import ssl as ssl_module
+            original_create_default_context = ssl_module.create_default_context
 
-        # 在新线程中启动客户端，避免阻塞主线程
-        def start_client():
+            def create_unverified_context(*args, **kwargs):
+                context = original_create_default_context(*args, **kwargs)
+                context.check_hostname = False
+                context.verify_mode = ssl.CERT_NONE
+                return context
+
+            # Give this thread its own event loop so lark SDK can call run_until_complete
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+            for attempt in range(2):
+                try:
+                    if attempt == 1:
+                        logger.warning("[FeiShu] Retrying with SSL verification disabled...")
+                        ssl_module.create_default_context = create_unverified_context
+                        ssl_module._create_unverified_context = create_unverified_context
+
+                    ws_client = lark.ws.Client(
+                        self.feishu_app_id,
+                        self.feishu_app_secret,
+                        event_handler=event_handler,
+                        log_level=lark.LogLevel.WARNING
+                    )
+                    self._ws_client = ws_client
+                    logger.debug("[FeiShu] Websocket client starting...")
+                    ws_client.start()
+                    break
+
+                except (SystemExit, KeyboardInterrupt):
+                    logger.info("[FeiShu] Websocket thread received stop signal")
+                    break
+                except Exception as e:
+                    error_msg = str(e)
+                    is_ssl_error = ("CERTIFICATE_VERIFY_FAILED" in error_msg
+                                    or "certificate verify failed" in error_msg.lower())
+                    if is_ssl_error and attempt == 0:
+                        logger.warning(f"[FeiShu] SSL error: {error_msg}, retrying...")
+                        continue
+                    logger.error(f"[FeiShu] Websocket client error: {e}", exc_info=True)
+                    ssl_module.create_default_context = original_create_default_context
+                    break
             try:
-                logger.debug("[FeiShu] Websocket client starting...")
-                ws_client.start()
-            except Exception as e:
-                logger.error(f"[FeiShu] Websocket client error: {e}", exc_info=True)
+                loop.close()
+            except Exception:
+                pass
+            logger.info("[FeiShu] Websocket thread exited")
 
-        ws_thread = threading.Thread(target=start_client, daemon=True)
+        ws_thread = threading.Thread(target=start_client_with_retry, daemon=True)
+        self._ws_thread = ws_thread
         ws_thread.start()
-
-        # 保持主线程运行
-        logger.info("[FeiShu] ✅ Websocket connected, ready to receive messages")
+        logger.info("[FeiShu] ✅ Websocket thread started, ready to receive messages")
         ws_thread.join()
 
     def _handle_message_event(self, event: dict):
@@ -148,6 +234,15 @@ class FeiShuChanel(ChatChannel):
             return
         self.receivedMsgs[msg_id] = True
 
+        # Filter out stale messages from before channel startup (offline backlog)
+        import time as _time
+        create_time_ms = msg.get("create_time")
+        if create_time_ms:
+            msg_age_s = _time.time() - int(create_time_ms) / 1000
+            if msg_age_s > 60:
+                logger.warning(f"[FeiShu] stale msg filtered (age={msg_age_s:.0f}s), msg_id={msg_id}")
+                return
+
         is_group = False
         chat_type = msg.get("chat_type")
 
@@ -176,7 +271,7 @@ class FeiShuChanel(ChatChannel):
         # 处理文件缓存逻辑
         from channel.file_cache import get_file_cache
         file_cache = get_file_cache()
-        
+
         # 获取 session_id（用于缓存关联）
         if is_group:
             if conf().get("group_shared_session", True):
@@ -185,7 +280,7 @@ class FeiShuChanel(ChatChannel):
                 session_id = feishu_msg.from_user_id + "_" + msg.get("chat_id")
         else:
             session_id = feishu_msg.from_user_id
-        
+
         # 如果是单张图片消息，缓存起来
         if feishu_msg.ctype == ContextType.IMAGE:
             if hasattr(feishu_msg, 'image_path') and feishu_msg.image_path:
@@ -193,7 +288,7 @@ class FeiShuChanel(ChatChannel):
                 logger.info(f"[FeiShu] Image cached for session {session_id}, waiting for user query...")
             # 单张图片不直接处理，等待用户提问
             return
-        
+
         # 如果是文本消息，检查是否有缓存的文件
         if feishu_msg.ctype == ContextType.TEXT:
             cached_files = file_cache.get(session_id)
@@ -209,7 +304,7 @@ class FeiShuChanel(ChatChannel):
                         file_refs.append(f"[视频: {file_path}]")
                     else:
                         file_refs.append(f"[文件: {file_path}]")
-                
+
                 feishu_msg.content = feishu_msg.content + "\n" + "\n".join(file_refs)
                 logger.info(f"[FeiShu] Attached {len(cached_files)} cached file(s) to user query")
                 # 清除缓存
@@ -251,28 +346,35 @@ class FeiShuChanel(ChatChannel):
             msg_type = "image"
             content_key = "image_key"
         elif reply.type == ReplyType.FILE:
+            # 如果有附加的文本内容，先发送文本
+            if hasattr(reply, 'text_content') and reply.text_content:
+                logger.info(f"[FeiShu] Sending text before file: {reply.text_content[:50]}...")
+                text_reply = Reply(ReplyType.TEXT, reply.text_content)
+                self._send(text_reply, context)
+                import time
+                time.sleep(0.3)  # 短暂延迟，确保文本先到达
+
             # 判断是否为视频文件
             file_path = reply.content
             if file_path.startswith("file://"):
                 file_path = file_path[7:]
-            
+
             is_video = file_path.lower().endswith(('.mp4', '.avi', '.mov', '.wmv', '.flv'))
-            
+
             if is_video:
-                # 视频使用 media 类型，需要上传并获取 file_key 和 duration
-                video_info = self._upload_video_url(reply.content, access_token)
-                if not video_info or not video_info.get('file_key'):
+                # 视频上传（包含duration信息）
+                upload_data = self._upload_video_url(reply.content, access_token)
+                if not upload_data or not upload_data.get('file_key'):
                     logger.warning("[FeiShu] upload video failed")
                     return
-                
-                # media 类型需要特殊的 content 格式
+
+                # 视频使用 media 类型（根据官方文档）
+                # 错误码 230055 说明：上传 mp4 时必须使用 msg_type="media"
                 msg_type = "media"
-                # 注意：media 类型的 content 不使用 content_key，而是完整的 JSON 对象
-                reply_content = {
-                    "file_key": video_info['file_key'],
-                    "duration": video_info.get('duration', 0)  # 视频时长（毫秒）
-                }
-                content_key = None  # media 类型不使用单一的 key
+                reply_content = upload_data  # 完整的上传响应数据（包含file_key和duration）
+                logger.info(
+                    f"[FeiShu] Sending video: file_key={upload_data.get('file_key')}, duration={upload_data.get('duration')}ms")
+                content_key = None  # 直接序列化整个对象
             else:
                 # 其他文件使用 file 类型
                 file_key = self._upload_file_url(reply.content, access_token)
@@ -282,16 +384,20 @@ class FeiShuChanel(ChatChannel):
                 reply_content = file_key
                 msg_type = "file"
                 content_key = "file_key"
-        
+
         # Check if we can reply to an existing message (need msg_id)
         can_reply = is_group and msg and hasattr(msg, 'msg_id') and msg.msg_id
-        
+
+        # Build content JSON
+        content_json = json.dumps(reply_content) if content_key is None else json.dumps({content_key: reply_content})
+        logger.debug(f"[FeiShu] Sending message: msg_type={msg_type}, content={content_json[:200]}")
+
         if can_reply:
             # 群聊中回复已有消息
             url = f"https://open.feishu.cn/open-apis/im/v1/messages/{msg.msg_id}/reply"
             data = {
                 "msg_type": msg_type,
-                "content": json.dumps(reply_content) if content_key is None else json.dumps({content_key: reply_content})
+                "content": content_json
             }
             res = requests.post(url=url, headers=headers, json=data, timeout=(5, 10))
         else:
@@ -301,7 +407,7 @@ class FeiShuChanel(ChatChannel):
             data = {
                 "receive_id": context.get("receiver"),
                 "msg_type": msg_type,
-                "content": json.dumps(reply_content) if content_key is None else json.dumps({content_key: reply_content})
+                "content": content_json
             }
             res = requests.post(url=url, headers=headers, params=params, json=data, timeout=(5, 10))
         res = res.json()
@@ -310,7 +416,6 @@ class FeiShuChanel(ChatChannel):
         else:
             logger.error(f"[FeiShu] send message failed, code={res.get('code')}, msg={res.get('msg')}")
 
-
     def fetch_access_token(self) -> str:
         url = "https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal/"
         headers = {
@@ -332,35 +437,34 @@ class FeiShuChanel(ChatChannel):
         else:
             logger.error(f"[FeiShu] fetch token error, res={response}")
 
-
     def _upload_image_url(self, img_url, access_token):
         logger.debug(f"[FeiShu] start process image, img_url={img_url}")
-        
+
         # Check if it's a local file path (file:// protocol)
         if img_url.startswith("file://"):
             local_path = img_url[7:]  # Remove "file://" prefix
             logger.info(f"[FeiShu] uploading local file: {local_path}")
-            
+
             if not os.path.exists(local_path):
                 logger.error(f"[FeiShu] local file not found: {local_path}")
                 return None
-            
+
             # Upload directly from local file
             upload_url = "https://open.feishu.cn/open-apis/im/v1/images"
             data = {'image_type': 'message'}
             headers = {'Authorization': f'Bearer {access_token}'}
-            
+
             with open(local_path, "rb") as file:
                 upload_response = requests.post(upload_url, files={"image": file}, data=data, headers=headers)
                 logger.info(f"[FeiShu] upload file, res={upload_response.content}")
-                
+
                 response_data = upload_response.json()
                 if response_data.get("code") == 0:
                     return response_data.get("data").get("image_key")
                 else:
                     logger.error(f"[FeiShu] upload failed: {response_data}")
                     return None
-        
+
         # Original logic for HTTP URLs
         response = requests.get(img_url)
         suffix = utils.get_path_suffix(img_url)
@@ -396,7 +500,7 @@ class FeiShuChanel(ChatChannel):
         """
         try:
             import subprocess
-            
+
             # 使用 ffprobe 获取视频时长
             cmd = [
                 'ffprobe',
@@ -405,7 +509,7 @@ class FeiShuChanel(ChatChannel):
                 '-of', 'default=noprint_wrappers=1:nokey=1',
                 file_path
             ]
-            
+
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
             if result.returncode == 0:
                 duration_seconds = float(result.stdout.strip())
@@ -434,7 +538,7 @@ class FeiShuChanel(ChatChannel):
         """
         local_path = None
         temp_file = None
-        
+
         try:
             # For file:// URLs (local files), upload directly
             if video_url.startswith("file://"):
@@ -449,56 +553,67 @@ class FeiShuChanel(ChatChannel):
                 if response.status_code != 200:
                     logger.error(f"[FeiShu] download video failed, status={response.status_code}")
                     return None
-                
+
                 # Save to temp file
                 import uuid
                 file_name = os.path.basename(video_url) or "video.mp4"
                 temp_file = str(uuid.uuid4()) + "_" + file_name
-                
+
                 with open(temp_file, "wb") as file:
                     file.write(response.content)
-                
+
                 logger.info(f"[FeiShu] Video downloaded, size={len(response.content)} bytes")
                 local_path = temp_file
-            
+
             # Get video duration
             duration = self._get_video_duration(local_path)
-            
+
             # Upload to Feishu
             file_name = os.path.basename(local_path)
             file_ext = os.path.splitext(file_name)[1].lower()
             file_type_map = {'.mp4': 'mp4'}
             file_type = file_type_map.get(file_ext, 'mp4')
-            
+
             upload_url = "https://open.feishu.cn/open-apis/im/v1/files"
-            data = {'file_type': file_type, 'file_name': file_name}
+            data = {
+                'file_type': file_type,
+                'file_name': file_name
+            }
+            # Add duration only if available (required for video/audio)
+            if duration:
+                data['duration'] = duration  # Must be int, not string
+
             headers = {'Authorization': f'Bearer {access_token}'}
-            
+
+            logger.info(f"[FeiShu] Uploading video: file_name={file_name}, duration={duration}ms")
+
             with open(local_path, "rb") as file:
                 upload_response = requests.post(
-                    upload_url, 
-                    files={"file": file}, 
-                    data=data, 
-                    headers=headers, 
+                    upload_url,
+                    files={"file": file},
+                    data=data,
+                    headers=headers,
                     timeout=(5, 60)
                 )
-                logger.info(f"[FeiShu] upload video response, status={upload_response.status_code}, res={upload_response.content}")
-                
+                logger.info(
+                    f"[FeiShu] upload video response, status={upload_response.status_code}, res={upload_response.content}")
+
                 response_data = upload_response.json()
                 if response_data.get("code") == 0:
-                    file_key = response_data.get("data").get("file_key")
-                    return {
-                        'file_key': file_key,
-                        'duration': duration
-                    }
+                    # Add duration to the response data (API doesn't return it)
+                    upload_data = response_data.get("data")
+                    upload_data['duration'] = duration  # Add our calculated duration
+                    logger.info(
+                        f"[FeiShu] Upload complete: file_key={upload_data.get('file_key')}, duration={duration}ms")
+                    return upload_data
                 else:
                     logger.error(f"[FeiShu] upload video failed: {response_data}")
                     return None
-        
+
         except Exception as e:
             logger.error(f"[FeiShu] upload video exception: {e}")
             return None
-        
+
         finally:
             # Clean up temp file
             if temp_file and os.path.exists(temp_file):
@@ -513,20 +628,20 @@ class FeiShuChanel(ChatChannel):
         Supports both local files (file://) and HTTP URLs
         """
         logger.debug(f"[FeiShu] start process file, file_url={file_url}")
-        
+
         # Check if it's a local file path (file:// protocol)
         if file_url.startswith("file://"):
             local_path = file_url[7:]  # Remove "file://" prefix
             logger.info(f"[FeiShu] uploading local file: {local_path}")
-            
+
             if not os.path.exists(local_path):
                 logger.error(f"[FeiShu] local file not found: {local_path}")
                 return None
-            
+
             # Get file info
             file_name = os.path.basename(local_path)
             file_ext = os.path.splitext(file_name)[1].lower()
-            
+
             # Determine file type for Feishu API
             # Feishu supports: opus, mp4, pdf, doc, xls, ppt, stream (other types)
             file_type_map = {
@@ -538,23 +653,24 @@ class FeiShuChanel(ChatChannel):
                 '.ppt': 'ppt', '.pptx': 'ppt',
             }
             file_type = file_type_map.get(file_ext, 'stream')  # Default to stream for other types
-            
+
             # Upload file to Feishu
             upload_url = "https://open.feishu.cn/open-apis/im/v1/files"
             data = {'file_type': file_type, 'file_name': file_name}
             headers = {'Authorization': f'Bearer {access_token}'}
-            
+
             try:
                 with open(local_path, "rb") as file:
                     upload_response = requests.post(
-                        upload_url, 
-                        files={"file": file}, 
-                        data=data, 
+                        upload_url,
+                        files={"file": file},
+                        data=data,
                         headers=headers,
                         timeout=(5, 30)  # 5s connect, 30s read timeout
                     )
-                    logger.info(f"[FeiShu] upload file response, status={upload_response.status_code}, res={upload_response.content}")
-                    
+                    logger.info(
+                        f"[FeiShu] upload file response, status={upload_response.status_code}, res={upload_response.content}")
+
                     response_data = upload_response.json()
                     if response_data.get("code") == 0:
                         return response_data.get("data").get("file_key")
@@ -564,22 +680,22 @@ class FeiShuChanel(ChatChannel):
             except Exception as e:
                 logger.error(f"[FeiShu] upload file exception: {e}")
                 return None
-        
+
         # For HTTP URLs, download first then upload
         try:
             response = requests.get(file_url, timeout=(5, 30))
             if response.status_code != 200:
                 logger.error(f"[FeiShu] download file failed, status={response.status_code}")
                 return None
-            
+
             # Save to temp file
             import uuid
             file_name = os.path.basename(file_url)
             temp_name = str(uuid.uuid4()) + "_" + file_name
-            
+
             with open(temp_name, "wb") as file:
                 file.write(response.content)
-            
+
             # Upload
             file_ext = os.path.splitext(file_name)[1].lower()
             file_type_map = {
@@ -589,18 +705,18 @@ class FeiShuChanel(ChatChannel):
                 '.ppt': 'ppt', '.pptx': 'ppt',
             }
             file_type = file_type_map.get(file_ext, 'stream')
-            
+
             upload_url = "https://open.feishu.cn/open-apis/im/v1/files"
             data = {'file_type': file_type, 'file_name': file_name}
             headers = {'Authorization': f'Bearer {access_token}'}
-            
+
             with open(temp_name, "rb") as file:
                 upload_response = requests.post(upload_url, files={"file": file}, data=data, headers=headers)
                 logger.info(f"[FeiShu] upload file, res={upload_response.content}")
-                
+
                 response_data = upload_response.json()
                 os.remove(temp_name)  # Clean up temp file
-                
+
                 if response_data.get("code") == 0:
                     return response_data.get("data").get("file_key")
                 else:
@@ -613,11 +729,13 @@ class FeiShuChanel(ChatChannel):
     def _compose_context(self, ctype: ContextType, content, **kwargs):
         context = Context(ctype, content)
         context.kwargs = kwargs
+        if "channel_type" not in context:
+            context["channel_type"] = self.channel_type
         if "origin_ctype" not in context:
             context["origin_ctype"] = ctype
 
         cmsg = context["msg"]
-        
+
         # Set session_id based on chat type
         if cmsg.is_group:
             # Group chat: check if group_shared_session is enabled
@@ -633,7 +751,7 @@ class FeiShuChanel(ChatChannel):
         else:
             # Private chat: use user_id only
             context["session_id"] = cmsg.from_user_id
-        
+
         context["receiver"] = cmsg.other_user_id
 
         if ctype == ContextType.TEXT:

channel/feishu/feishu_message.py

@@ -6,6 +6,7 @@ import requests
 from common.log import logger
 from common.tmp_dir import TmpDir
 from common import utils
+from common.utils import expand_path
 from config import conf
 
 
@@ -31,7 +32,7 @@ class FeishuMessage(ChatMessage):
             image_key = content.get("image_key")
             
             # 下载图片到工作空间临时目录
-            workspace_root = os.path.expanduser(conf().get("agent_workspace", "~/cow"))
+            workspace_root = expand_path(conf().get("agent_workspace", "~/cow"))
             tmp_dir = os.path.join(workspace_root, "tmp")
             os.makedirs(tmp_dir, exist_ok=True)
             image_path = os.path.join(tmp_dir, f"{image_key}.png")
@@ -97,7 +98,7 @@ class FeishuMessage(ChatMessage):
             
             if image_keys:
                 # 如果包含图片，下载并在文本中引用本地路径
-                workspace_root = os.path.expanduser(conf().get("agent_workspace", "~/cow"))
+                workspace_root = expand_path(conf().get("agent_workspace", "~/cow"))
                 tmp_dir = os.path.join(workspace_root, "tmp")
                 os.makedirs(tmp_dir, exist_ok=True)
                 

channel/web/static/css/console.css

@@ -0,0 +1,354 @@
+/* =====================================================================
+   CowAgent Console Styles
+   ===================================================================== */
+
+/* Animations */
+@keyframes pulseDot {
+    0%, 80%, 100% { transform: scale(0.6); opacity: 0.4; }
+    40% { transform: scale(1); opacity: 1; }
+}
+
+/* Scrollbar */
+* { scrollbar-width: thin; scrollbar-color: #94a3b8 transparent; }
+::-webkit-scrollbar { width: 6px; height: 6px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: #94a3b8; border-radius: 3px; }
+::-webkit-scrollbar-thumb:hover { background: #64748b; }
+.dark ::-webkit-scrollbar-thumb { background: #475569; }
+.dark ::-webkit-scrollbar-thumb:hover { background: #64748b; }
+
+/* Sidebar */
+.sidebar-item.active {
+    background: rgba(255, 255, 255, 0.08);
+    color: #FFFFFF;
+}
+.sidebar-item.active .item-icon { color: #4ABE6E; }
+
+/* Menu Groups */
+.menu-group-items { max-height: 0; overflow: hidden; transition: max-height 0.25s ease-out; }
+.menu-group.open .menu-group-items { max-height: 500px; transition: max-height 0.35s ease-in; }
+.menu-group .chevron { transition: transform 0.25s ease; }
+.menu-group.open .chevron { transform: rotate(90deg); }
+
+/* View Switching */
+.view { display: none; height: 100%; }
+.view.active { display: flex; flex-direction: column; }
+
+/* Markdown Content */
+.msg-content p { margin: 0.5em 0; line-height: 1.7; }
+.msg-content p:first-child { margin-top: 0; }
+.msg-content p:last-child { margin-bottom: 0; }
+.msg-content h1, .msg-content h2, .msg-content h3,
+.msg-content h4, .msg-content h5, .msg-content h6 {
+    margin-top: 1.2em; margin-bottom: 0.6em; font-weight: 600; line-height: 1.3;
+}
+.msg-content h1 { font-size: 1.4em; }
+.msg-content h2 { font-size: 1.25em; }
+.msg-content h3 { font-size: 1.1em; }
+.msg-content ul, .msg-content ol { margin: 0.5em 0; padding-left: 1.8em; }
+.msg-content li { margin: 0.25em 0; }
+.msg-content pre {
+    border-radius: 8px; overflow-x: auto; margin: 0.8em 0;
+    background: #f1f5f9; padding: 1em;
+}
+.dark .msg-content pre { background: #111111; }
+.msg-content code {
+    font-family: 'JetBrains Mono', 'Fira Code', Consolas, monospace;
+    font-size: 0.875em;
+}
+.msg-content :not(pre) > code {
+    background: rgba(74, 190, 110, 0.1); color: #1C6B3B;
+    padding: 2px 6px; border-radius: 4px;
+}
+.dark .msg-content :not(pre) > code {
+    background: rgba(74, 190, 110, 0.15); color: #74E9A4;
+}
+.msg-content pre code { background: transparent; padding: 0; color: inherit; }
+.msg-content blockquote {
+    border-left: 3px solid #4ABE6E; padding: 0.5em 1em;
+    margin: 0.8em 0; background: rgba(74, 190, 110, 0.05); border-radius: 0 6px 6px 0;
+}
+.dark .msg-content blockquote { background: rgba(74, 190, 110, 0.08); }
+.msg-content table { border-collapse: collapse; width: 100%; margin: 0.8em 0; }
+.msg-content th, .msg-content td {
+    border: 1px solid #e2e8f0; padding: 8px 12px; text-align: left;
+}
+.dark .msg-content th, .dark .msg-content td { border-color: rgba(255,255,255,0.1); }
+.msg-content th { background: #f1f5f9; font-weight: 600; }
+.dark .msg-content th { background: #111111; }
+.msg-content img { max-width: 100%; height: auto; border-radius: 8px; margin: 0.5em 0; }
+.msg-content a { color: #35A85B; text-decoration: underline; }
+.msg-content a:hover { color: #228547; }
+.msg-content hr { border: none; height: 1px; background: #e2e8f0; margin: 1.2em 0; }
+.dark .msg-content hr { background: rgba(255,255,255,0.1); }
+
+/* SSE Streaming cursor */
+@keyframes blink { 0%, 100% { opacity: 1; } 50% { opacity: 0; } }
+.sse-streaming::after {
+    content: '▋';
+    display: inline-block;
+    margin-left: 2px;
+    color: #4ABE6E;
+    animation: blink 0.9s step-end infinite;
+    font-size: 0.85em;
+    vertical-align: middle;
+}
+
+/* Agent steps (thinking summaries + tool indicators) */
+.agent-steps:empty { display: none; }
+.agent-steps:not(:empty) {
+    margin-bottom: 0.625rem;
+    padding-bottom: 0.5rem;
+    border-bottom: 1px dashed rgba(0, 0, 0, 0.08);
+}
+.dark .agent-steps:not(:empty) { border-bottom-color: rgba(255, 255, 255, 0.08); }
+
+.agent-step {
+    font-size: 0.75rem;
+    line-height: 1.4;
+    color: #94a3b8;
+    margin-bottom: 0.25rem;
+}
+.agent-step:last-child { margin-bottom: 0; }
+
+/* Thinking step - collapsible */
+.agent-thinking-step .thinking-header {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    cursor: pointer;
+    user-select: none;
+}
+.agent-thinking-step .thinking-header.no-toggle { cursor: default; }
+.agent-thinking-step .thinking-header:not(.no-toggle):hover { color: #64748b; }
+.dark .agent-thinking-step .thinking-header:not(.no-toggle):hover { color: #cbd5e1; }
+.agent-thinking-step .thinking-header i:first-child { font-size: 0.625rem; margin-top: 1px; }
+.agent-thinking-step .thinking-chevron {
+    font-size: 0.5rem;
+    margin-left: auto;
+    transition: transform 0.2s ease;
+    opacity: 0.5;
+}
+.agent-thinking-step.expanded .thinking-chevron { transform: rotate(90deg); }
+.agent-thinking-step .thinking-full {
+    display: none;
+    margin-top: 0.375rem;
+    margin-left: 1rem;
+    padding: 0.5rem;
+    background: rgba(0, 0, 0, 0.02);
+    border-radius: 6px;
+    border: 1px solid rgba(0, 0, 0, 0.04);
+    font-size: 0.75rem;
+    line-height: 1.5;
+    color: #94a3b8;
+    max-height: 200px;
+    overflow-y: auto;
+}
+.dark .agent-thinking-step .thinking-full {
+    background: rgba(255, 255, 255, 0.02);
+    border-color: rgba(255, 255, 255, 0.04);
+}
+.agent-thinking-step.expanded .thinking-full { display: block; }
+.agent-thinking-step .thinking-full p { margin: 0.25em 0; }
+.agent-thinking-step .thinking-full p:first-child { margin-top: 0; }
+.agent-thinking-step .thinking-full p:last-child { margin-bottom: 0; }
+
+/* Tool step - collapsible */
+.agent-tool-step .tool-header {
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    cursor: pointer;
+    user-select: none;
+    padding: 1px 0;
+    border-radius: 4px;
+}
+.agent-tool-step .tool-header:hover { color: #64748b; }
+.dark .agent-tool-step .tool-header:hover { color: #cbd5e1; }
+.agent-tool-step .tool-icon { font-size: 0.625rem; }
+.agent-tool-step .tool-chevron {
+    font-size: 0.5rem;
+    margin-left: auto;
+    transition: transform 0.2s ease;
+    opacity: 0.5;
+}
+.agent-tool-step.expanded .tool-chevron { transform: rotate(90deg); }
+.agent-tool-step .tool-time {
+    font-size: 0.65rem;
+    opacity: 0.6;
+    margin-left: 0.25rem;
+}
+
+/* Tool detail panel */
+.agent-tool-step .tool-detail {
+    display: none;
+    margin-top: 0.375rem;
+    margin-left: 1rem;
+    padding: 0.5rem;
+    background: rgba(0, 0, 0, 0.02);
+    border-radius: 6px;
+    border: 1px solid rgba(0, 0, 0, 0.04);
+}
+.dark .agent-tool-step .tool-detail {
+    background: rgba(255, 255, 255, 0.02);
+    border-color: rgba(255, 255, 255, 0.04);
+}
+.agent-tool-step.expanded .tool-detail { display: block; }
+.tool-detail-section { margin-bottom: 0.375rem; }
+.tool-detail-section:last-child { margin-bottom: 0; }
+.tool-detail-label {
+    font-size: 0.625rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    opacity: 0.6;
+    margin-bottom: 0.125rem;
+}
+.tool-detail-content {
+    font-family: 'JetBrains Mono', 'Fira Code', Consolas, monospace;
+    font-size: 0.7rem;
+    line-height: 1.5;
+    white-space: pre-wrap;
+    word-break: break-all;
+    max-height: 200px;
+    overflow-y: auto;
+    margin: 0;
+    padding: 0.25rem 0;
+    background: transparent;
+    color: inherit;
+}
+.tool-error-text { color: #f87171; }
+
+/* Tool failed state */
+.agent-tool-step.tool-failed .tool-name { color: #f87171; }
+
+/* Config form controls */
+#view-config input[type="text"],
+#view-config input[type="number"],
+#view-config input[type="password"] {
+    height: 40px;
+    transition: border-color 0.2s ease, box-shadow 0.2s ease;
+}
+#view-config input:focus {
+    border-color: #4ABE6E;
+    box-shadow: 0 0 0 3px rgba(74, 190, 110, 0.12);
+}
+#view-config input[type="text"]:hover,
+#view-config input[type="number"]:hover,
+#view-config input[type="password"]:hover {
+    border-color: #94a3b8;
+}
+.dark #view-config input[type="text"]:hover,
+.dark #view-config input[type="number"]:hover,
+.dark #view-config input[type="password"]:hover {
+    border-color: #64748b;
+}
+
+/* Custom dropdown */
+.cfg-dropdown {
+    position: relative;
+    outline: none;
+}
+.cfg-dropdown-selected {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    height: 40px;
+    padding: 0 0.75rem;
+    border-radius: 0.5rem;
+    border: 1px solid #e2e8f0;
+    background: #f8fafc;
+    font-size: 0.875rem;
+    color: #1e293b;
+    cursor: pointer;
+    transition: border-color 0.2s ease, box-shadow 0.2s ease;
+    user-select: none;
+}
+.dark .cfg-dropdown-selected {
+    border-color: #475569;
+    background: rgba(255, 255, 255, 0.05);
+    color: #f1f5f9;
+}
+.cfg-dropdown-selected:hover { border-color: #94a3b8; }
+.dark .cfg-dropdown-selected:hover { border-color: #64748b; }
+.cfg-dropdown.open .cfg-dropdown-selected,
+.cfg-dropdown:focus .cfg-dropdown-selected {
+    border-color: #4ABE6E;
+    box-shadow: 0 0 0 3px rgba(74, 190, 110, 0.12);
+}
+.cfg-dropdown-arrow {
+    font-size: 0.625rem;
+    color: #94a3b8;
+    transition: transform 0.2s ease;
+    flex-shrink: 0;
+    margin-left: 0.5rem;
+}
+.cfg-dropdown.open .cfg-dropdown-arrow { transform: rotate(180deg); }
+.cfg-dropdown-menu {
+    display: none;
+    position: absolute;
+    top: calc(100% + 4px);
+    left: 0;
+    right: 0;
+    z-index: 50;
+    max-height: 240px;
+    overflow-y: auto;
+    border-radius: 0.5rem;
+    border: 1px solid #e2e8f0;
+    background: #ffffff;
+    box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.1), 0 4px 10px -5px rgba(0, 0, 0, 0.04);
+    padding: 4px;
+}
+.dark .cfg-dropdown-menu {
+    border-color: #334155;
+    background: #1e1e1e;
+    box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.4);
+}
+.cfg-dropdown.open .cfg-dropdown-menu { display: block; }
+.cfg-dropdown-item {
+    display: flex;
+    align-items: center;
+    padding: 8px 10px;
+    border-radius: 6px;
+    font-size: 0.875rem;
+    color: #334155;
+    cursor: pointer;
+    transition: background 0.15s ease;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+}
+.dark .cfg-dropdown-item { color: #cbd5e1; }
+.cfg-dropdown-item:hover { background: #f1f5f9; }
+.dark .cfg-dropdown-item:hover { background: rgba(255, 255, 255, 0.08); }
+.cfg-dropdown-item.active {
+    background: rgba(74, 190, 110, 0.1);
+    color: #228547;
+    font-weight: 500;
+}
+.dark .cfg-dropdown-item.active {
+    background: rgba(74, 190, 110, 0.15);
+    color: #74E9A4;
+}
+
+/* API Key masking via CSS (avoids browser password prompts) */
+.cfg-key-masked {
+    -webkit-text-security: disc;
+    text-security: disc;
+}
+
+/* Chat Input */
+#chat-input {
+    resize: none; height: 42px; max-height: 180px;
+    overflow-y: hidden;
+    transition: border-color 0.2s ease;
+}
+
+/* Placeholder Cards */
+.placeholder-card {
+    transition: transform 0.2s ease, box-shadow 0.2s ease;
+}
+.placeholder-card:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 8px 25px -5px rgba(0, 0, 0, 0.1);
+}

channel/wechat/wechat_channel.py

@@ -151,7 +151,7 @@ class WechatChannel(ChatChannel):
 
     def exitCallback(self):
         try:
-            from common.linkai_client import chat_client
+            from common.cloud_client import chat_client
             if chat_client.client_id and conf().get("use_linkai"):
                 _send_logout()
                 time.sleep(2)
@@ -283,7 +283,7 @@ class WechatChannel(ChatChannel):
 
 def _send_login_success():
     try:
-        from common.linkai_client import chat_client
+        from common.cloud_client import chat_client
         if chat_client.client_id:
             chat_client.send_login_success()
     except Exception as e:
@@ -292,7 +292,7 @@ def _send_login_success():
 
 def _send_logout():
     try:
-        from common.linkai_client import chat_client
+        from common.cloud_client import chat_client
         if chat_client.client_id:
             chat_client.send_logout()
     except Exception as e:
@@ -301,7 +301,7 @@ def _send_logout():
 
 def _send_qr_code(qrcode_list: list):
     try:
-        from common.linkai_client import chat_client
+        from common.cloud_client import chat_client
         if chat_client.client_id:
             chat_client.send_qrcode(qrcode_list)
     except Exception as e:

channel/wechatcom/wechatcomapp_channel.py

@@ -1,6 +1,7 @@
 # -*- coding=utf-8 -*-
 import io
 import os
+import sys
 import time
 
 import requests
@@ -35,9 +36,9 @@ class WechatComAppChannel(ChatChannel):
         self.agent_id = conf().get("wechatcomapp_agent_id")
         self.token = conf().get("wechatcomapp_token")
         self.aes_key = conf().get("wechatcomapp_aes_key")
-        print(self.corp_id, self.secret, self.agent_id, self.token, self.aes_key)
+        self._http_server = None
         logger.info(
-            "[wechatcom] init: corp_id: {}, secret: {}, agent_id: {}, token: {}, aes_key: {}".format(self.corp_id, self.secret, self.agent_id, self.token, self.aes_key)
+            "[wechatcom] Initializing WeCom app channel, corp_id: {}, agent_id: {}".format(self.corp_id, self.agent_id)
         )
         self.crypto = WeChatCrypto(self.token, self.aes_key, self.corp_id)
         self.client = WechatComAppClient(self.corp_id, self.secret)
@@ -47,7 +48,28 @@ class WechatComAppChannel(ChatChannel):
         urls = ("/wxcomapp/?", "channel.wechatcom.wechatcomapp_channel.Query")
         app = web.application(urls, globals(), autoreload=False)
         port = conf().get("wechatcomapp_port", 9898)
-        web.httpserver.runsimple(app.wsgifunc(), ("0.0.0.0", port))
+        logger.info("[wechatcom] ✅ WeCom app channel started successfully")
+        logger.info("[wechatcom] 📡 Listening on http://0.0.0.0:{}/wxcomapp/".format(port))
+        logger.info("[wechatcom] 🤖 Ready to receive messages")
+        
+        # Build WSGI app with middleware (same as runsimple but without print)
+        func = web.httpserver.StaticMiddleware(app.wsgifunc())
+        func = web.httpserver.LogMiddleware(func)
+        server = web.httpserver.WSGIServer(("0.0.0.0", port), func)
+        self._http_server = server
+        try:
+            server.start()
+        except (KeyboardInterrupt, SystemExit):
+            server.stop()
+
+    def stop(self):
+        if self._http_server:
+            try:
+                self._http_server.stop()
+                logger.info("[wechatcom] HTTP server stopped")
+            except Exception as e:
+                logger.warning(f"[wechatcom] Error stopping HTTP server: {e}")
+            self._http_server = None
 
     def send(self, reply: Reply, context: Context):
         receiver = context["receiver"]
@@ -74,6 +96,10 @@ class WechatComAppChannel(ChatChannel):
                     response = self.client.media.upload("voice", open(path, "rb"))
                     logger.debug("[wechatcom] upload voice response: {}".format(response))
                     media_ids.append(response["media_id"])
+            except ImportError as e:
+                logger.error("[wechatcom] voice conversion failed: {}".format(e))
+                logger.error("[wechatcom] please install pydub: pip install pydub")
+                return
             except WeChatClientException as e:
                 logger.error("[wechatcom] upload voice failed: {}".format(e))
                 return

channel/wechatmp/wechatmp_channel.py

@@ -21,7 +21,11 @@ from common.log import logger
 from common.singleton import singleton
 from common.utils import split_string_by_utf8_length, remove_markdown_symbol
 from config import conf
-from voice.audio_convert import any_to_mp3, split_audio
+
+try:
+    from voice.audio_convert import any_to_mp3, split_audio
+except ImportError as e:
+    logger.debug("import voice.audio_convert failed, voice features will not be supported: {}".format(e))
 
 # If using SSL, uncomment the following lines, and modify the certificate path.
 # from cheroot.server import HTTPServer
@@ -37,6 +41,7 @@ class WechatMPChannel(ChatChannel):
         super().__init__()
         self.passive_reply = passive_reply
         self.NOT_SUPPORT_REPLYTYPE = []
+        self._http_server = None
         appid = conf().get("wechatmp_app_id")
         secret = conf().get("wechatmp_app_secret")
         token = conf().get("wechatmp_token")
@@ -65,7 +70,23 @@ class WechatMPChannel(ChatChannel):
             urls = ("/wx", "channel.wechatmp.active_reply.Query")
         app = web.application(urls, globals(), autoreload=False)
         port = conf().get("wechatmp_port", 8080)
-        web.httpserver.runsimple(app.wsgifunc(), ("0.0.0.0", port))
+        func = web.httpserver.StaticMiddleware(app.wsgifunc())
+        func = web.httpserver.LogMiddleware(func)
+        server = web.httpserver.WSGIServer(("0.0.0.0", port), func)
+        self._http_server = server
+        try:
+            server.start()
+        except (KeyboardInterrupt, SystemExit):
+            server.stop()
+
+    def stop(self):
+        if self._http_server:
+            try:
+                self._http_server.stop()
+                logger.info("[wechatmp] HTTP server stopped")
+            except Exception as e:
+                logger.warning(f"[wechatmp] Error stopping HTTP server: {e}")
+            self._http_server = None
 
     def start_loop(self, loop):
         asyncio.set_event_loop(loop)
@@ -85,26 +106,31 @@ class WechatMPChannel(ChatChannel):
                 logger.info("[wechatmp] text cached, receiver {}\n{}".format(receiver, reply_text))
                 self.cache_dict[receiver].append(("text", reply_text))
             elif reply.type == ReplyType.VOICE:
-                voice_file_path = reply.content
-                duration, files = split_audio(voice_file_path, 60 * 1000)
-                if len(files) > 1:
-                    logger.info("[wechatmp] voice too long {}s > 60s , split into {} parts".format(duration / 1000.0, len(files)))
+                try:
+                    voice_file_path = reply.content
+                    duration, files = split_audio(voice_file_path, 60 * 1000)
+                    if len(files) > 1:
+                        logger.info("[wechatmp] voice too long {}s > 60s , split into {} parts".format(duration / 1000.0, len(files)))
 
-                for path in files:
-                    # support: <2M, <60s, mp3/wma/wav/amr
-                    try:
-                        with open(path, "rb") as f:
-                            response = self.client.material.add("voice", f)
-                            logger.debug("[wechatmp] upload voice response: {}".format(response))
-                            f_size = os.fstat(f.fileno()).st_size
-                            time.sleep(1.0 + 2 * f_size / 1024 / 1024)
-                            # todo check media_id
-                    except WeChatClientException as e:
-                        logger.error("[wechatmp] upload voice failed: {}".format(e))
-                        return
-                    media_id = response["media_id"]
-                    logger.info("[wechatmp] voice uploaded, receiver {}, media_id {}".format(receiver, media_id))
-                    self.cache_dict[receiver].append(("voice", media_id))
+                    for path in files:
+                        # support: <2M, <60s, mp3/wma/wav/amr
+                        try:
+                            with open(path, "rb") as f:
+                                response = self.client.material.add("voice", f)
+                                logger.debug("[wechatmp] upload voice response: {}".format(response))
+                                f_size = os.fstat(f.fileno()).st_size
+                                time.sleep(1.0 + 2 * f_size / 1024 / 1024)
+                                # todo check media_id
+                        except WeChatClientException as e:
+                            logger.error("[wechatmp] upload voice failed: {}".format(e))
+                            return
+                        media_id = response["media_id"]
+                        logger.info("[wechatmp] voice uploaded, receiver {}, media_id {}".format(receiver, media_id))
+                        self.cache_dict[receiver].append(("voice", media_id))
+                except ImportError as e:
+                    logger.error("[wechatmp] voice conversion failed: {}".format(e))
+                    logger.error("[wechatmp] please install pydub: pip install pydub")
+                    return
 
             elif reply.type == ReplyType.IMAGE_URL:  # 从网络下载图片
                 img_url = reply.content
@@ -213,6 +239,10 @@ class WechatMPChannel(ChatChannel):
                         logger.debug("[wechatcom] upload voice response: {}".format(response))
                         media_ids.append(response["media_id"])
                         os.remove(path)
+                except ImportError as e:
+                    logger.error("[wechatmp] voice conversion failed: {}".format(e))
+                    logger.error("[wechatmp] please install pydub: pip install pydub")
+                    return
                 except WeChatClientException as e:
                     logger.error("[wechatmp] upload voice failed: {}".format(e))
                     return

channel/wework/wework_channel.py

@@ -20,7 +20,6 @@ from common.utils import compress_imgfile, fsize
 from config import conf
 from channel.wework.run import wework
 from channel.wework import run
-from PIL import Image
 
 
 def get_wxid_by_name(room_members, group_wxid, name):
@@ -55,6 +54,7 @@ def download_and_compress_image(url, filename, quality=30):
     image_storage.seek(0)
 
     # 读取并保存图片
+    from PIL import Image
     image = Image.open(image_storage)
     image_path = os.path.join(directory, f"{filename}.png")
     image.save(image_path, "png")

common/cloud_client.py

@@ -0,0 +1,375 @@
+"""
+Cloud management client for connecting to the LinkAI control console.
+
+Handles remote configuration sync, message push, and skill management
+via the LinkAI socket protocol.
+"""
+
+from bridge.context import Context, ContextType
+from bridge.reply import Reply, ReplyType
+from common.log import logger
+from linkai import LinkAIClient, PushMsg
+from config import conf, pconf, plugin_config, available_setting, write_plugin_config, get_root
+from plugins import PluginManager
+import threading
+import time
+import json
+import os
+
+
+chat_client: LinkAIClient
+
+
+class CloudClient(LinkAIClient):
+    def __init__(self, api_key: str, channel, host: str = ""):
+        super().__init__(api_key, host)
+        self.channel = channel
+        self.client_type = channel.channel_type
+        self.channel_mgr = None
+        self._skill_service = None
+        self._memory_service = None
+        self._chat_service = None
+
+    @property
+    def skill_service(self):
+        """Lazy-init SkillService so it is available once SkillManager exists."""
+        if self._skill_service is None:
+            try:
+                from agent.skills.manager import SkillManager
+                from agent.skills.service import SkillService
+                from config import conf
+                from common.utils import expand_path
+                workspace_root = expand_path(conf().get("agent_workspace", "~/cow"))
+                manager = SkillManager(custom_dir=os.path.join(workspace_root, "skills"))
+                self._skill_service = SkillService(manager)
+                logger.debug("[CloudClient] SkillService initialised")
+            except Exception as e:
+                logger.error(f"[CloudClient] Failed to init SkillService: {e}")
+        return self._skill_service
+
+    @property
+    def memory_service(self):
+        """Lazy-init MemoryService."""
+        if self._memory_service is None:
+            try:
+                from agent.memory.service import MemoryService
+                from config import conf
+                from common.utils import expand_path
+                workspace_root = expand_path(conf().get("agent_workspace", "~/cow"))
+                self._memory_service = MemoryService(workspace_root)
+                logger.debug("[CloudClient] MemoryService initialised")
+            except Exception as e:
+                logger.error(f"[CloudClient] Failed to init MemoryService: {e}")
+        return self._memory_service
+
+    @property
+    def chat_service(self):
+        """Lazy-init ChatService (requires AgentBridge via Bridge singleton)."""
+        if self._chat_service is None:
+            try:
+                from agent.chat.service import ChatService
+                from bridge.bridge import Bridge
+                agent_bridge = Bridge().get_agent_bridge()
+                self._chat_service = ChatService(agent_bridge)
+                logger.debug("[CloudClient] ChatService initialised")
+            except Exception as e:
+                logger.error(f"[CloudClient] Failed to init ChatService: {e}")
+        return self._chat_service
+
+    # ------------------------------------------------------------------
+    # message push callback
+    # ------------------------------------------------------------------
+    def on_message(self, push_msg: PushMsg):
+        session_id = push_msg.session_id
+        msg_content = push_msg.msg_content
+        logger.info(f"receive msg push, session_id={session_id}, msg_content={msg_content}")
+        context = Context()
+        context.type = ContextType.TEXT
+        context["receiver"] = session_id
+        context["isgroup"] = push_msg.is_group
+        self.channel.send(Reply(ReplyType.TEXT, content=msg_content), context)
+
+    # ------------------------------------------------------------------
+    # config callback
+    # ------------------------------------------------------------------
+    def on_config(self, config: dict):
+        if not self.client_id:
+            return
+        logger.info(f"[CloudClient] Loading remote config: {config}")
+        if config.get("enabled") != "Y":
+            return
+
+        local_config = conf()
+        need_restart_channel = False
+
+        for key in config.keys():
+            if key in available_setting and config.get(key) is not None:
+                local_config[key] = config.get(key)
+
+        # Voice settings
+        reply_voice_mode = config.get("reply_voice_mode")
+        if reply_voice_mode:
+            if reply_voice_mode == "voice_reply_voice":
+                local_config["voice_reply_voice"] = True
+                local_config["always_reply_voice"] = False
+            elif reply_voice_mode == "always_reply_voice":
+                local_config["always_reply_voice"] = True
+                local_config["voice_reply_voice"] = True
+            elif reply_voice_mode == "no_reply_voice":
+                local_config["always_reply_voice"] = False
+                local_config["voice_reply_voice"] = False
+
+        # Model configuration
+        if config.get("model"):
+            local_config["model"] = config.get("model")
+
+        # Channel configuration
+        if config.get("channelType"):
+            if local_config.get("channel_type") != config.get("channelType"):
+                local_config["channel_type"] = config.get("channelType")
+                need_restart_channel = True
+
+        # Channel-specific app credentials
+        current_channel_type = local_config.get("channel_type", "")
+
+        if config.get("app_id") is not None:
+            if current_channel_type == "feishu":
+                if local_config.get("feishu_app_id") != config.get("app_id"):
+                    local_config["feishu_app_id"] = config.get("app_id")
+                    need_restart_channel = True
+            elif current_channel_type == "dingtalk":
+                if local_config.get("dingtalk_client_id") != config.get("app_id"):
+                    local_config["dingtalk_client_id"] = config.get("app_id")
+                    need_restart_channel = True
+            elif current_channel_type in ("wechatmp", "wechatmp_service"):
+                if local_config.get("wechatmp_app_id") != config.get("app_id"):
+                    local_config["wechatmp_app_id"] = config.get("app_id")
+                    need_restart_channel = True
+            elif current_channel_type == "wechatcom_app":
+                if local_config.get("wechatcomapp_agent_id") != config.get("app_id"):
+                    local_config["wechatcomapp_agent_id"] = config.get("app_id")
+                    need_restart_channel = True
+
+        if config.get("app_secret"):
+            if current_channel_type == "feishu":
+                if local_config.get("feishu_app_secret") != config.get("app_secret"):
+                    local_config["feishu_app_secret"] = config.get("app_secret")
+                    need_restart_channel = True
+            elif current_channel_type == "dingtalk":
+                if local_config.get("dingtalk_client_secret") != config.get("app_secret"):
+                    local_config["dingtalk_client_secret"] = config.get("app_secret")
+                    need_restart_channel = True
+            elif current_channel_type in ("wechatmp", "wechatmp_service"):
+                if local_config.get("wechatmp_app_secret") != config.get("app_secret"):
+                    local_config["wechatmp_app_secret"] = config.get("app_secret")
+                    need_restart_channel = True
+            elif current_channel_type == "wechatcom_app":
+                if local_config.get("wechatcomapp_secret") != config.get("app_secret"):
+                    local_config["wechatcomapp_secret"] = config.get("app_secret")
+                    need_restart_channel = True
+
+        if config.get("admin_password"):
+            if not pconf("Godcmd"):
+                write_plugin_config({"Godcmd": {"password": config.get("admin_password"), "admin_users": []}})
+            else:
+                pconf("Godcmd")["password"] = config.get("admin_password")
+            PluginManager().instances["GODCMD"].reload()
+
+        if config.get("group_app_map") and pconf("linkai"):
+            local_group_map = {}
+            for mapping in config.get("group_app_map"):
+                local_group_map[mapping.get("group_name")] = mapping.get("app_code")
+            pconf("linkai")["group_app_map"] = local_group_map
+            PluginManager().instances["LINKAI"].reload()
+
+        if config.get("text_to_image") and config.get("text_to_image") == "midjourney" and pconf("linkai"):
+            if pconf("linkai")["midjourney"]:
+                pconf("linkai")["midjourney"]["enabled"] = True
+                pconf("linkai")["midjourney"]["use_image_create_prefix"] = True
+        elif config.get("text_to_image") and config.get("text_to_image") in ["dall-e-2", "dall-e-3"]:
+            if pconf("linkai")["midjourney"]:
+                pconf("linkai")["midjourney"]["use_image_create_prefix"] = False
+
+        # Save configuration to config.json file
+        self._save_config_to_file(local_config)
+
+        if need_restart_channel:
+            self._restart_channel(local_config.get("channel_type", ""))
+
+    # ------------------------------------------------------------------
+    # skill callback
+    # ------------------------------------------------------------------
+    def on_skill(self, data: dict) -> dict:
+        """
+        Handle SKILL messages from the cloud console.
+        Delegates to SkillService.dispatch for the actual operations.
+
+        :param data: message data with 'action', 'clientId', 'payload'
+        :return: response dict
+        """
+        action = data.get("action", "")
+        payload = data.get("payload")
+        logger.info(f"[CloudClient] on_skill: action={action}")
+
+        svc = self.skill_service
+        if svc is None:
+            return {"action": action, "code": 500, "message": "SkillService not available", "payload": None}
+
+        return svc.dispatch(action, payload)
+
+    # ------------------------------------------------------------------
+    # memory callback
+    # ------------------------------------------------------------------
+    def on_memory(self, data: dict) -> dict:
+        """
+        Handle MEMORY messages from the cloud console.
+        Delegates to MemoryService.dispatch for the actual operations.
+
+        :param data: message data with 'action', 'clientId', 'payload'
+        :return: response dict
+        """
+        action = data.get("action", "")
+        payload = data.get("payload")
+        logger.info(f"[CloudClient] on_memory: action={action}")
+
+        svc = self.memory_service
+        if svc is None:
+            return {"action": action, "code": 500, "message": "MemoryService not available", "payload": None}
+
+        return svc.dispatch(action, payload)
+
+    # ------------------------------------------------------------------
+    # chat callback
+    # ------------------------------------------------------------------
+    def on_chat(self, data: dict, send_chunk_fn):
+        """
+        Handle CHAT messages from the cloud console.
+        Runs the agent in streaming mode and sends chunks back via send_chunk_fn.
+
+        :param data: message data with 'action' and 'payload' (query, session_id)
+        :param send_chunk_fn: callable(chunk_data: dict) to send one streaming chunk
+        """
+        payload = data.get("payload", {})
+        query = payload.get("query", "")
+        session_id = payload.get("session_id", "cloud_console")
+        logger.info(f"[CloudClient] on_chat: session={session_id}, query={query[:80]}")
+
+        svc = self.chat_service
+        if svc is None:
+            raise RuntimeError("ChatService not available")
+
+        svc.run(query=query, session_id=session_id, send_chunk_fn=send_chunk_fn)
+
+    # ------------------------------------------------------------------
+    # channel restart helpers
+    # ------------------------------------------------------------------
+    def _restart_channel(self, new_channel_type: str):
+        """
+        Restart the channel via ChannelManager when channel type changes.
+        """
+        if self.channel_mgr:
+            logger.info(f"[CloudClient] Restarting channel to '{new_channel_type}'...")
+            threading.Thread(target=self._do_restart_channel, args=(self.channel_mgr, new_channel_type), daemon=True).start()
+        else:
+            logger.warning("[CloudClient] ChannelManager not available, please restart the application manually")
+
+    def _do_restart_channel(self, mgr, new_channel_type: str):
+        """
+        Perform the channel restart in a separate thread to avoid blocking the config callback.
+        """
+        try:
+            mgr.restart(new_channel_type)
+            # Update the client's channel reference
+            if mgr.channel:
+                self.channel = mgr.channel
+                self.client_type = mgr.channel.channel_type
+                logger.info(f"[CloudClient] Channel reference updated to '{new_channel_type}'")
+        except Exception as e:
+            logger.error(f"[CloudClient] Channel restart failed: {e}")
+
+    # ------------------------------------------------------------------
+    # config persistence
+    # ------------------------------------------------------------------
+    def _save_config_to_file(self, local_config: dict):
+        """
+        Save configuration to config.json file.
+        """
+        try:
+            config_path = os.path.join(get_root(), "config.json")
+            if not os.path.exists(config_path):
+                logger.warning(f"[CloudClient] config.json not found at {config_path}, skip saving")
+                return
+
+            with open(config_path, "r", encoding="utf-8") as f:
+                file_config = json.load(f)
+
+            file_config.update(dict(local_config))
+
+            with open(config_path, "w", encoding="utf-8") as f:
+                json.dump(file_config, f, indent=4, ensure_ascii=False)
+
+            logger.info("[CloudClient] Configuration saved to config.json successfully")
+        except Exception as e:
+            logger.error(f"[CloudClient] Failed to save configuration to config.json: {e}")
+
+
+def start(channel, channel_mgr=None):
+    global chat_client
+    chat_client = CloudClient(api_key=conf().get("linkai_api_key"), host=conf().get("cloud_host", ""), channel=channel)
+    chat_client.channel_mgr = channel_mgr
+    chat_client.config = _build_config()
+    chat_client.start()
+    time.sleep(1.5)
+    if chat_client.client_id:
+        logger.info("[CloudClient] Console: https://link-ai.tech/console/clients")
+
+
+def _build_config():
+    local_conf = conf()
+    config = {
+        "linkai_app_code": local_conf.get("linkai_app_code"),
+        "single_chat_prefix": local_conf.get("single_chat_prefix"),
+        "single_chat_reply_prefix": local_conf.get("single_chat_reply_prefix"),
+        "single_chat_reply_suffix": local_conf.get("single_chat_reply_suffix"),
+        "group_chat_prefix": local_conf.get("group_chat_prefix"),
+        "group_chat_reply_prefix": local_conf.get("group_chat_reply_prefix"),
+        "group_chat_reply_suffix": local_conf.get("group_chat_reply_suffix"),
+        "group_name_white_list": local_conf.get("group_name_white_list"),
+        "nick_name_black_list": local_conf.get("nick_name_black_list"),
+        "speech_recognition": "Y" if local_conf.get("speech_recognition") else "N",
+        "text_to_image": local_conf.get("text_to_image"),
+        "image_create_prefix": local_conf.get("image_create_prefix"),
+        "model": local_conf.get("model"),
+        "agent_max_context_turns": local_conf.get("agent_max_context_turns"),
+        "agent_max_context_tokens": local_conf.get("agent_max_context_tokens"),
+        "agent_max_steps": local_conf.get("agent_max_steps"),
+        "channelType": local_conf.get("channel_type"),
+    }
+
+    if local_conf.get("always_reply_voice"):
+        config["reply_voice_mode"] = "always_reply_voice"
+    elif local_conf.get("voice_reply_voice"):
+        config["reply_voice_mode"] = "voice_reply_voice"
+
+    if pconf("linkai"):
+        config["group_app_map"] = pconf("linkai").get("group_app_map")
+
+    if plugin_config.get("Godcmd"):
+        config["admin_password"] = plugin_config.get("Godcmd").get("password")
+
+    # Add channel-specific app credentials
+    current_channel_type = local_conf.get("channel_type", "")
+    if current_channel_type == "feishu":
+        config["app_id"] = local_conf.get("feishu_app_id")
+        config["app_secret"] = local_conf.get("feishu_app_secret")
+    elif current_channel_type == "dingtalk":
+        config["app_id"] = local_conf.get("dingtalk_client_id")
+        config["app_secret"] = local_conf.get("dingtalk_client_secret")
+    elif current_channel_type in ("wechatmp", "wechatmp_service"):
+        config["app_id"] = local_conf.get("wechatmp_app_id")
+        config["app_secret"] = local_conf.get("wechatmp_app_secret")
+    elif current_channel_type == "wechatcom_app":
+        config["app_id"] = local_conf.get("wechatcomapp_agent_id")
+        config["app_secret"] = local_conf.get("wechatcomapp_secret")
+
+    return config

common/const.py

@@ -1,77 +1,99 @@
-# bot_type
+# 厂商类型
 OPEN_AI = "openAI"
 CHATGPT = "chatGPT"
-BAIDU = "baidu"  # 百度文心一言模型
+BAIDU = "baidu"
 XUNFEI = "xunfei"
 CHATGPTONAZURE = "chatGPTOnAzure"
 LINKAI = "linkai"
-CLAUDEAI = "claude"  # 使用cookie的历史模型
-CLAUDEAPI= "claudeAPI"  # 通过Claude api调用模型
-QWEN = "qwen"  # 旧版通义模型
-QWEN_DASHSCOPE = "dashscope"  # 通义新版sdk和api key
-
-
-GEMINI = "gemini"  # gemini-1.0-pro
+CLAUDEAPI= "claudeAPI"
+QWEN = "qwen"  # 旧版千问接入
+QWEN_DASHSCOPE = "dashscope"  # 新版千问接入(百炼)
+GEMINI = "gemini" 
 ZHIPU_AI = "glm-4"
 MOONSHOT = "moonshot"
 MiniMax = "minimax"
 MODELSCOPE = "modelscope"
 
-# model
+# 模型列表
+# Claude (Anthropic)
 CLAUDE3 = "claude-3-opus-20240229"
-GPT35 = "gpt-3.5-turbo"
-GPT35_0125 = "gpt-3.5-turbo-0125"
-GPT35_1106 = "gpt-3.5-turbo-1106"
-
-GPT_4o = "gpt-4o"
-GPT_4O_0806 = "gpt-4o-2024-08-06"
-GPT4_TURBO = "gpt-4-turbo"
-GPT4_TURBO_PREVIEW = "gpt-4-turbo-preview"
-GPT4_TURBO_04_09 = "gpt-4-turbo-2024-04-09"
-GPT4_TURBO_01_25 = "gpt-4-0125-preview"
-GPT4_TURBO_11_06 = "gpt-4-1106-preview"
-GPT4_VISION_PREVIEW = "gpt-4-vision-preview"
-
-GPT4 = "gpt-4"
-GPT_4o_MINI = "gpt-4o-mini"
-GPT4_32k = "gpt-4-32k"
-GPT4_06_13 = "gpt-4-0613"
-GPT4_32k_06_13 = "gpt-4-32k-0613"
-GPT_41 = "gpt-4.1"
-GPT_41_MINI = "gpt-4.1-mini"
-GPT_41_NANO = "gpt-4.1-nano"
-
-GPT_5 = "gpt-5"
-GPT_5_MINI = "gpt-5-mini"
-GPT_5_NANO = "gpt-5-nano"
-
-O1 = "o1-preview"
-O1_MINI = "o1-mini"
-
-WHISPER_1 = "whisper-1"
-TTS_1 = "tts-1"
-TTS_1_HD = "tts-1-hd"
-
-WEN_XIN = "wenxin"
-WEN_XIN_4 = "wenxin-4"
-
-QWEN_TURBO = "qwen-turbo"
-QWEN_PLUS = "qwen-plus"
-QWEN_MAX = "qwen-max"
-
-LINKAI_35 = "linkai-3.5"
-LINKAI_4_TURBO = "linkai-4-turbo"
-LINKAI_4o = "linkai-4o"
+CLAUDE_3_OPUS = "claude-3-opus-latest"
+CLAUDE_3_OPUS_0229 = "claude-3-opus-20240229"
+CLAUDE_3_SONNET = "claude-3-sonnet-20240229"
+CLAUDE_3_HAIKU = "claude-3-haiku-20240307"
+CLAUDE_35_SONNET = "claude-3-5-sonnet-latest"  # 带 latest 标签的模型名称，会不断更新指向最新发布的模型
+CLAUDE_35_SONNET_1022 = "claude-3-5-sonnet-20241022"  # 带具体日期的模型名称，会固定为该日期发布的模型
+CLAUDE_35_SONNET_0620 = "claude-3-5-sonnet-20240620"
+CLAUDE_4_OPUS = "claude-opus-4-0"
+CLAUDE_4_6_OPUS = "claude-opus-4-6"      # Claude Opus 4.6 - Agent推荐模型
+CLAUDE_4_SONNET = "claude-sonnet-4-0"    # Claude Sonnet 4.0
+CLAUDE_4_5_SONNET = "claude-sonnet-4-5"  # Claude Sonnet 4.5 - Agent推荐模型
+CLAUDE_4_6_SONNET = "claude-sonnet-4-6"  # Claude Sonnet 4.6 - Agent推荐模型
 
+# Gemini (Google)
 GEMINI_PRO = "gemini-1.0-pro"
 GEMINI_15_flash = "gemini-1.5-flash"
 GEMINI_15_PRO = "gemini-1.5-pro"
 GEMINI_20_flash_exp = "gemini-2.0-flash-exp"  # exp结尾为实验模型，会逐步不再支持
 GEMINI_20_FLASH = "gemini-2.0-flash"  # 正式版模型
-GEMINI_25_FLASH_PRE = "gemini-2.5-flash-preview-05-20"  # preview为预览版模型 ，主要是新能力体验
+GEMINI_25_FLASH_PRE = "gemini-2.5-flash-preview-05-20"
 GEMINI_25_PRO_PRE = "gemini-2.5-pro-preview-05-06"
+GEMINI_3_FLASH_PRE = "gemini-3-flash-preview"  # Gemini 3 Flash Preview - Agent推荐模型
+GEMINI_3_PRO_PRE = "gemini-3-pro-preview"  # Gemini 3 Pro Preview
+GEMINI_31_PRO_PRE = "gemini-3.1-pro-preview"  # Gemini 3.1 Pro Preview - Agent推荐模型
 
+# OpenAI
+GPT35 = "gpt-3.5-turbo"
+GPT35_0125 = "gpt-3.5-turbo-0125"
+GPT35_1106 = "gpt-3.5-turbo-1106"
+GPT4 = "gpt-4"
+GPT4_06_13 = "gpt-4-0613"
+GPT4_32k = "gpt-4-32k"
+GPT4_32k_06_13 = "gpt-4-32k-0613"
+GPT4_TURBO = "gpt-4-turbo"
+GPT4_TURBO_PREVIEW = "gpt-4-turbo-preview"
+GPT4_TURBO_01_25 = "gpt-4-0125-preview"
+GPT4_TURBO_11_06 = "gpt-4-1106-preview"
+GPT4_TURBO_04_09 = "gpt-4-turbo-2024-04-09"
+GPT4_VISION_PREVIEW = "gpt-4-vision-preview"
+GPT_4o = "gpt-4o"
+GPT_4O_0806 = "gpt-4o-2024-08-06"
+GPT_4o_MINI = "gpt-4o-mini"
+GPT_41 = "gpt-4.1"
+GPT_41_MINI = "gpt-4.1-mini"
+GPT_41_NANO = "gpt-4.1-nano"
+GPT_5 = "gpt-5"
+GPT_5_MINI = "gpt-5-mini"
+GPT_5_NANO = "gpt-5-nano"
+O1 = "o1-preview"
+O1_MINI = "o1-mini"
+WHISPER_1 = "whisper-1"
+TTS_1 = "tts-1"
+TTS_1_HD = "tts-1-hd"
 
+# DeepSeek
+DEEPSEEK_CHAT = "deepseek-chat"  # DeepSeek-V3对话模型
+DEEPSEEK_REASONER = "deepseek-reasoner"  # DeepSeek-R1模型
+
+# Qwen (通义千问 - 阿里云)
+QWEN = "qwen"
+QWEN_TURBO = "qwen-turbo"
+QWEN_PLUS = "qwen-plus"
+QWEN_MAX = "qwen-max"
+QWEN_LONG = "qwen-long"
+QWEN3_MAX = "qwen3-max"  # Qwen3 Max - Agent推荐模型
+QWEN35_PLUS = "qwen3.5-plus"  # Qwen3.5 Plus - Omni model (MultiModalConversation)
+QWQ_PLUS = "qwq-plus"
+
+# MiniMax
+MINIMAX_M2_5 = "MiniMax-M2.5"  # MiniMax M2.5 - Latest
+MINIMAX_M2_1 = "MiniMax-M2.1"  # MiniMax M2.1 - Agent推荐模型
+MINIMAX_M2_1_LIGHTNING = "MiniMax-M2.1-lightning"  # MiniMax M2.1 极速版
+MINIMAX_M2 = "MiniMax-M2"  # MiniMax M2
+MINIMAX_ABAB6_5 = "abab6.5-chat"  # MiniMax abab6.5
+
+# GLM (智谱AI)
+GLM_5 = "glm-5"  # 智谱 GLM-5 - Latest
 GLM_4 = "glm-4"
 GLM_4_PLUS = "glm-4-plus"
 GLM_4_flash = "glm-4-flash"
@@ -80,20 +102,28 @@ GLM_4_ALLTOOLS = "glm-4-alltools"
 GLM_4_0520 = "glm-4-0520"
 GLM_4_AIR = "glm-4-air"
 GLM_4_AIRX = "glm-4-airx"
+GLM_4_7 = "glm-4.7"  # 智谱 GLM-4.7 - Agent推荐模型
 
+# Kimi (Moonshot)
+MOONSHOT = "moonshot"
+KIMI_K2 = "kimi-k2"
+KIMI_K2_5 = "kimi-k2.5"
 
-CLAUDE_3_OPUS = "claude-3-opus-latest"
-CLAUDE_3_OPUS_0229 = "claude-3-opus-20240229"
-CLAUDE_35_SONNET = "claude-3-5-sonnet-latest"  # 带 latest 标签的模型名称，会不断更新指向最新发布的模型
-CLAUDE_35_SONNET_1022 = "claude-3-5-sonnet-20241022"  # 带具体日期的模型名称，会固定为该日期发布的模型
-CLAUDE_35_SONNET_0620 = "claude-3-5-sonnet-20240620"
-CLAUDE_3_SONNET = "claude-3-sonnet-20240229"
-CLAUDE_3_HAIKU = "claude-3-haiku-20240307"
-CLAUDE_4_SONNET = "claude-sonnet-4-0"
-CLAUDE_4_OPUS = "claude-opus-4-0"
+# Doubao (Volcengine Ark)
+DOUBAO = "doubao"
+DOUBAO_SEED_2_CODE = "doubao-seed-2-0-code-preview-260215"
+DOUBAO_SEED_2_PRO = "doubao-seed-2-0-pro-260215"
+DOUBAO_SEED_2_LITE = "doubao-seed-2-0-lite-260215"
+DOUBAO_SEED_2_MINI = "doubao-seed-2-0-mini-260215"
 
-DEEPSEEK_CHAT = "deepseek-chat"  # DeepSeek-V3对话模型
-DEEPSEEK_REASONER = "deepseek-reasoner"  # DeepSeek-R1模型
+# 其他模型
+WEN_XIN = "wenxin"
+WEN_XIN_4 = "wenxin-4"
+XUNFEI = "xunfei"
+LINKAI_35 = "linkai-3.5"
+LINKAI_4_TURBO = "linkai-4-turbo"
+LINKAI_4o = "linkai-4o"
+MODELSCOPE = "modelscope"
 
 GITEE_AI_MODEL_LIST = ["Yi-34B-Chat", "InternVL2-8B", "deepseek-coder-33B-instruct", "InternVL2.5-26B", "Qwen2-VL-72B", "Qwen2.5-32B-Instruct", "glm-4-9b-chat", "codegeex4-all-9b", "Qwen2.5-Coder-32B-Instruct", "Qwen2.5-72B-Instruct", "Qwen2.5-7B-Instruct", "Qwen2-72B-Instruct", "Qwen2-7B-Instruct", "code-raccoon-v1", "Qwen2.5-14B-Instruct"]
 
@@ -104,19 +134,47 @@ MODELSCOPE_MODEL_LIST = ["LLM-Research/c4ai-command-r-plus-08-2024","mistralai/M
                           "deepseek-ai/DeepSeek-R1-Distill-Qwen-14B","deepseek-ai/DeepSeek-R1-Distill-Qwen-7B","deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B","deepseek-ai/DeepSeek-R1","deepseek-ai/DeepSeek-V3","Qwen/QwQ-32B"]
 
 MODEL_LIST = [
+              # Claude
+              CLAUDE3, CLAUDE_4_6_SONNET, CLAUDE_4_6_OPUS, CLAUDE_4_OPUS, CLAUDE_4_5_SONNET, CLAUDE_4_SONNET, CLAUDE_3_OPUS, CLAUDE_3_OPUS_0229, 
+              CLAUDE_35_SONNET, CLAUDE_35_SONNET_1022, CLAUDE_35_SONNET_0620, CLAUDE_3_SONNET, CLAUDE_3_HAIKU, 
+              "claude", "claude-3-haiku", "claude-3-sonnet", "claude-3-opus", "claude-3.5-sonnet",
+              
+              # Gemini
+              GEMINI_31_PRO_PRE, GEMINI_3_PRO_PRE, GEMINI_3_FLASH_PRE, GEMINI_25_PRO_PRE, GEMINI_25_FLASH_PRE, 
+              GEMINI_20_FLASH, GEMINI_20_flash_exp, GEMINI_15_PRO, GEMINI_15_flash, GEMINI_PRO, GEMINI,
+              
+              # OpenAI
               GPT35, GPT35_0125, GPT35_1106, "gpt-3.5-turbo-16k",
-              GPT_41, GPT_41_MINI, GPT_41_NANO, O1, O1_MINI, GPT_4o, GPT_4O_0806, GPT_4o_MINI, GPT4_TURBO, GPT4_TURBO_PREVIEW, GPT4_TURBO_01_25, GPT4_TURBO_11_06, GPT4, GPT4_32k, GPT4_06_13, GPT4_32k_06_13,
+              GPT4, GPT4_06_13, GPT4_32k, GPT4_32k_06_13,
+              GPT4_TURBO, GPT4_TURBO_PREVIEW, GPT4_TURBO_01_25, GPT4_TURBO_11_06, GPT4_TURBO_04_09,
+              GPT_4o, GPT_4O_0806, GPT_4o_MINI,
+              GPT_41, GPT_41_MINI, GPT_41_NANO,
               GPT_5, GPT_5_MINI, GPT_5_NANO,
-              WEN_XIN, WEN_XIN_4,
-              XUNFEI,
-              ZHIPU_AI, GLM_4, GLM_4_PLUS, GLM_4_flash, GLM_4_LONG, GLM_4_ALLTOOLS, GLM_4_0520, GLM_4_AIR, GLM_4_AIRX,
-              MOONSHOT, MiniMax,
-              GEMINI_25_PRO_PRE, GEMINI_25_FLASH_PRE, GEMINI_20_FLASH, GEMINI, GEMINI_PRO, GEMINI_15_flash, GEMINI_15_PRO, GEMINI_20_flash_exp,
-              CLAUDE_4_OPUS, CLAUDE_4_SONNET, CLAUDE_3_OPUS, CLAUDE_3_OPUS_0229, CLAUDE_35_SONNET, CLAUDE_35_SONNET_1022, CLAUDE_35_SONNET_0620, CLAUDE_3_SONNET, CLAUDE_3_HAIKU, "claude", "claude-3-haiku", "claude-3-sonnet", "claude-3-opus", "claude-3.5-sonnet",
-              "moonshot-v1-8k", "moonshot-v1-32k", "moonshot-v1-128k",
-              QWEN, QWEN_TURBO, QWEN_PLUS, QWEN_MAX,
-              LINKAI_35, LINKAI_4_TURBO, LINKAI_4o,
+              O1, O1_MINI,
+              
+              # DeepSeek
               DEEPSEEK_CHAT, DEEPSEEK_REASONER,
+              
+              # Qwen
+              QWEN, QWEN_TURBO, QWEN_PLUS, QWEN_MAX, QWEN_LONG, QWEN3_MAX, QWEN35_PLUS,
+              
+              # MiniMax
+              MiniMax, MINIMAX_M2_5, MINIMAX_M2_1, MINIMAX_M2_1_LIGHTNING, MINIMAX_M2, MINIMAX_ABAB6_5,
+
+              # GLM
+              ZHIPU_AI, GLM_5, GLM_4, GLM_4_PLUS, GLM_4_flash, GLM_4_LONG, GLM_4_ALLTOOLS,
+              GLM_4_0520, GLM_4_AIR, GLM_4_AIRX, GLM_4_7,
+
+              # Kimi
+              MOONSHOT, "moonshot-v1-8k", "moonshot-v1-32k", "moonshot-v1-128k",
+              KIMI_K2, KIMI_K2_5,
+
+              # Doubao
+              DOUBAO, DOUBAO_SEED_2_CODE, DOUBAO_SEED_2_PRO, DOUBAO_SEED_2_LITE, DOUBAO_SEED_2_MINI,
+
+              # 其他模型
+              WEN_XIN, WEN_XIN_4, XUNFEI,
+              LINKAI_35, LINKAI_4_TURBO, LINKAI_4o,
               MODELSCOPE
             ]
 

common/linkai_client.py

@@ -1,110 +0,0 @@
-from bridge.context import Context, ContextType
-from bridge.reply import Reply, ReplyType
-from common.log import logger
-from linkai import LinkAIClient, PushMsg
-from config import conf, pconf, plugin_config, available_setting, write_plugin_config
-from plugins import PluginManager
-import time
-
-
-chat_client: LinkAIClient
-
-
-class ChatClient(LinkAIClient):
-    def __init__(self, api_key, host, channel):
-        super().__init__(api_key, host)
-        self.channel = channel
-        self.client_type = channel.channel_type
-
-    def on_message(self, push_msg: PushMsg):
-        session_id = push_msg.session_id
-        msg_content = push_msg.msg_content
-        logger.info(f"receive msg push, session_id={session_id}, msg_content={msg_content}")
-        context = Context()
-        context.type = ContextType.TEXT
-        context["receiver"] = session_id
-        context["isgroup"] = push_msg.is_group
-        self.channel.send(Reply(ReplyType.TEXT, content=msg_content), context)
-
-    def on_config(self, config: dict):
-        if not self.client_id:
-            return
-        logger.info(f"[LinkAI] 从客户端管理加载远程配置: {config}")
-        if config.get("enabled") != "Y":
-            return
-
-        local_config = conf()
-        for key in config.keys():
-            if key in available_setting and config.get(key) is not None:
-                local_config[key] = config.get(key)
-        # 语音配置
-        reply_voice_mode = config.get("reply_voice_mode")
-        if reply_voice_mode:
-            if reply_voice_mode == "voice_reply_voice":
-                local_config["voice_reply_voice"] = True
-                local_config["always_reply_voice"] = False
-            elif reply_voice_mode == "always_reply_voice":
-                local_config["always_reply_voice"] = True
-                local_config["voice_reply_voice"] = True
-            elif reply_voice_mode == "no_reply_voice":
-                local_config["always_reply_voice"] = False
-                local_config["voice_reply_voice"] = False
-
-        if config.get("admin_password"):
-            if not pconf("Godcmd"):
-                write_plugin_config({"Godcmd": {"password": config.get("admin_password"), "admin_users": []} })
-            else:
-                pconf("Godcmd")["password"] = config.get("admin_password")
-            PluginManager().instances["GODCMD"].reload()
-
-        if config.get("group_app_map") and pconf("linkai"):
-            local_group_map = {}
-            for mapping in config.get("group_app_map"):
-                local_group_map[mapping.get("group_name")] = mapping.get("app_code")
-            pconf("linkai")["group_app_map"] = local_group_map
-            PluginManager().instances["LINKAI"].reload()
-
-        if config.get("text_to_image") and config.get("text_to_image") == "midjourney" and pconf("linkai"):
-            if pconf("linkai")["midjourney"]:
-                pconf("linkai")["midjourney"]["enabled"] = True
-                pconf("linkai")["midjourney"]["use_image_create_prefix"] = True
-        elif config.get("text_to_image") and config.get("text_to_image") in ["dall-e-2", "dall-e-3"]:
-            if pconf("linkai")["midjourney"]:
-                pconf("linkai")["midjourney"]["use_image_create_prefix"] = False
-
-
-def start(channel):
-    global chat_client
-    chat_client = ChatClient(api_key=conf().get("linkai_api_key"), host="", channel=channel)
-    chat_client.config = _build_config()
-    chat_client.start()
-    time.sleep(1.5)
-    if chat_client.client_id:
-        logger.info("[LinkAI] 可前往控制台进行线上登录和配置：https://link-ai.tech/console/clients")
-
-
-def _build_config():
-    local_conf = conf()
-    config = {
-        "linkai_app_code": local_conf.get("linkai_app_code"),
-        "single_chat_prefix": local_conf.get("single_chat_prefix"),
-        "single_chat_reply_prefix": local_conf.get("single_chat_reply_prefix"),
-        "single_chat_reply_suffix": local_conf.get("single_chat_reply_suffix"),
-        "group_chat_prefix": local_conf.get("group_chat_prefix"),
-        "group_chat_reply_prefix": local_conf.get("group_chat_reply_prefix"),
-        "group_chat_reply_suffix": local_conf.get("group_chat_reply_suffix"),
-        "group_name_white_list": local_conf.get("group_name_white_list"),
-        "nick_name_black_list": local_conf.get("nick_name_black_list"),
-        "speech_recognition": "Y" if local_conf.get("speech_recognition") else "N",
-        "text_to_image": local_conf.get("text_to_image"),
-        "image_create_prefix": local_conf.get("image_create_prefix")
-    }
-    if local_conf.get("always_reply_voice"):
-        config["reply_voice_mode"] = "always_reply_voice"
-    elif local_conf.get("voice_reply_voice"):
-        config["reply_voice_mode"] = "voice_reply_voice"
-    if pconf("linkai"):
-        config["group_app_map"] = pconf("linkai").get("group_app_map")
-    if plugin_config.get("Godcmd"):
-        config["admin_password"] = plugin_config.get("Godcmd").get("password")
-    return config

common/package_manager.py

@@ -28,7 +28,7 @@ def check_dulwich():
         except ImportError:
             try:
                 install("dulwich")
-            except:
+            except Exception:
                 needwait = True
     try:
         import dulwich

common/utils.py

@@ -2,7 +2,6 @@ import io
 import os
 import re
 from urllib.parse import urlparse
-from PIL import Image
 from common.log import logger
 
 def fsize(file):
@@ -23,6 +22,7 @@ def fsize(file):
 def compress_imgfile(file, max_size):
     if fsize(file) <= max_size:
         return file
+    from PIL import Image
     file.seek(0)
     img = Image.open(file)
     rgb_image = img.convert("RGB")
@@ -76,3 +76,42 @@ def remove_markdown_symbol(text: str):
     if not text:
         return text
     return re.sub(r'\*\*(.*?)\*\*', r'\1', text)
+
+
+def expand_path(path: str) -> str:
+    """
+    Expand user path with proper Windows support.
+    
+    On Windows, os.path.expanduser('~') may not work properly in some shells (like PowerShell).
+    This function provides a more robust path expansion.
+    
+    Args:
+        path: Path string that may contain ~
+        
+    Returns:
+        Expanded absolute path
+    """
+    if not path:
+        return path
+    
+    # Try standard expansion first
+    expanded = os.path.expanduser(path)
+    
+    # If expansion didn't work (path still starts with ~), use HOME or USERPROFILE
+    if expanded.startswith('~'):
+        import platform
+        if platform.system() == 'Windows':
+            # On Windows, try USERPROFILE first, then HOME
+            home = os.environ.get('USERPROFILE') or os.environ.get('HOME')
+        else:
+            # On Unix-like systems, use HOME
+            home = os.environ.get('HOME')
+        
+        if home:
+            # Replace ~ with home directory
+            if path == '~':
+                expanded = home
+            elif path.startswith('~/') or path.startswith('~\\'):
+                expanded = os.path.join(home, path[2:])
+    
+    return expanded

config-template.json

@@ -1,23 +1,32 @@
 {
   "channel_type": "web",
-  "model": "claude-sonnet-4-5",
-  "open_ai_api_key": "YOUR API KEY",
-  "open_ai_api_base": "https://api.openai.com/v1",
-  "claude_api_key": "YOUR API KEY",
+  "model": "MiniMax-M2.5",
+  "minimax_api_key": "",
+  "zhipu_ai_api_key": "",
+  "ark_api_key": "",
+  "moonshot_api_key": "",
+  "dashscope_api_key": "",
+  "claude_api_key": "",
   "claude_api_base": "https://api.anthropic.com/v1",
-  "gemini_api_key": "YOUR API KEY",
+  "open_ai_api_key": "",
+  "open_ai_api_base": "https://api.openai.com/v1",
+  "gemini_api_key": "",
   "gemini_api_base": "https://generativelanguage.googleapis.com",
   "voice_to_text": "openai",
   "text_to_voice": "openai",
   "voice_reply_voice": false,
   "speech_recognition": true,
   "group_speech_recognition": false,
-  "proxy": "",
   "use_linkai": false,
   "linkai_api_key": "",
   "linkai_app_code": "",
+  "feishu_bot_name": "",
+  "feishu_app_id": "",
+  "feishu_app_secret": "",
+  "dingtalk_client_id": "",
+  "dingtalk_client_secret":"",
   "agent": true,
   "agent_max_context_tokens": 40000,
-  "agent_max_context_turns": 30,
-  "agent_max_steps": 20
+  "agent_max_context_turns": 20,
+  "agent_max_steps": 15
 }

config.py

@@ -160,7 +160,8 @@ available_setting = {
     # chatgpt指令自定义触发词
     "clear_memory_commands": ["#清除记忆"],  # 重置会话指令，必须以#开头
     # channel配置
-    "channel_type": "",  # 通道类型，支持：{wx,wxy,terminal,wechatmp,wechatmp_service,wechatcom_app,dingtalk}
+    "channel_type": "",  # 通道类型，支持多渠道同时运行。单个: "feishu"，多个: "feishu, dingtalk" 或 ["feishu", "dingtalk"]。可选值: web,feishu,dingtalk,wechatmp,wechatmp_service,wechatcom_app
+    "web_console": True,  # 是否自动启动Web控制台（默认启动）。设为False可禁用
     "subscribe_msg": "",  # 订阅消息, 支持: wechatmp, wechatmp_service, wechatcom_app
     "debug": False,  # 是否开启debug模式，开启后会打印更多日志
     "appdata_dir": "",  # 数据目录
@@ -174,7 +175,10 @@ available_setting = {
     "zhipu_ai_api_key": "",
     "zhipu_ai_api_base": "https://open.bigmodel.cn/api/paas/v4",
     "moonshot_api_key": "",
-    "moonshot_base_url": "https://api.moonshot.cn/v1/chat/completions",
+    "moonshot_base_url": "https://api.moonshot.cn/v1",
+    # 豆包(火山方舟) 平台配置
+    "ark_api_key": "",
+    "ark_base_url": "https://ark.cn-beijing.volces.com/api/v3",
     #魔搭社区 平台配置
     "modelscope_api_key": "",
     "modelscope_base_url": "https://api-inference.modelscope.cn/v1/chat/completions",
@@ -183,15 +187,16 @@ available_setting = {
     "linkai_api_key": "",
     "linkai_app_code": "",
     "linkai_api_base": "https://api.link-ai.tech",  # linkAI服务地址
-    "Minimax_api_key": "",
+    "cloud_host": "client.link-ai.tech",
+    "minimax_api_key": "",
     "Minimax_group_id": "",
     "Minimax_base_url": "",
     "web_port": 9899,
     "agent": True,  # 是否开启Agent模式
     "agent_workspace": "~/cow",  # agent工作空间路径，用于存储skills、memory等
-    "agent_max_context_tokens": 40000,  # Agent模式下最大上下文tokens
-    "agent_max_context_turns": 30,  # Agent模式下最大上下文轮次
-    "agent_max_steps": 20,  # Agent模式下单次运行最大决策步数
+    "agent_max_context_tokens": 50000,  # Agent模式下最大上下文tokens
+    "agent_max_context_turns": 30,  # Agent模式下最大上下文记忆轮次
+    "agent_max_steps": 15,  # Agent模式下单次运行最大决策步数
 }
 
 
@@ -243,11 +248,11 @@ class Config(dict):
         try:
             with open(os.path.join(get_appdata_dir(), "user_datas.pkl"), "rb") as f:
                 self.user_datas = pickle.load(f)
-                logger.info("[Config] User datas loaded.")
+                logger.debug("[Config] User datas loaded.")
         except FileNotFoundError as e:
-            logger.info("[Config] User datas file not found, ignore.")
+            logger.debug("[Config] User datas file not found, ignore.")
         except Exception as e:
-            logger.info("[Config] User datas error: {}".format(e))
+            logger.warning("[Config] User datas error: {}".format(e))
             self.user_datas = {}
 
     def save_user_datas(self):
@@ -288,6 +293,15 @@ def drag_sensitive(config):
 
 def load_config():
     global config
+
+    # 打印 ASCII Logo
+    logger.info("  ____                _                    _   ")
+    logger.info(" / ___|_____      __ / \\   __ _  ___ _ __ | |_ ")
+    logger.info("| |   / _ \\ \\ /\\ / // _ \\ / _` |/ _ \\ '_ \\| __|")
+    logger.info("| |__| (_) \\ V  V // ___ \\ (_| |  __/ | | | |_ ")
+    logger.info(" \\____\\___/ \\_/\\_//_/   \\_\\__, |\\___|_| |_|\\__|")
+    logger.info("                          |___/                 ")
+    logger.info("")
     config_path = "./config.json"
     if not os.path.exists(config_path):
         logger.info("配置文件不存在，将使用config-template.json模板")
@@ -310,7 +324,7 @@ def load_config():
             logger.info("[INIT] override config by environ args: {}={}".format(name, value))
             try:
                 config[name] = eval(value)
-            except:
+            except Exception:
                 if value == "false":
                     config[name] = False
                 elif value == "true":
@@ -324,6 +338,23 @@ def load_config():
 
     logger.info("[INIT] load config: {}".format(drag_sensitive(config)))
 
+    # 打印系统初始化信息
+    logger.info("[INIT] ========================================")
+    logger.info("[INIT] System Initialization")
+    logger.info("[INIT] ========================================")
+    logger.info("[INIT] Channel: {}".format(config.get("channel_type", "unknown")))
+    logger.info("[INIT] Model: {}".format(config.get("model", "unknown")))
+
+    # Agent模式信息
+    if config.get("agent", False):
+        workspace = config.get("agent_workspace", "~/cow")
+        logger.info("[INIT] Mode: Agent (workspace: {})".format(workspace))
+    else:
+        logger.info("[INIT] Mode: Chat (在config.json中设置 \"agent\":true 可启用Agent模式)")
+
+    logger.info("[INIT] Debug: {}".format(config.get("debug", False)))
+    logger.info("[INIT] ========================================")
+
     config.load_user_datas()
 
 

docker/docker-compose.yml

@@ -21,5 +21,6 @@ services:
       EXPIRES_IN_SECONDS: 3600
       USE_GLOBAL_PLUGIN_CONFIG: 'True'
       USE_LINKAI: 'False'
+      AGENT: 'True'
       LINKAI_API_KEY: ''
       LINKAI_APP_CODE: ''

docs/agent.md

@@ -0,0 +1,182 @@
+# CowAgent介绍
+
+## 概述
+
+Cow项目从简单的聊天机器人全面升级为超级智能助理 **CowAgent**，能够主动规思考和规划任务、拥有长期记忆、操作计算机和外部资源、创造和执行Skill，真正理解你并和你一起成长。CowAgent能够长期运行在个人电脑或服务器中，通过飞书、钉钉、企业微信、网页等多种方式进行交互。核心能力如下：
+
+- **复杂任务规划**：能够理解复杂任务并自主规划执行，持续思考和调用工具直到完成目标，支持多轮推理和上下文理解
+- **工具系统**：内置实现10+种工具，包括文件读写、bash终端、浏览器、定时任务、记忆管理等，通过Agent管理你的计算机或服务器
+- **长期记忆**：自动将对话记忆持久化至本地文件和数据库中，包括全局记忆和天级记忆，支持关键词及向量检索
+- **Skills系统**：新增Skill运行引擎，内置多种技能，并支持通过自然语言对话完成自定义Skills开发
+- **多渠道和多模型支持**：支持在Web、飞书、钉钉、企微等多渠道与Agent交互，支持Claude、Gemini、OpenAI、GLM、MiniMax、Qwen、Kimi、Doubao 等多种国内外主流模型
+- **安全和成本**：通过秘钥管理工具、提示词控制、系统权限等手段控制Agent的访问安全；通过最大记忆轮次、最大上下文token、工具执行步数对token成本进行限制
+
+
+## 核心功能
+
+### 1. 长期记忆
+
+> 记忆系统让 Agent 能够长期记住重要信息。Agent 会在用户分享偏好、决策、事实等重要信息时主动存储，也会在对话达到一定长度时自动提取摘要。记忆分为核心记忆、天级记忆，支持语义搜索和向量检索的混合检索模式。
+
+
+第一次启动Agent会主动向用户获取询问关键信息，并记录至工作空间 (默认为 ~/cow) 中的智能体设定、用户身份、记忆文件中。
+
+在后续的长期对话中，Agent会在需要的时候智能记录或检索记忆，并对自身设定、用户偏好、记忆文件等进行不断更新，总结和记录经验和教训，真正实现自主思考和不断成长。
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260203000455.png">
+
+
+
+### 2. 任务规划和工具调用
+
+工具是Agent访问操作系统资源的核心，Agent会根据任务需求智能选择和调用工具，完成文件读写、命令执行、定时任务等各类操作。内置工具的视线在项目的 `tools` 目录下。
+
+**主要工具：** 文件读写编辑、Bash终端、浏览器、文件发送、定时调度、记忆搜索、环境配置等。
+
+#### 1.1 终端和文件访问能力
+
+针对操作系统的终端和文件的访问能力，是最基础和核心的工具，其他很多工具或技能都是基于基础工具进行扩展。用户可通过手机端与Agent交互，操作个人电脑或服务器上的资源：
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260202181130.png">
+
+#### 1.2 编程能力
+
+基于编程能力和系统访问能力，Agent可以实现从信息搜索、图片等素材生成、编码、测试、部署、Nginx配置修改、发布的 Vibecoding 全流程，通过手机端简单的一句命令完成应用的快速demo：
+
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260203121008.png">
+
+
+
+#### 1.3 定时任务
+
+基于 scheduler 工具实现动态定时任务，支持 **一次性任务、固定时间间隔、Cron表达式** 三种形式，任务触发可选择**固定消息发送** 或 **Agent动态任务** 执行两种模式，有很高灵活性：
+
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260202195402.png">
+
+同时你也可以通过自然语言快速查看和管理已有的定时任务。
+
+
+#### 1.4 环境变量管理
+
+技能所需要的秘钥存储在环境变量文件中，由 `env_config` 工具进行管理，你可以通过对话的方式更新秘钥，工具内置了安全保护和脱敏策略，会严格保护秘钥安全：
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260202234939.png">
+
+### 3. 技能系统
+
+> 技能系统为Agent提供无限的扩展性，每个Skill由说明文件、运行脚本 (可选)、资源 (可选) 组成，描述如何完成特定类型的任务。通过Skill可以让Agent遵循说明完成复杂流程，调用各类工具或对接第三方系统等。
+
+- **内置技能：** 在项目的`skills`目录下，包含技能创造器、网络搜索、图像识别（openai-image-vision）、LinkAI智能体、网页抓取等。内置Skill根据依赖条件 (API Key、系统命令等) 自动判断是否启用。通过技能创造器可以快速创建自定义技能。
+
+- **自定义技能：** 由用户通过对话创建，存放在工作空间中 (`~/cow/skills/`)，基于自定义技能可以实现任何复杂的业务流程和第三方系统对接。
+
+
+#### 3.1 创建技能
+
+通过 `skill-creator` 技能可以通过对话的方式快速创建技能。你可以在与Agent的写作中让他对将某个工作流程固化为技能，或者把任意接口文档和示例发送给Agent，让他直接完成对接：
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260202202247.png">
+
+
+#### 3.2 搜索和图像识别
+
+- **搜索技能：** 系统内置实现了 `bocha-search`(博查搜索)的Skill，依赖环境变量 `BOCHA_SEARCH_API_KEY`，可在[控制台](https://open.bochaai.com/)进行创建，并发送给Agent完成配置
+- **图像识别技能：** 实现了 `openai-image-vision` 插件，可使用 gpt-4.1-mini、gpt-4.1 等图像识别模型。依赖秘钥 `OPENAI_API_KEY`，可通过config.json或env_config工具进行维护。
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260202213219.png">
+
+
+#### 3.3 三方知识库和插件
+
+`linkai-agent` 技能可以将 [LinkAI](https://link-ai.tech/) 上的所有智能体作为skill交给Agent使用，并实现多智能体决策的效果。
+
+使用方式：需通过对话的方式配置 `LINKAI_API_KEY`，或在config.json中添加 `linkai_api_key`。 并在 `skills/linkai-agent/config.json`中添加智能体说明，示例如下：
+
+```json
+{
+  "apps": [
+    {
+      "app_code": "G7z6vKwp",
+      "app_name": "LinkAI客服助手",
+      "app_description": "当用户需要了解LinkAI平台相关问题时才选择该助手，基于LinkAI知识库进行回答"
+    },
+    {
+      "app_code": "SFY5x7JR",
+      "app_name": "内容创作助手",
+      "app_description": "当用户需要创作图片或视频时才使用该助手，支持Nano Banana、Seedream、即梦、Veo、可灵等多种模型"
+    }
+  ]
+}
+```
+
+Agent可根据智能体的名称和描述进行决策，并通过 app_code 调用接口访问对应的应用/工作流，通过该技能，可以灵活访问LinkAI平台上的智能体、知识库、插件等能力，实现效果如下：
+
+<img width="750" src="https://cdn.link-ai.tech/doc/20260202234350.png">
+
+注：需通过 `env_config` 配置 `LINKAI_API_KEY`，或在config.json中添加 `linkai_api_key` 配置。
+
+
+## 使用方式
+
+> 详细使用方式参考项目README.md文档进行
+
+### 1.项目运行
+
+在命令行中执行：
+
+```bash
+bash <(curl -sS https://cdn.link-ai.tech/code/cow/run.sh)
+```
+
+详细说明及后续程序管理参考：[项目启动脚本](https://github.com/zhayujie/chatgpt-on-wechat/wiki/CowAgentQuickStart)
+
+
+### 2.模型选择
+
+Agent模式推荐使用以下模型，可根据效果及成本综合选择：
+
+- **MiniMax**: `MiniMax-M2.5`
+- **GLM**: `glm-5`
+- **Kimi**: `kimi-k2.5`
+- **Doubao**: `doubao-seed-2-0-code-preview-260215`
+- **Qwen**: `qwen3.5-plus`
+- **Claude**: `claude-sonnet-4-6`
+- **Gemini**: `gemini-3.1-pro-preview`
+
+详细模型配置方式参考 [README.md 模型说明](../README.md#模型说明)
+
+### 3.Agent核心配置
+
+Agent模式的核心配置项如下，在 `config.json` 中配置：
+
+```bash
+{
+  "agent": true,                           # 是否启用Agent模式
+  "agent_workspace": "~/cow",              # Agent工作空间路径
+  "agent_max_context_tokens": 40000,       # 最大上下文tokens
+  "agent_max_context_turns": 30,           # 最大上下文记忆轮次
+  "agent_max_steps": 15                    # 单次任务最大决策步数
+}
+```
+
+**配置说明：**
+
+- `agent`: 设为 `true` 启用Agent模式，获得多轮工具决策、长期记忆、Skills等能力
+- `agent_workspace`: 工作空间路径，用于存储 memory、skills、其他系统设定提示词
+- `agent_max_context_tokens`: 上下文token上限，超出将自动丢弃最早的对话
+- `agent_max_context_turns`: 上下文记忆轮次，每轮包括一次提问和回复
+- `agent_max_steps`: 单次任务最大工具调用步数，防止无限循环
+
+
+### 4.渠道接入
+
+Agent支持在多种渠道中使用，只需修改 `config.json` 中的 `channel_type` 配置即可切换。
+
+- **Web网页**：默认使用该渠道，运行后监听本地端口，通过浏览器访问
+- **飞书接入**：[飞书接入文档](https://docs.link-ai.tech/cow/multi-platform/feishu)
+- **钉钉接入**：[钉钉接入文档](https://docs.link-ai.tech/cow/multi-platform/dingtalk)
+- **企业微信应用接入**：[企微应用文档](https://docs.link-ai.tech/cow/multi-platform/wechat-com)
+
+更多渠道配置参考：[通道说明](../README.md#通道说明)

docs/release/2.0.0.md

@@ -0,0 +1,121 @@
+# CowAgent 2.0
+
+🚀 CowAgent 2.0 实现了从聊天机器人到**超级智能助理**的全面升级！现在它能够主动思考和规划任务、拥有长期记忆、操作计算机和外部资源、创造和执行技能，真正理解你并和你一起成长。
+
+### ✨ 重点更新
+
+- Agent核心能力：
+    - **复杂任务规划**：能够理解复杂任务并自主规划执行，持续思考和调用工具直到完成目标，支持多轮推理和上下文理解。
+    - **长期记忆**：自动将对话记忆持久化至本地文件和数据库中，包括全局记忆和天级记忆，支持关键词及向量检索。
+    - **内置系统工具**：内置实现10+种工具，包括文件操作、bash终端、浏览器、文件发送、定时任务、记忆管理等。
+    - **Skills**：新增Skill运行引擎，内置多种技能，并支持通过自然语言对话完成自定义Skills开发。
+    - **安全和成本**：通过秘钥管理工具、提示词控制、系统权限等手段控制Agent的访问安全；通过最大记忆轮次、最大上下文token、工具执行步数对token成本进行限制。
+- 其他更新：
+    - 渠道优化：飞书及钉钉接入渠道支持长连接接入(无需公网IP)、支持图片/文件消息的接收和发送。
+    - 模型更新：新增claude-sonnet-4-5、gemini-3-pro-preview、glm-4.7、MiniMax-M2.1、qwen3-max等最新模型。
+    - 部署优化：增加一键安装、配置、运行、管理的脚本，简化部署流程。
+
+## 一、长期记忆系统
+
+Agent 会在用户分享重要信息时主动存储，也会在对话达到一定长度时自动提取摘要。支持语义搜索和向量检索的混合检索模式。
+
+**首次启动**时，Agent 会主动询问关键信息，并记录至工作空间(默认 `~/cow`)中的智能体设定、用户身份、记忆文件中。
+
+**长期对话**中，Agent 会智能记录或检索记忆，不断更新自身设定、用户偏好，总结经验和教训，真正实现自主思考和持续成长。
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260203000455.png">
+
+
+## 二、任务规划与工具调用
+
+Agent 根据任务需求智能选择和调用工具，完成各类复杂操作。
+
+### 1. 终端和文件访问
+
+最基础和核心的工具能力，用户可通过手机端与 Agent 交互，操作个人电脑或服务器上的资源：
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260202181130.png">
+
+### 2. 应用编程能力
+
+基于编程能力和系统访问能力，Agent 可实现从信息搜索、素材生成、编码、测试、部署、Nginx配置、发布的 **Vibecoding 全流程**，通过手机端一句命令完成应用快速 demo。
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260203121008.png">
+
+### 3. 定时任务
+
+支持 **一次性任务、固定时间间隔、Cron表达式** 三种形式，任务触发可选择 **固定消息发送** 或 **Agent动态任务执行** 两种模式：
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260202195402.png">
+
+### 4. 环境变量管理
+
+通过 `env_config` 工具管理技能所需秘钥，支持对话式更新，内置安全保护和脱敏策略：
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260202234939.png">
+
+## 三、技能系统
+
+每个 Skill 由说明文件、运行脚本(可选)、资源(可选)组成，为 Agent 提供无限扩展性。
+
+### 1. 技能创造器
+
+通过对话方式快速创建技能，将工作流程固化或对接任意第三方接口：
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260202202247.png">
+
+### 2. 搜索和图像识别
+
+- **搜索技能**：内置 `bocha-search`(博查搜索)，配置 `BOCHA_SEARCH_API_KEY` 即可使用。
+- **图像识别**：支持 `gpt-4.1-mini`、`gpt-4.1` 等模型，配置 `OPENAI_API_KEY` 即可使用。
+
+<img width="800" src="https://cdn.link-ai.tech/doc/20260202213219.png">
+
+### 3. 三方知识库和插件
+
+`linkai-agent` 技能可将 [LinkAI](https://link-ai.tech/) 上的所有智能体作为 skill 使用，实现多智能体决策：
+
+<img width="750" src="https://cdn.link-ai.tech/doc/20260202234350.png">
+
+
+## 四、快速开始
+
+### 一键启动
+
+本次新增了一键下载、配置、运行和管理的脚本，只需命令行中执行：
+
+```bash
+bash <(curl -sS https://cdn.link-ai.tech/code/cow/run.sh)
+```
+
+详细说明参考：[项目启动脚本](https://github.com/zhayujie/chatgpt-on-wechat/wiki/CowAgentQuickStart)
+
+### 模型选择
+
+Agent 模式推荐使用以下模型：
+
+- **Claude**: `claude-sonnet-4-5`、`claude-sonnet-4-0`
+- **Gemini**: `gemini-3-flash-preview`、`gemini-3-pro-preview`
+- **GLM**: `glm-4.7`
+- **MiniMax**: `MiniMax-M2.1`
+- **Qwen**: `qwen3-max`
+
+详细配置方式参考 [README.md 模型说明](../README.md#模型说明)
+
+
+### 渠道接入
+
+支持在 Web、飞书、钉钉、企业微信 等多渠道与 Agent 交互，随时随地使用超级助理，只需修改 `config.json` 中的 `channel_type` 配置即可切换：
+
+- **Web网页**：默认使用该渠道，运行后监听本地端口，通过浏览器访问。
+- **飞书接入**：[飞书接入文档](https://docs.link-ai.tech/cow/multi-platform/feishu)
+- **钉钉接入**：[钉钉接入文档](https://docs.link-ai.tech/cow/multi-platform/dingtalk)
+- **企业微信应用接入**：[企微应用文档](https://docs.link-ai.tech/cow/multi-platform/wechat-com)
+
+更多渠道配置参考：[通道说明](../README.md#通道说明)
+
+## 五、参与共建
+
+2.0版本后，项目将持续升级Agent能力、拓展接入渠道、内置工具、技能系统，降低模型成本和提升安全性。欢迎 [提出反馈](https://github.com/zhayujie/chatgpt-on-wechat/issues) 和 [贡献代码](https://github.com/zhayujie/chatgpt-on-wechat/pulls)。
+
+**🤖立即体验 CowAgent 2.0，开启你的超级AI助理之旅！** 

lib/itchat/async_components/contact.py

@@ -273,7 +273,7 @@ def get_contact(self, update=False):
             'User-Agent' : config.USER_AGENT, }
         try:
             r = self.s.get(url, headers=headers)
-        except:
+        except Exception:
             logger.info('Failed to fetch contact, that may because of the amount of your chatrooms')
             for chatroom in self.get_chatrooms():
                 self.update_chatroom(chatroom['UserName'], detailedMember=True)

lib/itchat/async_components/hotreload.py

@@ -21,7 +21,7 @@ async def dump_login_status(self, fileDir=None):
         with open(fileDir, 'w') as f:
             f.write('itchat - DELETE THIS')
         os.remove(fileDir)
-    except:
+    except Exception:
         raise Exception('Incorrect fileDir')
     status = {
         'version'   : VERSION,
@@ -57,7 +57,7 @@ async def load_login_status(self, fileDir,
     self.storageClass.loads(j['storage'])
     try:
         msgList, contactList = self.get_msg()
-    except:
+    except Exception:
         msgList = contactList = None
     if (msgList or contactList) is None:
         self.logout()
@@ -97,6 +97,6 @@ async def load_last_login_status(session, cookiesDict):
             'mm_lang': 'zh_CN',
             'MM_WX_NOTIFY_STATE': '1',
             'MM_WX_SOUND_STATE': '1', })
-    except:
+    except Exception:
         logger.info('Load status for push login failed, we may have experienced a cookies change.')
         logger.info('If you are using the newest version of itchat, you may report a bug.')

lib/itchat/async_components/login.py

@@ -330,7 +330,7 @@ async def start_receiving(self, exitCallback=None, getReceivingFnOnly=False):
                 retryCount = 0
             except requests.exceptions.ReadTimeout:
                 pass
-            except:
+            except Exception:
                 retryCount += 1
                 logger.error(traceback.format_exc())
                 if self.receivingRetryCount < retryCount:
@@ -372,7 +372,7 @@ def sync_check(self):
             # 6f:00:8a:9c:09:74:e4:d8:e0:14:bf:96:3a:56:a0:64:1b:a4:25:5d:12:f4:31:a5:30:f1:c6:48:5f:c3:75:6a:99:93
             # seems like status of typing, but before I make further achievement code will remain like this
             return '2'
-        except:
+        except Exception:
             raise
     r.raise_for_status()
     regx = r'window.synccheck={retcode:"(\d+)",selector:"(\d+)"}'

lib/itchat/async_components/register.py

@@ -63,7 +63,7 @@ async def configured_reply(self, event_stream, payload, message_container):
                 r = await replyFn(msg)
                 if r is not None:
                     await self.send(r, msg.get('FromUserName'))
-            except:
+            except Exception:
                 logger.warning(traceback.format_exc())
 
 def msg_register(self, msgType, isFriendChat=False, isGroupChat=False, isMpChat=False):

lib/itchat/components/contact.py

@@ -287,7 +287,7 @@ def get_contact(self, update=False):
             'User-Agent': config.USER_AGENT, }
         try:
             r = self.s.get(url, headers=headers)
-        except:
+        except Exception:
             logger.info(
                 'Failed to fetch contact, that may because of the amount of your chatrooms')
             for chatroom in self.get_chatrooms():

lib/itchat/components/hotreload.py

@@ -21,7 +21,7 @@ def dump_login_status(self, fileDir=None):
         with open(fileDir, 'w') as f:
             f.write('itchat - DELETE THIS')
         os.remove(fileDir)
-    except:
+    except Exception:
         raise Exception('Incorrect fileDir')
     status = {
         'version'   : VERSION,
@@ -57,7 +57,7 @@ def load_login_status(self, fileDir,
     self.storageClass.loads(j['storage'])
     try:
         msgList, contactList = self.get_msg()
-    except:
+    except Exception:
         msgList = contactList = None
     if (msgList or contactList) is None:
         self.logout()
@@ -97,6 +97,6 @@ def load_last_login_status(session, cookiesDict):
             'mm_lang': 'zh_CN',
             'MM_WX_NOTIFY_STATE': '1',
             'MM_WX_SOUND_STATE': '1', })
-    except:
+    except Exception:
         logger.info('Load status for push login failed, we may have experienced a cookies change.')
         logger.info('If you are using the newest version of itchat, you may report a bug.')

lib/itchat/components/login.py

@@ -318,7 +318,7 @@ def start_receiving(self, exitCallback=None, getReceivingFnOnly=False):
                 retryCount = 0
             except requests.exceptions.ReadTimeout:
                 pass
-            except:
+            except Exception:
                 retryCount += 1
                 logger.error(traceback.format_exc())
                 if self.receivingRetryCount < retryCount:
@@ -364,7 +364,7 @@ def sync_check(self):
             # 6f:00:8a:9c:09:74:e4:d8:e0:14:bf:96:3a:56:a0:64:1b:a4:25:5d:12:f4:31:a5:30:f1:c6:48:5f:c3:75:6a:99:93
             # seems like status of typing, but before I make further achievement code will remain like this
             return '2'
-        except:
+        except Exception:
             raise
     r.raise_for_status()
     regx = r'window.synccheck={retcode:"(\d+)",selector:"(\d+)"}'

lib/itchat/components/register.py

@@ -63,7 +63,7 @@ def configured_reply(self):
                 r = replyFn(msg)
                 if r is not None:
                     self.send(r, msg.get('FromUserName'))
-            except:
+            except Exception:
                 logger.warning(traceback.format_exc())
 
 def msg_register(self, msgType, isFriendChat=False, isGroupChat=False, isMpChat=False):

lib/itchat/utils.py

@@ -82,7 +82,7 @@ def check_file(fileDir):
         with open(fileDir):
             pass
         return True
-    except:
+    except Exception:
         return False
 
 def print_qr(fileDir):
@@ -133,7 +133,7 @@ def test_connect(retryTime=5):
         try:
             r = requests.get(config.BASE_URL)
             return True
-        except:
+        except Exception:
             if i == retryTime - 1:
                 logger.error(traceback.format_exc())
                 return False

models/bot_factory.py

@@ -40,9 +40,6 @@ def create_bot(bot_type):
         from models.linkai.link_ai_bot import LinkAIBot
         return LinkAIBot()
 
-    elif bot_type == const.CLAUDEAI:
-        from models.claude.claude_ai_bot import ClaudeAIBot
-        return ClaudeAIBot()
     elif bot_type == const.CLAUDEAPI:
         from models.claudeapi.claude_api_bot import ClaudeAPIBot
         return ClaudeAPIBot()
@@ -72,5 +69,8 @@ def create_bot(bot_type):
         from models.modelscope.modelscope_bot import ModelScopeBot
         return ModelScopeBot()
 
+    elif bot_type == const.DOUBAO:
+        from models.doubao.doubao_bot import DoubaoBot
+        return DoubaoBot()
 
     raise RuntimeError

models/chatgpt/chat_gpt_bot.py

@@ -125,10 +125,100 @@ class ChatGPTBot(Bot, OpenAIImage, OpenAICompatibleBot):
             else:
                 reply = Reply(ReplyType.ERROR, retstring)
             return reply
+        elif context.type == ContextType.IMAGE:
+            logger.info("[CHATGPT] Image message received")
+            reply = self.reply_image(context)
+            return reply
         else:
             reply = Reply(ReplyType.ERROR, "Bot不支持处理{}类型的消息".format(context.type))
             return reply
 
+    def reply_image(self, context):
+        """
+        Process image message using OpenAI Vision API
+        """
+        import base64
+        import os
+        
+        try:
+            image_path = context.content
+            logger.info(f"[CHATGPT] Processing image: {image_path}")
+            
+            # Check if file exists
+            if not os.path.exists(image_path):
+                logger.error(f"[CHATGPT] Image file not found: {image_path}")
+                return Reply(ReplyType.ERROR, "图片文件不存在")
+            
+            # Read and encode image
+            with open(image_path, "rb") as f:
+                image_data = f.read()
+                image_base64 = base64.b64encode(image_data).decode("utf-8")
+            
+            # Detect image format
+            extension = os.path.splitext(image_path)[1].lower()
+            mime_type_map = {
+                ".jpg": "image/jpeg",
+                ".jpeg": "image/jpeg", 
+                ".png": "image/png",
+                ".gif": "image/gif",
+                ".webp": "image/webp"
+            }
+            mime_type = mime_type_map.get(extension, "image/jpeg")
+            
+            # Get model and API config
+            model = context.get("gpt_model") or conf().get("model", "gpt-4o")
+            api_key = context.get("openai_api_key") or conf().get("open_ai_api_key")
+            api_base = conf().get("open_ai_api_base")
+            
+            # Build vision request
+            messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": "请描述这张图片的内容"},
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": f"data:{mime_type};base64,{image_base64}"
+                            }
+                        }
+                    ]
+                }
+            ]
+            
+            logger.info(f"[CHATGPT] Calling vision API with model: {model}")
+            
+            # Call OpenAI API
+            kwargs = {
+                "model": model,
+                "messages": messages,
+                "max_tokens": 1000
+            }
+            if api_key:
+                kwargs["api_key"] = api_key
+            if api_base:
+                kwargs["api_base"] = api_base
+            
+            response = openai.ChatCompletion.create(**kwargs)
+            
+            content = response.choices[0]["message"]["content"]
+            logger.info(f"[CHATGPT] Vision API response: {content[:100]}...")
+            
+            # Clean up temp file
+            try:
+                os.remove(image_path)
+                logger.debug(f"[CHATGPT] Removed temp image file: {image_path}")
+            except Exception:
+                pass
+            
+            return Reply(ReplyType.TEXT, content)
+            
+        except Exception as e:
+            logger.error(f"[CHATGPT] Image processing error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            return Reply(ReplyType.ERROR, f"图片识别失败: {str(e)}")
+
     def reply_text(self, session: ChatGPTSession, api_key=None, args=None, retry_count=0) -> dict:
         """
         call openai's ChatCompletion to get the answer

models/claudeapi/claude_api_bot.py

@@ -383,7 +383,7 @@ class ClaudeAPIBot(Bot, OpenAIImage):
                 try:
                     error_data = json.loads(error_text)
                     error_msg = error_data.get("error", {}).get("message", error_text)
-                except:
+                except Exception:
                     error_msg = error_text or "Unknown error"
 
                 yield {

models/dashscope/dashscope_bot.py

@@ -1,5 +1,6 @@
 # encoding:utf-8
 
+import json
 from models.bot import Bot
 from models.session_manager import SessionManager
 from bridge.context import ContextType
@@ -9,26 +10,41 @@ from config import conf, load_config
 from .dashscope_session import DashscopeSession
 import os
 import dashscope
+from dashscope import MultiModalConversation
 from http import HTTPStatus
 
 
 
+# Legacy model name mapping for older dashscope SDK constants.
+# New models don't need to be added here — they use their name string directly.
 dashscope_models = {
     "qwen-turbo": dashscope.Generation.Models.qwen_turbo,
     "qwen-plus": dashscope.Generation.Models.qwen_plus,
     "qwen-max": dashscope.Generation.Models.qwen_max,
-    "qwen-bailian-v1": dashscope.Generation.Models.bailian_v1
+    "qwen-bailian-v1": dashscope.Generation.Models.bailian_v1,
 }
-# ZhipuAI对话模型API
+
+# Model name prefixes that require MultiModalConversation API instead of Generation API.
+# Qwen3.5+ series are omni models that only support MultiModalConversation.
+MULTIMODAL_MODEL_PREFIXES = ("qwen3.5-",)
+
+
+# Qwen对话模型API
 class DashscopeBot(Bot):
     def __init__(self):
         super().__init__()
         self.sessions = SessionManager(DashscopeSession, model=conf().get("model") or "qwen-plus")
         self.model_name = conf().get("model") or "qwen-plus"
         self.api_key = conf().get("dashscope_api_key")
-        os.environ["DASHSCOPE_API_KEY"] = self.api_key
+        if self.api_key:
+            os.environ["DASHSCOPE_API_KEY"] = self.api_key
         self.client = dashscope.Generation
 
+    @staticmethod
+    def _is_multimodal_model(model_name: str) -> bool:
+        """Check if the model requires MultiModalConversation API"""
+        return model_name.startswith(MULTIMODAL_MODEL_PREFIXES)
+
     def reply(self, query, context=None):
         # acquire reply content
         if context.type == ContextType.TEXT:
@@ -83,16 +99,33 @@ class DashscopeBot(Bot):
         """
         try:
             dashscope.api_key = self.api_key
-            response = self.client.call(
-                dashscope_models[self.model_name],
-                messages=session.messages,
-                result_format="message"
-            )
+            model = dashscope_models.get(self.model_name, self.model_name)
+            if self._is_multimodal_model(self.model_name):
+                mm_messages = self._prepare_messages_for_multimodal(session.messages)
+                response = MultiModalConversation.call(
+                    model=model,
+                    messages=mm_messages,
+                    result_format="message"
+                )
+            else:
+                response = self.client.call(
+                    model,
+                    messages=session.messages,
+                    result_format="message"
+                )
             if response.status_code == HTTPStatus.OK:
-                content = response.output.choices[0]["message"]["content"]
+                resp_dict = self._response_to_dict(response)
+                choice = resp_dict["output"]["choices"][0]
+                content = choice.get("message", {}).get("content", "")
+                # Multimodal models may return content as a list of blocks
+                if isinstance(content, list):
+                    content = "".join(
+                        item.get("text", "") for item in content if isinstance(item, dict)
+                    )
+                usage = resp_dict.get("usage", {})
                 return {
-                    "total_tokens": response.usage["total_tokens"],
-                    "completion_tokens": response.usage["output_tokens"],
+                    "total_tokens": usage.get("total_tokens", 0),
+                    "completion_tokens": usage.get("output_tokens", 0),
                     "content": content,
                 }
             else:
@@ -115,3 +148,481 @@ class DashscopeBot(Bot):
                 return self.reply_text(session, retry_count + 1)
             else:
                 return result
+
+    def call_with_tools(self, messages, tools=None, stream=False, **kwargs):
+        """
+        Call DashScope API with tool support for agent integration
+        
+        This method handles:
+        1. Format conversion (Claude format → DashScope format)
+        2. System prompt injection
+        3. API calling with DashScope SDK
+        4. Thinking mode support (enable_thinking for Qwen3)
+        
+        Args:
+            messages: List of messages (may be in Claude format from agent)
+            tools: List of tool definitions (may be in Claude format from agent)
+            stream: Whether to use streaming
+            **kwargs: Additional parameters (max_tokens, temperature, system, etc.)
+            
+        Returns:
+            Formatted response or generator for streaming
+        """
+        try:
+            # Convert messages from Claude format to DashScope format
+            messages = self._convert_messages_to_dashscope_format(messages)
+            
+            # Convert tools from Claude format to DashScope format
+            if tools:
+                tools = self._convert_tools_to_dashscope_format(tools)
+            
+            # Handle system prompt
+            system_prompt = kwargs.get('system')
+            if system_prompt:
+                # Add system message at the beginning if not already present
+                if not messages or messages[0].get('role') != 'system':
+                    messages = [{"role": "system", "content": system_prompt}] + messages
+                else:
+                    # Replace existing system message
+                    messages[0] = {"role": "system", "content": system_prompt}
+            
+            # Build request parameters
+            model_name = kwargs.get("model", self.model_name)
+            
+            parameters = {
+                "result_format": "message",  # Required for tool calling
+                "temperature": kwargs.get("temperature", conf().get("temperature", 0.85)),
+                "top_p": kwargs.get("top_p", conf().get("top_p", 0.8)),
+            }
+            
+            # Add max_tokens if specified
+            if kwargs.get("max_tokens"):
+                parameters["max_tokens"] = kwargs["max_tokens"]
+            
+            # Add tools if provided
+            if tools:
+                parameters["tools"] = tools
+                # Add tool_choice if specified
+                if kwargs.get("tool_choice"):
+                    parameters["tool_choice"] = kwargs["tool_choice"]
+            
+            # Add thinking parameters for Qwen3 models (disabled by default for stability)
+            if "qwen3" in model_name.lower() or "qwq" in model_name.lower():
+                # Only enable thinking mode if explicitly requested
+                enable_thinking = kwargs.get("enable_thinking", False)
+                if enable_thinking:
+                    parameters["enable_thinking"] = True
+                    
+                    # Set thinking budget if specified
+                    if kwargs.get("thinking_budget"):
+                        parameters["thinking_budget"] = kwargs["thinking_budget"]
+                    
+                    # Qwen3 requires incremental_output=true in thinking mode
+                    if stream:
+                        parameters["incremental_output"] = True
+            
+            # Always use incremental_output for streaming (for better token-by-token streaming)
+            # This is especially important for tool calling to avoid incomplete responses
+            if stream:
+                parameters["incremental_output"] = True
+            
+            # Make API call with DashScope SDK
+            if stream:
+                return self._handle_stream_response(model_name, messages, parameters)
+            else:
+                return self._handle_sync_response(model_name, messages, parameters)
+                
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"[DASHSCOPE] call_with_tools error: {error_msg}")
+            if stream:
+                def error_generator():
+                    yield {
+                        "error": True,
+                        "message": error_msg,
+                        "status_code": 500
+                    }
+                return error_generator()
+            else:
+                return {
+                    "error": True,
+                    "message": error_msg,
+                    "status_code": 500
+                }
+    
+    def _handle_sync_response(self, model_name, messages, parameters):
+        """Handle synchronous DashScope API response"""
+        try:
+            # Set API key before calling
+            dashscope.api_key = self.api_key
+            model = dashscope_models.get(model_name, model_name)
+
+            if self._is_multimodal_model(model_name):
+                messages = self._prepare_messages_for_multimodal(messages)
+                response = MultiModalConversation.call(
+                    model=model,
+                    messages=messages,
+                    **parameters
+                )
+            else:
+                response = dashscope.Generation.call(
+                    model=model,
+                    messages=messages,
+                    **parameters
+                )
+
+            if response.status_code == HTTPStatus.OK:
+                # Convert response to dict to avoid DashScope object KeyError issues
+                resp_dict = self._response_to_dict(response)
+                choice = resp_dict["output"]["choices"][0]
+                message = choice.get("message", {})
+                content = message.get("content", "")
+                # Multimodal models may return content as a list of blocks
+                if isinstance(content, list):
+                    content = "".join(
+                        item.get("text", "") for item in content if isinstance(item, dict)
+                    )
+                usage = resp_dict.get("usage", {})
+                return {
+                    "id": resp_dict.get("request_id"),
+                    "object": "chat.completion",
+                    "created": 0,
+                    "model": model_name,
+                    "choices": [{
+                        "index": 0,
+                        "message": {
+                            "role": message.get("role", "assistant"),
+                            "content": content,
+                            "tool_calls": self._convert_tool_calls_to_openai_format(
+                                message.get("tool_calls")
+                            )
+                        },
+                        "finish_reason": choice.get("finish_reason")
+                    }],
+                    "usage": {
+                        "prompt_tokens": usage.get("input_tokens", 0),
+                        "completion_tokens": usage.get("output_tokens", 0),
+                        "total_tokens": usage.get("total_tokens", 0)
+                    }
+                }
+            else:
+                logger.error(f"[DASHSCOPE] API error: {response.code} - {response.message}")
+                return {
+                    "error": True,
+                    "message": response.message,
+                    "status_code": response.status_code
+                }
+
+        except Exception as e:
+            logger.error(f"[DASHSCOPE] sync response error: {e}")
+            return {
+                "error": True,
+                "message": str(e),
+                "status_code": 500
+            }
+    
+    def _handle_stream_response(self, model_name, messages, parameters):
+        """Handle streaming DashScope API response"""
+        try:
+            # Set API key before calling
+            dashscope.api_key = self.api_key
+            model = dashscope_models.get(model_name, model_name)
+
+            if self._is_multimodal_model(model_name):
+                messages = self._prepare_messages_for_multimodal(messages)
+                responses = MultiModalConversation.call(
+                    model=model,
+                    messages=messages,
+                    stream=True,
+                    **parameters
+                )
+            else:
+                responses = dashscope.Generation.call(
+                    model=model,
+                    messages=messages,
+                    stream=True,
+                    **parameters
+                )
+            
+            # Stream chunks to caller, converting to OpenAI format
+            for response in responses:
+                # Convert to dict first to avoid DashScope proxy object KeyError
+                resp_dict = self._response_to_dict(response)
+                status_code = resp_dict.get("status_code", 200)
+
+                if status_code != HTTPStatus.OK:
+                    err_code = resp_dict.get("code", "")
+                    err_msg = resp_dict.get("message", "Unknown error")
+                    logger.error(f"[DASHSCOPE] Stream error: {err_code} - {err_msg}")
+                    yield {
+                        "error": True,
+                        "message": err_msg,
+                        "status_code": status_code
+                    }
+                    continue
+
+                choices = resp_dict.get("output", {}).get("choices", [])
+                if not choices:
+                    continue
+
+                choice = choices[0]
+                finish_reason = choice.get("finish_reason")
+                message = choice.get("message", {})
+
+                # Convert to OpenAI-compatible format
+                openai_chunk = {
+                    "id": resp_dict.get("request_id"),
+                    "object": "chat.completion.chunk",
+                    "created": 0,
+                    "model": model_name,
+                    "choices": [{
+                        "index": 0,
+                        "delta": {},
+                        "finish_reason": finish_reason
+                    }]
+                }
+
+                # Add role
+                role = message.get("role")
+                if role:
+                    openai_chunk["choices"][0]["delta"]["role"] = role
+
+                # Add reasoning_content (thinking process from models like qwen3.5)
+                reasoning_content = message.get("reasoning_content")
+                if reasoning_content:
+                    openai_chunk["choices"][0]["delta"]["reasoning_content"] = reasoning_content
+
+                # Add content (multimodal models may return list of blocks)
+                content = message.get("content")
+                if isinstance(content, list):
+                    content = "".join(
+                        item.get("text", "") for item in content if isinstance(item, dict)
+                    )
+                if content:
+                    openai_chunk["choices"][0]["delta"]["content"] = content
+
+                # Add tool_calls
+                tool_calls = message.get("tool_calls")
+                if tool_calls:
+                    openai_chunk["choices"][0]["delta"]["tool_calls"] = self._convert_tool_calls_to_openai_format(tool_calls)
+
+                yield openai_chunk
+
+        except Exception as e:
+            logger.error(f"[DASHSCOPE] stream response error: {e}", exc_info=True)
+            yield {
+                "error": True,
+                "message": str(e),
+                "status_code": 500
+            }
+    
+    @staticmethod
+    def _response_to_dict(response) -> dict:
+        """
+        Convert DashScope response object to a plain dict.
+
+        DashScope SDK wraps responses in proxy objects whose __getattr__
+        delegates to __getitem__, raising KeyError (not AttributeError)
+        when an attribute is missing.  Standard hasattr / getattr only
+        catch AttributeError, so we must use try-except everywhere.
+        """
+        _SENTINEL = object()
+
+        def _safe_getattr(obj, name, default=_SENTINEL):
+            """getattr that also catches KeyError from DashScope proxy objects."""
+            try:
+                return getattr(obj, name)
+            except (AttributeError, KeyError, TypeError):
+                return default
+
+        def _has_attr(obj, name):
+            return _safe_getattr(obj, name) is not _SENTINEL
+
+        def _to_dict(obj):
+            if isinstance(obj, (str, int, float, bool, type(None))):
+                return obj
+            if isinstance(obj, dict):
+                return {k: _to_dict(v) for k, v in obj.items()}
+            if isinstance(obj, (list, tuple)):
+                return [_to_dict(i) for i in obj]
+            # DashScope response objects behave like dicts (have .keys())
+            if _has_attr(obj, "keys"):
+                try:
+                    return {k: _to_dict(obj[k]) for k in obj.keys()}
+                except Exception:
+                    pass
+            return obj
+
+        result = {}
+        # Extract known top-level fields safely
+        for attr in ("request_id", "status_code", "code", "message", "output", "usage"):
+            val = _safe_getattr(response, attr)
+            if val is _SENTINEL:
+                try:
+                    val = response[attr]
+                except (KeyError, TypeError, IndexError):
+                    continue
+            result[attr] = _to_dict(val)
+        return result
+
+    def _convert_tools_to_dashscope_format(self, tools):
+        """
+        Convert tools from Claude format to DashScope format
+        
+        Claude format: {name, description, input_schema}
+        DashScope format: {type: "function", function: {name, description, parameters}}
+        """
+        if not tools:
+            return None
+        
+        dashscope_tools = []
+        for tool in tools:
+            # Check if already in DashScope/OpenAI format
+            if 'type' in tool and tool['type'] == 'function':
+                dashscope_tools.append(tool)
+            else:
+                # Convert from Claude format
+                dashscope_tools.append({
+                    "type": "function",
+                    "function": {
+                        "name": tool.get("name"),
+                        "description": tool.get("description"),
+                        "parameters": tool.get("input_schema", {})
+                    }
+                })
+        
+        return dashscope_tools
+    
+    @staticmethod
+    def _prepare_messages_for_multimodal(messages: list) -> list:
+        """
+        Ensure messages are compatible with MultiModalConversation API.
+
+        MultiModalConversation._preprocess_messages iterates every message
+        with ``content = message["content"]; for elem in content: ...``,
+        which means:
+          1. Every message MUST have a 'content' key.
+          2. 'content' MUST be an iterable (list), not a plain string.
+             The expected format is [{"text": "..."}, ...].
+
+        Meanwhile the DashScope API requires role='tool' messages to follow
+        assistant tool_calls, so we must NOT convert them to role='user'.
+        We just ensure they have a list-typed 'content'.
+        """
+        result = []
+        for msg in messages:
+            msg = dict(msg)  # shallow copy
+
+            # Normalize content to list format [{"text": "..."}]
+            content = msg.get("content")
+            if content is None or (isinstance(content, str) and content == ""):
+                msg["content"] = [{"text": ""}]
+            elif isinstance(content, str):
+                msg["content"] = [{"text": content}]
+            # If content is already a list, keep as-is (already in multimodal format)
+
+            result.append(msg)
+        return result
+
+    def _convert_messages_to_dashscope_format(self, messages):
+        """
+        Convert messages from Claude format to DashScope format
+        
+        Claude uses content blocks with types like 'tool_use', 'tool_result'
+        DashScope uses 'tool_calls' in assistant messages and 'tool' role for results
+        """
+        if not messages:
+            return []
+        
+        dashscope_messages = []
+        
+        for msg in messages:
+            role = msg.get("role")
+            content = msg.get("content")
+            
+            # Handle string content (already in correct format)
+            if isinstance(content, str):
+                dashscope_messages.append(msg)
+                continue
+            
+            # Handle list content (Claude format with content blocks)
+            if isinstance(content, list):
+                # Check if this is a tool result message (user role with tool_result blocks)
+                if role == "user" and any(block.get("type") == "tool_result" for block in content):
+                    # Convert each tool_result block to a separate tool message
+                    for block in content:
+                        if block.get("type") == "tool_result":
+                            dashscope_messages.append({
+                                "role": "tool",
+                                "content": block.get("content", ""),
+                                "tool_call_id": block.get("tool_use_id")  # DashScope uses 'tool_call_id'
+                            })
+                
+                # Check if this is an assistant message with tool_use blocks
+                elif role == "assistant":
+                    # Separate text content and tool_use blocks
+                    text_parts = []
+                    tool_calls = []
+                    
+                    for block in content:
+                        if block.get("type") == "text":
+                            text_parts.append(block.get("text", ""))
+                        elif block.get("type") == "tool_use":
+                            tool_calls.append({
+                                "id": block.get("id"),
+                                "type": "function",
+                                "function": {
+                                    "name": block.get("name"),
+                                    "arguments": json.dumps(block.get("input", {}))
+                                }
+                            })
+                    
+                    # Build DashScope format assistant message
+                    dashscope_msg = {
+                        "role": "assistant"
+                    }
+                    
+                    # Add content only if there is actual text
+                    # DashScope API: when tool_calls exist, content should be None or omitted if empty
+                    if text_parts:
+                        dashscope_msg["content"] = " ".join(text_parts)
+                    elif not tool_calls:
+                        # If no tool_calls and no text, set empty string (rare case)
+                        dashscope_msg["content"] = ""
+                    # If there are tool_calls but no text, don't set content field at all
+                    
+                    if tool_calls:
+                        dashscope_msg["tool_calls"] = tool_calls
+                    
+                    dashscope_messages.append(dashscope_msg)
+                else:
+                    # Other list content, keep as is
+                    dashscope_messages.append(msg)
+            else:
+                # Other formats, keep as is
+                dashscope_messages.append(msg)
+        
+        return dashscope_messages
+    
+    def _convert_tool_calls_to_openai_format(self, tool_calls):
+        """Convert DashScope tool_calls to OpenAI format"""
+        if not tool_calls:
+            return None
+        
+        openai_tool_calls = []
+        for tool_call in tool_calls:
+            # DashScope format is already similar to OpenAI
+            if isinstance(tool_call, dict):
+                openai_tool_calls.append(tool_call)
+            else:
+                # Handle object format
+                openai_tool_calls.append({
+                    "id": getattr(tool_call, 'id', None),
+                    "type": "function",
+                    "function": {
+                        "name": tool_call.function.name,
+                        "arguments": tool_call.function.arguments
+                    }
+                })
+        
+        return openai_tool_calls

models/doubao/doubao_bot.py

@@ -0,0 +1,520 @@
+# encoding:utf-8
+
+import json
+import time
+
+import requests
+from models.bot import Bot
+from models.session_manager import SessionManager
+from bridge.context import ContextType
+from bridge.reply import Reply, ReplyType
+from common.log import logger
+from config import conf, load_config
+from .doubao_session import DoubaoSession
+
+
+# Doubao (火山方舟 / Volcengine Ark) API Bot
+class DoubaoBot(Bot):
+    def __init__(self):
+        super().__init__()
+        self.sessions = SessionManager(DoubaoSession, model=conf().get("model") or "doubao-seed-2-0-pro-260215")
+        model = conf().get("model") or "doubao-seed-2-0-pro-260215"
+        self.args = {
+            "model": model,
+            "temperature": conf().get("temperature", 0.8),
+            "top_p": conf().get("top_p", 1.0),
+        }
+        self.api_key = conf().get("ark_api_key")
+        self.base_url = conf().get("ark_base_url", "https://ark.cn-beijing.volces.com/api/v3")
+        # Ensure base_url does not end with /chat/completions
+        if self.base_url.endswith("/chat/completions"):
+            self.base_url = self.base_url.rsplit("/chat/completions", 1)[0]
+        if self.base_url.endswith("/"):
+            self.base_url = self.base_url.rstrip("/")
+
+    def reply(self, query, context=None):
+        # acquire reply content
+        if context.type == ContextType.TEXT:
+            logger.info("[DOUBAO] query={}".format(query))
+
+            session_id = context["session_id"]
+            reply = None
+            clear_memory_commands = conf().get("clear_memory_commands", ["#清除记忆"])
+            if query in clear_memory_commands:
+                self.sessions.clear_session(session_id)
+                reply = Reply(ReplyType.INFO, "记忆已清除")
+            elif query == "#清除所有":
+                self.sessions.clear_all_session()
+                reply = Reply(ReplyType.INFO, "所有人记忆已清除")
+            elif query == "#更新配置":
+                load_config()
+                reply = Reply(ReplyType.INFO, "配置已更新")
+            if reply:
+                return reply
+            session = self.sessions.session_query(query, session_id)
+            logger.debug("[DOUBAO] session query={}".format(session.messages))
+
+            model = context.get("doubao_model")
+            new_args = self.args.copy()
+            if model:
+                new_args["model"] = model
+
+            reply_content = self.reply_text(session, args=new_args)
+            logger.debug(
+                "[DOUBAO] new_query={}, session_id={}, reply_cont={}, completion_tokens={}".format(
+                    session.messages,
+                    session_id,
+                    reply_content["content"],
+                    reply_content["completion_tokens"],
+                )
+            )
+            if reply_content["completion_tokens"] == 0 and len(reply_content["content"]) > 0:
+                reply = Reply(ReplyType.ERROR, reply_content["content"])
+            elif reply_content["completion_tokens"] > 0:
+                self.sessions.session_reply(reply_content["content"], session_id, reply_content["total_tokens"])
+                reply = Reply(ReplyType.TEXT, reply_content["content"])
+            else:
+                reply = Reply(ReplyType.ERROR, reply_content["content"])
+                logger.debug("[DOUBAO] reply {} used 0 tokens.".format(reply_content))
+            return reply
+        else:
+            reply = Reply(ReplyType.ERROR, "Bot不支持处理{}类型的消息".format(context.type))
+            return reply
+
+    def reply_text(self, session: DoubaoSession, args=None, retry_count: int = 0) -> dict:
+        """
+        Call Doubao chat completion API to get the answer
+        :param session: a conversation session
+        :param args: model args
+        :param retry_count: retry count
+        :return: {}
+        """
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": "Bearer " + self.api_key
+            }
+            body = args.copy()
+            body["messages"] = session.messages
+            # Disable thinking by default for better efficiency
+            body["thinking"] = {"type": "disabled"}
+            res = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=headers,
+                json=body
+            )
+            if res.status_code == 200:
+                response = res.json()
+                return {
+                    "total_tokens": response["usage"]["total_tokens"],
+                    "completion_tokens": response["usage"]["completion_tokens"],
+                    "content": response["choices"][0]["message"]["content"]
+                }
+            else:
+                response = res.json()
+                error = response.get("error", {})
+                logger.error(f"[DOUBAO] chat failed, status_code={res.status_code}, "
+                             f"msg={error.get('message')}, type={error.get('type')}")
+
+                result = {"completion_tokens": 0, "content": "提问太快啦，请休息一下再问我吧"}
+                need_retry = False
+                if res.status_code >= 500:
+                    logger.warn(f"[DOUBAO] do retry, times={retry_count}")
+                    need_retry = retry_count < 2
+                elif res.status_code == 401:
+                    result["content"] = "授权失败，请检查API Key是否正确"
+                elif res.status_code == 429:
+                    result["content"] = "请求过于频繁，请稍后再试"
+                    need_retry = retry_count < 2
+                else:
+                    need_retry = False
+
+                if need_retry:
+                    time.sleep(3)
+                    return self.reply_text(session, args, retry_count + 1)
+                else:
+                    return result
+        except Exception as e:
+            logger.exception(e)
+            need_retry = retry_count < 2
+            result = {"completion_tokens": 0, "content": "我现在有点累了，等会再来吧"}
+            if need_retry:
+                return self.reply_text(session, args, retry_count + 1)
+            else:
+                return result
+
+    # ==================== Agent mode support ====================
+
+    def call_with_tools(self, messages, tools=None, stream: bool = False, **kwargs):
+        """
+        Call Doubao API with tool support for agent integration.
+
+        This method handles:
+        1. Format conversion (Claude format -> OpenAI format)
+        2. System prompt injection
+        3. Streaming SSE response with tool_calls
+        4. Thinking (reasoning) is disabled by default for efficiency
+
+        Args:
+            messages: List of messages (may be in Claude format from agent)
+            tools: List of tool definitions (may be in Claude format from agent)
+            stream: Whether to use streaming
+            **kwargs: Additional parameters (max_tokens, temperature, system, model, etc.)
+
+        Returns:
+            Generator yielding OpenAI-format chunks (for streaming)
+        """
+        try:
+            # Convert messages from Claude format to OpenAI format
+            converted_messages = self._convert_messages_to_openai_format(messages)
+
+            # Inject system prompt if provided
+            system_prompt = kwargs.pop("system", None)
+            if system_prompt:
+                if not converted_messages or converted_messages[0].get("role") != "system":
+                    converted_messages.insert(0, {"role": "system", "content": system_prompt})
+                else:
+                    converted_messages[0] = {"role": "system", "content": system_prompt}
+
+            # Convert tools from Claude format to OpenAI format
+            converted_tools = None
+            if tools:
+                converted_tools = self._convert_tools_to_openai_format(tools)
+
+            # Resolve model / temperature
+            model = kwargs.pop("model", None) or self.args["model"]
+            max_tokens = kwargs.pop("max_tokens", None)
+            # Don't pop temperature, just ignore it - let API use default
+            kwargs.pop("temperature", None)
+
+            # Build request body (omit temperature, let the API use its own default)
+            request_body = {
+                "model": model,
+                "messages": converted_messages,
+                "stream": stream,
+            }
+            if max_tokens is not None:
+                request_body["max_tokens"] = max_tokens
+
+            # Add tools
+            if converted_tools:
+                request_body["tools"] = converted_tools
+                request_body["tool_choice"] = "auto"
+
+            # Explicitly disable thinking to avoid reasoning_content issues
+            # in multi-turn tool calls
+            request_body["thinking"] = {"type": "disabled"}
+
+            logger.debug(f"[DOUBAO] API call: model={model}, "
+                         f"tools={len(converted_tools) if converted_tools else 0}, stream={stream}")
+
+            if stream:
+                return self._handle_stream_response(request_body)
+            else:
+                return self._handle_sync_response(request_body)
+
+        except Exception as e:
+            logger.error(f"[DOUBAO] call_with_tools error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+
+            def error_generator():
+                yield {"error": True, "message": str(e), "status_code": 500}
+            return error_generator()
+
+    # -------------------- streaming --------------------
+
+    def _handle_stream_response(self, request_body: dict):
+        """Handle streaming SSE response from Doubao API and yield OpenAI-format chunks."""
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}"
+            }
+
+            url = f"{self.base_url}/chat/completions"
+            response = requests.post(url, headers=headers, json=request_body, stream=True, timeout=120)
+
+            if response.status_code != 200:
+                error_msg = response.text
+                logger.error(f"[DOUBAO] API error: status={response.status_code}, msg={error_msg}")
+                yield {"error": True, "message": error_msg, "status_code": response.status_code}
+                return
+
+            current_tool_calls = {}
+            finish_reason = None
+
+            for line in response.iter_lines():
+                if not line:
+                    continue
+
+                line = line.decode("utf-8")
+                if not line.startswith("data: "):
+                    continue
+
+                data_str = line[6:]  # Remove "data: " prefix
+                if data_str.strip() == "[DONE]":
+                    break
+
+                try:
+                    chunk = json.loads(data_str)
+                except json.JSONDecodeError as e:
+                    logger.warning(f"[DOUBAO] JSON decode error: {e}, data: {data_str[:200]}")
+                    continue
+
+                # Check for error in chunk
+                if chunk.get("error"):
+                    error_data = chunk["error"]
+                    error_msg = error_data.get("message", "Unknown error") if isinstance(error_data, dict) else str(error_data)
+                    logger.error(f"[DOUBAO] stream error: {error_msg}")
+                    yield {"error": True, "message": error_msg, "status_code": 500}
+                    return
+
+                if not chunk.get("choices"):
+                    continue
+
+                choice = chunk["choices"][0]
+                delta = choice.get("delta", {})
+
+                # Skip reasoning_content (thinking) - don't log or forward
+                if delta.get("reasoning_content"):
+                    continue
+
+                # Handle text content
+                if "content" in delta and delta["content"]:
+                    yield {
+                        "choices": [{
+                            "index": 0,
+                            "delta": {
+                                "role": "assistant",
+                                "content": delta["content"]
+                            }
+                        }]
+                    }
+
+                # Handle tool_calls (streamed incrementally)
+                if "tool_calls" in delta:
+                    for tool_call_chunk in delta["tool_calls"]:
+                        index = tool_call_chunk.get("index", 0)
+                        if index not in current_tool_calls:
+                            current_tool_calls[index] = {
+                                "id": tool_call_chunk.get("id", ""),
+                                "type": "tool_use",
+                                "name": tool_call_chunk.get("function", {}).get("name", ""),
+                                "input": ""
+                            }
+
+                        # Accumulate arguments
+                        if "function" in tool_call_chunk and "arguments" in tool_call_chunk["function"]:
+                            current_tool_calls[index]["input"] += tool_call_chunk["function"]["arguments"]
+
+                        # Yield OpenAI-format tool call delta
+                        yield {
+                            "choices": [{
+                                "index": 0,
+                                "delta": {
+                                    "tool_calls": [tool_call_chunk]
+                                }
+                            }]
+                        }
+
+                # Capture finish_reason
+                if choice.get("finish_reason"):
+                    finish_reason = choice["finish_reason"]
+
+            # Final chunk with finish_reason
+            yield {
+                "choices": [{
+                    "index": 0,
+                    "delta": {},
+                    "finish_reason": finish_reason
+                }]
+            }
+
+        except requests.exceptions.Timeout:
+            logger.error("[DOUBAO] Request timeout")
+            yield {"error": True, "message": "Request timeout", "status_code": 500}
+        except Exception as e:
+            logger.error(f"[DOUBAO] stream response error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            yield {"error": True, "message": str(e), "status_code": 500}
+
+    # -------------------- sync --------------------
+
+    def _handle_sync_response(self, request_body: dict):
+        """Handle synchronous API response and yield a single result dict."""
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}"
+            }
+
+            request_body.pop("stream", None)
+            url = f"{self.base_url}/chat/completions"
+            response = requests.post(url, headers=headers, json=request_body, timeout=120)
+
+            if response.status_code != 200:
+                error_msg = response.text
+                logger.error(f"[DOUBAO] API error: status={response.status_code}, msg={error_msg}")
+                yield {"error": True, "message": error_msg, "status_code": response.status_code}
+                return
+
+            result = response.json()
+            message = result["choices"][0]["message"]
+            finish_reason = result["choices"][0]["finish_reason"]
+
+            response_data = {"role": "assistant", "content": []}
+
+            # Add text content
+            if message.get("content"):
+                response_data["content"].append({
+                    "type": "text",
+                    "text": message["content"]
+                })
+
+            # Add tool calls
+            if message.get("tool_calls"):
+                for tool_call in message["tool_calls"]:
+                    response_data["content"].append({
+                        "type": "tool_use",
+                        "id": tool_call["id"],
+                        "name": tool_call["function"]["name"],
+                        "input": json.loads(tool_call["function"]["arguments"])
+                    })
+
+            # Map finish_reason
+            if finish_reason == "tool_calls":
+                response_data["stop_reason"] = "tool_use"
+            elif finish_reason == "stop":
+                response_data["stop_reason"] = "end_turn"
+            else:
+                response_data["stop_reason"] = finish_reason
+
+            yield response_data
+
+        except requests.exceptions.Timeout:
+            logger.error("[DOUBAO] Request timeout")
+            yield {"error": True, "message": "Request timeout", "status_code": 500}
+        except Exception as e:
+            logger.error(f"[DOUBAO] sync response error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            yield {"error": True, "message": str(e), "status_code": 500}
+
+    # -------------------- format conversion --------------------
+
+    def _convert_messages_to_openai_format(self, messages):
+        """
+        Convert messages from Claude format to OpenAI format.
+
+        Claude format uses content blocks: tool_use / tool_result / text
+        OpenAI format uses tool_calls in assistant, role=tool for results
+        """
+        if not messages:
+            return []
+
+        converted = []
+
+        for msg in messages:
+            role = msg.get("role")
+            content = msg.get("content")
+
+            # Already a simple string - pass through
+            if isinstance(content, str):
+                converted.append(msg)
+                continue
+
+            if not isinstance(content, list):
+                converted.append(msg)
+                continue
+
+            if role == "user":
+                text_parts = []
+                tool_results = []
+
+                for block in content:
+                    if not isinstance(block, dict):
+                        continue
+                    if block.get("type") == "text":
+                        text_parts.append(block.get("text", ""))
+                    elif block.get("type") == "tool_result":
+                        tool_call_id = block.get("tool_use_id") or ""
+                        result_content = block.get("content", "")
+                        if not isinstance(result_content, str):
+                            result_content = json.dumps(result_content, ensure_ascii=False)
+                        tool_results.append({
+                            "role": "tool",
+                            "tool_call_id": tool_call_id,
+                            "content": result_content
+                        })
+
+                # Tool results first (must come right after assistant with tool_calls)
+                for tr in tool_results:
+                    converted.append(tr)
+
+                if text_parts:
+                    converted.append({"role": "user", "content": "\n".join(text_parts)})
+
+            elif role == "assistant":
+                openai_msg = {"role": "assistant"}
+                text_parts = []
+                tool_calls = []
+
+                for block in content:
+                    if not isinstance(block, dict):
+                        continue
+                    if block.get("type") == "text":
+                        text_parts.append(block.get("text", ""))
+                    elif block.get("type") == "tool_use":
+                        tool_calls.append({
+                            "id": block.get("id"),
+                            "type": "function",
+                            "function": {
+                                "name": block.get("name"),
+                                "arguments": json.dumps(block.get("input", {}))
+                            }
+                        })
+
+                if text_parts:
+                    openai_msg["content"] = "\n".join(text_parts)
+                elif not tool_calls:
+                    openai_msg["content"] = ""
+
+                if tool_calls:
+                    openai_msg["tool_calls"] = tool_calls
+                    if not text_parts:
+                        openai_msg["content"] = None
+
+                converted.append(openai_msg)
+            else:
+                converted.append(msg)
+
+        return converted
+
+    def _convert_tools_to_openai_format(self, tools):
+        """
+        Convert tools from Claude format to OpenAI format.
+
+        Claude: {name, description, input_schema}
+        OpenAI: {type: "function", function: {name, description, parameters}}
+        """
+        if not tools:
+            return None
+
+        converted = []
+        for tool in tools:
+            # Already in OpenAI format
+            if "type" in tool and tool["type"] == "function":
+                converted.append(tool)
+            else:
+                converted.append({
+                    "type": "function",
+                    "function": {
+                        "name": tool.get("name"),
+                        "description": tool.get("description"),
+                        "parameters": tool.get("input_schema", {})
+                    }
+                })
+
+        return converted

models/doubao/doubao_session.py

@@ -0,0 +1,51 @@
+from models.session_manager import Session
+from common.log import logger
+
+
+class DoubaoSession(Session):
+    def __init__(self, session_id, system_prompt=None, model="doubao-seed-2-0-pro-260215"):
+        super().__init__(session_id, system_prompt)
+        self.model = model
+        self.reset()
+
+    def discard_exceeding(self, max_tokens, cur_tokens=None):
+        precise = True
+        try:
+            cur_tokens = self.calc_tokens()
+        except Exception as e:
+            precise = False
+            if cur_tokens is None:
+                raise e
+            logger.debug("Exception when counting tokens precisely for query: {}".format(e))
+        while cur_tokens > max_tokens:
+            if len(self.messages) > 2:
+                self.messages.pop(1)
+            elif len(self.messages) == 2 and self.messages[1]["role"] == "assistant":
+                self.messages.pop(1)
+                if precise:
+                    cur_tokens = self.calc_tokens()
+                else:
+                    cur_tokens = cur_tokens - max_tokens
+                break
+            elif len(self.messages) == 2 and self.messages[1]["role"] == "user":
+                logger.warn("user message exceed max_tokens. total_tokens={}".format(cur_tokens))
+                break
+            else:
+                logger.debug("max_tokens={}, total_tokens={}, len(messages)={}".format(
+                    max_tokens, cur_tokens, len(self.messages)))
+                break
+            if precise:
+                cur_tokens = self.calc_tokens()
+            else:
+                cur_tokens = cur_tokens - max_tokens
+        return cur_tokens
+
+    def calc_tokens(self):
+        return num_tokens_from_messages(self.messages, self.model)
+
+
+def num_tokens_from_messages(messages, model):
+    tokens = 0
+    for msg in messages:
+        tokens += len(msg["content"])
+    return tokens

models/gemini/google_gemini_bot.py

@@ -6,11 +6,14 @@ Google gemini bot
 """
 # encoding:utf-8
 
+import base64
 import json
+import mimetypes
+import os
+import re
 import time
 import requests
 from models.bot import Bot
-import google.generativeai as genai
 from models.session_manager import SessionManager
 from bridge.context import ContextType, Context
 from bridge.reply import Reply, ReplyType
@@ -18,7 +21,6 @@ from common.log import logger
 from config import conf
 from models.chatgpt.chat_gpt_session import ChatGPTSession
 from models.baidu.baidu_wenxin_session import BaiduWenxinSession
-from google.generativeai.types import HarmCategory, HarmBlockThreshold
 
 
 # OpenAI对话模型API (可用)
@@ -43,6 +45,7 @@ class GoogleGeminiBot(Bot):
             self.api_base = "https://generativelanguage.googleapis.com"
 
     def reply(self, query, context: Context = None) -> Reply:
+        session_id = None
         try:
             if context.type != ContextType.TEXT:
                 logger.warn(f"[Gemini] Unsupported message type, type={context.type}")
@@ -50,43 +53,47 @@ class GoogleGeminiBot(Bot):
             logger.info(f"[Gemini] query={query}")
             session_id = context["session_id"]
             session = self.sessions.session_query(query, session_id)
-            gemini_messages = self._convert_to_gemini_messages(self.filter_messages(session.messages))
-            logger.debug(f"[Gemini] messages={gemini_messages}")
-            genai.configure(api_key=self.api_key)
-            model = genai.GenerativeModel(self.model)
-            
-            # 添加安全设置
-            safety_settings = {
-                HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
-                HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
-                HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
-                HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
-            }
-            
-            # 生成回复，包含安全设置
-            response = model.generate_content(
-                gemini_messages,
-                safety_settings=safety_settings
+            filtered_messages = self.filter_messages(session.messages)
+            logger.debug(f"[Gemini] messages={filtered_messages}")
+
+            response = self.call_with_tools(
+                messages=filtered_messages,
+                tools=None,
+                stream=False,
+                model=self.model
             )
-            if response.candidates and response.candidates[0].content:
-                reply_text = response.candidates[0].content.parts[0].text
-                logger.info(f"[Gemini] reply={reply_text}")
-                self.sessions.session_reply(reply_text, session_id)
-                return Reply(ReplyType.TEXT, reply_text)
-            else:
-                # 没有有效响应内容，可能内容被屏蔽，输出安全评分
-                logger.warning("[Gemini] No valid response generated. Checking safety ratings.")
-                if hasattr(response, 'candidates') and response.candidates:
-                    for rating in response.candidates[0].safety_ratings:
-                        logger.warning(f"Safety rating: {rating.category} - {rating.probability}")
-                error_message = "No valid response generated due to safety constraints."
+
+            if isinstance(response, dict) and response.get("error"):
+                error_message = response.get("message", "Failed to invoke [Gemini] api!")
+                logger.error(f"[Gemini] API error: {error_message}")
                 self.sessions.session_reply(error_message, session_id)
                 return Reply(ReplyType.ERROR, error_message)
+
+            choices = response.get("choices", []) if isinstance(response, dict) else []
+            if choices and choices[0].get("message"):
+                reply_text = choices[0]["message"].get("content")
+                if reply_text:
+                    logger.info(f"[Gemini] reply={reply_text}")
+                    self.sessions.session_reply(reply_text, session_id)
+                    return Reply(ReplyType.TEXT, reply_text)
+
+            logger.warning("[Gemini] No valid response generated. Checking safety ratings.")
+            safety_ratings = response.get("safety_ratings", []) if isinstance(response, dict) else []
+            if safety_ratings:
+                for rating in safety_ratings:
+                    category = rating.get("category", "UNKNOWN")
+                    probability = rating.get("probability", "UNKNOWN")
+                    logger.warning(f"[Gemini] Safety rating: {category} - {probability}")
+
+            error_message = "No valid response generated due to safety constraints."
+            self.sessions.session_reply(error_message, session_id)
+            return Reply(ReplyType.ERROR, error_message)
                     
         except Exception as e:
             logger.error(f"[Gemini] Error generating response: {str(e)}", exc_info=True)
             error_message = "Failed to invoke [Gemini] api!"
-            self.sessions.session_reply(error_message, session_id)
+            if session_id:
+                self.sessions.session_reply(error_message, session_id)
             return Reply(ReplyType.ERROR, error_message)
             
     def _convert_to_gemini_messages(self, messages: list):
@@ -127,6 +134,93 @@ class GoogleGeminiBot(Bot):
                 turn = "user"
         return res
 
+    @staticmethod
+    def _extract_image_paths_from_text(content: str):
+        if not isinstance(content, str):
+            return "", []
+        pattern = r"\[图片:\s*([^\]]+)\]"
+        image_paths = [m.strip().strip("'\"") for m in re.findall(pattern, content) if m.strip()]
+        cleaned_text = re.sub(pattern, "", content)
+        cleaned_text = re.sub(r"\n{3,}", "\n\n", cleaned_text).strip()
+        return cleaned_text, image_paths
+
+    @staticmethod
+    def _build_image_inline_part(image_path: str):
+        if not image_path:
+            return None
+        try:
+            if image_path.startswith("file://"):
+                image_path = image_path[7:]
+
+            image_path = os.path.expanduser(image_path)
+            if not os.path.exists(image_path):
+                logger.warning(f"[Gemini] Image file not found: {image_path}")
+                return None
+
+            with open(image_path, "rb") as f:
+                image_bytes = f.read()
+
+            mime_type = mimetypes.guess_type(image_path)[0] or "image/png"
+            if not mime_type.startswith("image/"):
+                mime_type = "image/png"
+
+            return {
+                "inlineData": {
+                    "mimeType": mime_type,
+                    "data": base64.b64encode(image_bytes).decode("utf-8")
+                }
+            }
+        except Exception as e:
+            logger.warning(f"[Gemini] Failed to build inline image part from path={image_path}, err={e}")
+            return None
+
+    @staticmethod
+    def _build_inline_part_from_image_url(image_url):
+        if not image_url:
+            return None
+
+        if isinstance(image_url, dict):
+            image_url = image_url.get("url")
+        if not image_url or not isinstance(image_url, str):
+            return None
+
+        if image_url.startswith("data:"):
+            match = re.match(r"^data:([^;]+);base64,(.+)$", image_url, re.DOTALL)
+            if not match:
+                logger.warning("[Gemini] Invalid data URL for image block")
+                return None
+            return {
+                "inlineData": {
+                    "mimeType": match.group(1),
+                    "data": match.group(2).strip()
+                }
+            }
+
+        if image_url.startswith("file://") or os.path.exists(os.path.expanduser(image_url)):
+            return GoogleGeminiBot._build_image_inline_part(image_url)
+
+        if image_url.startswith("http://") or image_url.startswith("https://"):
+            try:
+                response = requests.get(image_url, timeout=20)
+                if response.status_code != 200:
+                    logger.warning(f"[Gemini] Failed to fetch remote image: status={response.status_code}, url={image_url}")
+                    return None
+                mime_type = response.headers.get("Content-Type", "image/png").split(";")[0].strip()
+                if not mime_type.startswith("image/"):
+                    mime_type = "image/png"
+                return {
+                    "inlineData": {
+                        "mimeType": mime_type,
+                        "data": base64.b64encode(response.content).decode("utf-8")
+                    }
+                }
+            except Exception as e:
+                logger.warning(f"[Gemini] Failed to download remote image: url={image_url}, err={e}")
+                return None
+
+        logger.warning(f"[Gemini] Unsupported image URL format: {image_url[:120]}")
+        return None
+
     def call_with_tools(self, messages, tools=None, stream=False, **kwargs):
         """
         Call Gemini API with tool support using REST API (following official docs)
@@ -145,6 +239,15 @@ class GoogleGeminiBot(Bot):
             
             # Build REST API payload
             payload = {"contents": []}
+            inline_image_count = 0
+
+            # Keep legacy behavior: disable Gemini safety blocking like old SDK path.
+            payload["safetySettings"] = [
+                {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+                {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+                {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+                {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+            ]
             
             # Extract and set system instruction
             system_prompt = kwargs.get("system", "")
@@ -174,8 +277,19 @@ class GoogleGeminiBot(Bot):
                 parts = []
                 
                 if isinstance(content, str):
-                    # Simple text content
-                    parts.append({"text": content})
+                    # Text with optional [图片: /path/to/file] markers
+                    cleaned_text, image_paths = self._extract_image_paths_from_text(content)
+                    if cleaned_text:
+                        parts.append({"text": cleaned_text})
+                    image_added = False
+                    for image_path in image_paths:
+                        image_part = self._build_image_inline_part(image_path)
+                        if image_part:
+                            parts.append(image_part)
+                            image_added = True
+                            inline_image_count += 1
+                    if not cleaned_text and not image_added and content:
+                        parts.append({"text": content})
                     
                 elif isinstance(content, list):
                     # List of content blocks (Claude format)
@@ -188,8 +302,39 @@ class GoogleGeminiBot(Bot):
                         block_type = block.get("type")
                         
                         if block_type == "text":
-                            # Text block
-                            parts.append({"text": block.get("text", "")})
+                            # Text block with optional image markers
+                            block_text = block.get("text", "")
+                            cleaned_text, image_paths = self._extract_image_paths_from_text(block_text)
+                            if cleaned_text:
+                                parts.append({"text": cleaned_text})
+                            for image_path in image_paths:
+                                image_part = self._build_image_inline_part(image_path)
+                                if image_part:
+                                    parts.append(image_part)
+
+                        elif block_type in ["image", "image_url"]:
+                            # OpenAI format: {"type":"image_url","image_url":{"url":"..."}}
+                            # Claude format: {"type":"image","source":{"type":"base64","media_type":"...","data":"..."}}
+                            image_part = None
+                            if block_type == "image":
+                                source = block.get("source", {})
+                                if isinstance(source, dict) and source.get("type") == "base64" and source.get("data"):
+                                    image_part = {
+                                        "inlineData": {
+                                            "mimeType": source.get("media_type", "image/png"),
+                                            "data": source.get("data")
+                                        }
+                                    }
+                                elif block.get("image_url"):
+                                    image_part = self._build_inline_part_from_image_url(block.get("image_url"))
+                            else:
+                                image_part = self._build_inline_part_from_image_url(block.get("image_url"))
+
+                            if image_part:
+                                parts.append(image_part)
+                                inline_image_count += 1
+                            else:
+                                logger.warning(f"[Gemini] Skip invalid image block: {str(block)[:200]}")
                             
                         elif block_type == "tool_result":
                             # Convert Claude tool_result to Gemini functionResponse
@@ -202,7 +347,7 @@ class GoogleGeminiBot(Bot):
                                     tool_result_data = json.loads(tool_content)
                                 else:
                                     tool_result_data = tool_content
-                            except:
+                            except Exception:
                                 tool_result_data = {"result": tool_content}
                             
                             # Find the tool name from previous messages
@@ -237,6 +382,9 @@ class GoogleGeminiBot(Bot):
                         "role": gemini_role,
                         "parts": parts
                     })
+
+            if inline_image_count > 0:
+                logger.info(f"[Gemini] Multimodal request includes {inline_image_count} image part(s)")
             
             # Generation config
             gen_config = {}
@@ -363,15 +511,18 @@ class GoogleGeminiBot(Bot):
             candidates = data.get("candidates", [])
             if not candidates:
                 logger.warning("[Gemini] No candidates in response")
+                prompt_feedback = data.get("promptFeedback", {})
                 return {
                     "error": True,
                     "message": "No candidates in response",
-                    "status_code": 500
+                    "status_code": 500,
+                    "safety_ratings": prompt_feedback.get("safetyRatings", [])
                 }
             
             candidate = candidates[0]
             content = candidate.get("content", {})
             parts = content.get("parts", [])
+            safety_ratings = candidate.get("safetyRatings", [])
             
             logger.debug(f"[Gemini] Candidate parts count: {len(parts)}")
             
@@ -419,7 +570,8 @@ class GoogleGeminiBot(Bot):
                     "message": message_dict,
                     "finish_reason": "tool_calls" if tool_calls else "stop"
                 }],
-                "usage": data.get("usageMetadata", {})
+                "usage": data.get("usageMetadata", {}),
+                "safety_ratings": safety_ratings
             }
             
         except Exception as e:

models/linkai/link_ai_bot.py

@@ -107,7 +107,7 @@ class LinkAIBot(Bot, OpenAICompatibleBot):
                 "presence_penalty": conf().get("presence_penalty", 0.0),  # [-2,2]之间，该值越大则更倾向于产生不同的内容
                 "session_id": session_id,
                 "sender_id": session_id,
-                "channel_type": conf().get("channel_type", "wx")
+                "channel_type": context.get("channel_type") or conf().get("channel_type", "web")
             }
             try:
                 from linkai import LinkAIClient
@@ -526,6 +526,14 @@ def _linkai_call_with_tools(self, messages, tools=None, stream=False, **kwargs):
         logger.debug(f"[LinkAI] messages: {len(messages)}, tools: {len(tools) if tools else 0}, stream: {stream}")
         
         # Build request parameters (LinkAI uses OpenAI-compatible format)
+        raw_ct = conf().get("channel_type", "web")
+        if isinstance(raw_ct, list):
+            channel_type = raw_ct[0] if raw_ct else "web"
+        elif isinstance(raw_ct, str) and "," in raw_ct:
+            channel_type = raw_ct.split(",")[0].strip()
+        else:
+            channel_type = raw_ct
+
         body = {
             "messages": messages,
             "model": kwargs.get("model", conf().get("model") or "gpt-3.5-turbo"),
@@ -533,7 +541,8 @@ def _linkai_call_with_tools(self, messages, tools=None, stream=False, **kwargs):
             "top_p": kwargs.get("top_p", conf().get("top_p", 1)),
             "frequency_penalty": kwargs.get("frequency_penalty", conf().get("frequency_penalty", 0.0)),
             "presence_penalty": kwargs.get("presence_penalty", conf().get("presence_penalty", 0.0)),
-            "stream": stream
+            "stream": stream,
+            "channel_type": kwargs.get("channel_type", channel_type),
         }
 
         if tools:
@@ -608,7 +617,7 @@ def _handle_linkai_stream_response(self, base_url, headers, body):
             try:
                 error_data = json.loads(error_text)
                 error_msg = error_data.get("error", {}).get("message", error_text)
-            except:
+            except Exception:
                 error_msg = error_text or "Unknown error"
             
             yield {
@@ -628,9 +637,28 @@ def _handle_linkai_stream_response(self, base_url, headers, body):
                         break
                     try:
                         chunk = json.loads(line)
-                        yield chunk
                     except json.JSONDecodeError:
                         continue
+
+                    # Check for error responses within the stream
+                    # Some providers (e.g., MiniMax via LinkAI) return errors as:
+                    # {'type': 'error', 'error': {'type': '...', 'message': '...', 'http_code': '400'}}
+                    if chunk.get("type") == "error" or (
+                        isinstance(chunk.get("error"), dict) and "message" in chunk.get("error", {})
+                    ):
+                        error_data = chunk.get("error", {})
+                        error_msg = error_data.get("message", "Unknown error") if isinstance(error_data, dict) else str(error_data)
+                        http_code = error_data.get("http_code", "") if isinstance(error_data, dict) else ""
+                        status_code = int(http_code) if http_code and str(http_code).isdigit() else 400
+                        logger.error(f"[LinkAI] stream error: {error_msg} (http_code={http_code})")
+                        yield {
+                            "error": True,
+                            "message": error_msg,
+                            "status_code": status_code
+                        }
+                        return
+
+                    yield chunk
                         
     except Exception as e:
         logger.error(f"[LinkAI] stream response error: {e}")

models/minimax/minimax_bot.py

@@ -1,9 +1,10 @@
 # encoding:utf-8
 
 import time
+import json
+from pydantic.types import T
+import requests
 
-import openai
-import openai.error
 from models.bot import Bot
 from models.minimax.minimax_session import MinimaxSession
 from models.session_manager import SessionManager
@@ -11,41 +12,36 @@ from bridge.context import Context, ContextType
 from bridge.reply import Reply, ReplyType
 from common.log import logger
 from config import conf, load_config
-from models.chatgpt.chat_gpt_session import ChatGPTSession
-import requests
 from common import const
 
 
-# ZhipuAI对话模型API
+# MiniMax对话模型API
 class MinimaxBot(Bot):
     def __init__(self):
         super().__init__()
         self.args = {
-            "model": conf().get("model") or "abab6.5",  # 对话模型的名称
-            "temperature": conf().get("temperature", 0.3),  # 如果设置，值域须为 [0, 1] 我们推荐 0.3，以达到较合适的效果。
-            "top_p": conf().get("top_p", 0.95),  # 使用默认值
-        }
-        self.api_key = conf().get("Minimax_api_key")
-        self.group_id = conf().get("Minimax_group_id")
-        self.base_url = conf().get("Minimax_base_url", f"https://api.minimax.chat/v1/text/chatcompletion_pro?GroupId={self.group_id}")
-        # tokens_to_generate/bot_setting/reply_constraints可自行修改
-        self.request_body = {
-            "model": self.args["model"],
-            "tokens_to_generate": 2048,
-            "reply_constraints": {"sender_type": "BOT", "sender_name": "MM智能助理"},
-            "messages": [],
-            "bot_setting": [
-                {
-                    "bot_name": "MM智能助理",
-                    "content": "MM智能助理是一款由MiniMax自研的，没有调用其他产品的接口的大型语言模型。MiniMax是一家中国科技公司，一直致力于进行大模型相关的研究。",
-                }
-            ],
+            "model": conf().get("model") or "MiniMax-M2.1",
+            "temperature": conf().get("temperature", 0.3),
+            "top_p": conf().get("top_p", 0.95),
         }
+        # Use unified key name: minimax_api_key
+        self.api_key = conf().get("minimax_api_key")
+        if not self.api_key:
+            # Fallback to old key name for backward compatibility
+            self.api_key = conf().get("Minimax_api_key")
+            if self.api_key:
+                logger.warning("[MINIMAX] 'Minimax_api_key' is deprecated, please use 'minimax_api_key' instead")
+
+        # REST API endpoint
+        # Use Chinese endpoint by default, users can override in config
+        # International users should set: "minimax_api_base": "https://api.minimax.io/v1"
+        self.api_base = conf().get("minimax_api_base", "https://api.minimaxi.com/v1")
+
         self.sessions = SessionManager(MinimaxSession, model=const.MiniMax)
 
     def reply(self, query, context: Context = None) -> Reply:
         # acquire reply content
-        logger.info("[Minimax_AI] query={}".format(query))
+        logger.info("[MINIMAX] query={}".format(query))
         if context.type == ContextType.TEXT:
             session_id = context["session_id"]
             reply = None
@@ -62,19 +58,16 @@ class MinimaxBot(Bot):
             if reply:
                 return reply
             session = self.sessions.session_query(query, session_id)
-            logger.debug("[Minimax_AI] session query={}".format(session))
+            logger.debug("[MINIMAX] session query={}".format(session))
 
             model = context.get("Minimax_model")
             new_args = self.args.copy()
             if model:
                 new_args["model"] = model
-            # if context.get('stream'):
-            #     # reply in stream
-            #     return self.reply_text_stream(query, new_query, session_id)
 
             reply_content = self.reply_text(session, args=new_args)
             logger.debug(
-                "[Minimax_AI] new_query={}, session_id={}, reply_cont={}, completion_tokens={}".format(
+                "[MINIMAX] new_query={}, session_id={}, reply_cont={}, completion_tokens={}".format(
                     session.messages,
                     session_id,
                     reply_content["content"],
@@ -88,7 +81,7 @@ class MinimaxBot(Bot):
                 reply = Reply(ReplyType.TEXT, reply_content["content"])
             else:
                 reply = Reply(ReplyType.ERROR, reply_content["content"])
-                logger.debug("[Minimax_AI] reply {} used 0 tokens.".format(reply_content))
+                logger.debug("[MINIMAX] reply {} used 0 tokens.".format(reply_content))
             return reply
         else:
             reply = Reply(ReplyType.ERROR, "Bot不支持处理{}类型的消息".format(context.type))
@@ -96,41 +89,62 @@ class MinimaxBot(Bot):
 
     def reply_text(self, session: MinimaxSession, args=None, retry_count=0) -> dict:
         """
-        call openai's ChatCompletion to get the answer
+        Call MiniMax API to get the answer using REST API
         :param session: a conversation session
-        :param session_id: session id
+        :param args: request arguments
         :param retry_count: retry count
         :return: {}
         """
         try:
-            headers = {"Content-Type": "application/json", "Authorization": "Bearer " + self.api_key}
-            self.request_body["messages"].extend(session.messages)
-            logger.info("[Minimax_AI] request_body={}".format(self.request_body))
-            # logger.info("[Minimax_AI] reply={}, total_tokens={}".format(response.choices[0]['message']['content'], response["usage"]["total_tokens"]))
-            res = requests.post(self.base_url, headers=headers, json=self.request_body)
+            if args is None:
+                args = self.args
+
+            # Build request
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}"
+            }
+
+            request_body = {
+                "model": args.get("model", self.args["model"]),
+                "messages": session.messages,
+                "temperature": args.get("temperature", self.args["temperature"]),
+                "top_p": args.get("top_p", self.args["top_p"]),
+            }
+
+            url = f"{self.api_base}/chat/completions"
+            logger.debug(f"[MINIMAX] Calling {url} with model={request_body['model']}")
+
+            response = requests.post(url, headers=headers, json=request_body, timeout=60)
+
+            if response.status_code == 200:
+                result = response.json()
+                content = result["choices"][0]["message"]["content"]
+                total_tokens = result["usage"]["total_tokens"]
+                completion_tokens = result["usage"]["completion_tokens"]
+
+                logger.debug(f"[MINIMAX] reply_text: content_length={len(content)}, tokens={total_tokens}")
 
-            # self.request_body["messages"].extend(response.json()["choices"][0]["messages"])
-            if res.status_code == 200:
-                response = res.json()
                 return {
-                    "total_tokens": response["usage"]["total_tokens"],
-                    "completion_tokens": response["usage"]["total_tokens"],
-                    "content": response["reply"],
+                    "total_tokens": total_tokens,
+                    "completion_tokens": completion_tokens,
+                    "content": content,
                 }
             else:
-                response = res.json()
-                error = response.get("error")
-                logger.error(f"[Minimax_AI] chat failed, status_code={res.status_code}, " f"msg={error.get('message')}, type={error.get('type')}")
+                error_msg = response.text
+                logger.error(f"[MINIMAX] API error: status={response.status_code}, msg={error_msg}")
 
-                result = {"completion_tokens": 0, "content": "提问太快啦，请休息一下再问我吧"}
+                # Parse error for better messages
+                result = {"completion_tokens": 0, "content": "我现在有点累了，等会再来吧"}
                 need_retry = False
-                if res.status_code >= 500:
-                    # server error, need retry
-                    logger.warn(f"[Minimax_AI] do retry, times={retry_count}")
+
+                if response.status_code >= 500:
+                    logger.warning(f"[MINIMAX] Server error, retry={retry_count}")
                     need_retry = retry_count < 2
-                elif res.status_code == 401:
+                elif response.status_code == 401:
                     result["content"] = "授权失败，请检查API Key是否正确"
-                elif res.status_code == 429:
+                    need_retry = False
+                elif response.status_code == 429:
                     result["content"] = "请求过于频繁，请稍后再试"
                     need_retry = retry_count < 2
                 else:
@@ -141,11 +155,494 @@ class MinimaxBot(Bot):
                     return self.reply_text(session, args, retry_count + 1)
                 else:
                     return result
-        except Exception as e:
-            logger.exception(e)
+
+        except requests.exceptions.Timeout:
+            logger.error("[MINIMAX] Request timeout")
             need_retry = retry_count < 2
-            result = {"completion_tokens": 0, "content": "我现在有点累了，等会再来吧"}
+            result = {"completion_tokens": 0, "content": "请求超时，请稍后再试"}
             if need_retry:
+                time.sleep(3)
                 return self.reply_text(session, args, retry_count + 1)
             else:
                 return result
+        except Exception as e:
+            logger.error(f"[MINIMAX] reply_text error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            need_retry = retry_count < 2
+            result = {"completion_tokens": 0, "content": "我现在有点累了，等会再来吧"}
+            if need_retry:
+                time.sleep(3)
+                return self.reply_text(session, args, retry_count + 1)
+            else:
+                return result
+
+    def call_with_tools(self, messages, tools=None, stream=False, **kwargs):
+        """
+        Call MiniMax API with tool support for agent integration
+
+        This method handles:
+        1. Format conversion (Claude format → OpenAI format)
+        2. System prompt injection
+        3. API calling with REST API
+        4. Interleaved Thinking support (reasoning_split=True)
+
+        Args:
+            messages: List of messages (may be in Claude format from agent)
+            tools: List of tool definitions (may be in Claude format from agent)
+            stream: Whether to use streaming
+            **kwargs: Additional parameters (max_tokens, temperature, system, etc.)
+
+        Returns:
+            Formatted response or generator for streaming
+        """
+        try:
+            # Convert messages from Claude format to OpenAI format
+            converted_messages = self._convert_messages_to_openai_format(messages)
+
+            # Extract and inject system prompt if provided
+            system_prompt = kwargs.pop("system", None)
+            if system_prompt:
+                # Add system message at the beginning
+                converted_messages.insert(0, {"role": "system", "content": system_prompt})
+
+            # Convert tools from Claude format to OpenAI format
+            converted_tools = None
+            if tools:
+                converted_tools = self._convert_tools_to_openai_format(tools)
+
+            # Prepare API parameters
+            model = kwargs.pop("model", None) or self.args["model"]
+            max_tokens = kwargs.pop("max_tokens", 4096)
+            temperature = kwargs.pop("temperature", self.args["temperature"])
+
+            # Build request body
+            request_body = {
+                "model": model,
+                "messages": converted_messages,
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                "stream": stream,
+            }
+
+            # Add tools if provided
+            if converted_tools:
+                request_body["tools"] = converted_tools
+
+            # Add reasoning_split=True for better thinking control (M2.1 feature)
+            # This separates thinking content into reasoning_details field
+            request_body["reasoning_split"] = True
+
+            logger.debug(f"[MINIMAX] API call: model={model}, tools={len(converted_tools) if converted_tools else 0}, stream={stream}")
+
+            # Check if we should show thinking process
+            show_thinking = kwargs.pop("show_thinking", conf().get("minimax_show_thinking", False))
+            
+            if stream:
+                return self._handle_stream_response(request_body, show_thinking=show_thinking)
+            else:
+                return self._handle_sync_response(request_body)
+
+        except Exception as e:
+            logger.error(f"[MINIMAX] call_with_tools error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            
+            def error_generator():
+                yield {"error": True, "message": str(e), "status_code": 500}
+            return error_generator()
+
+    def _convert_messages_to_openai_format(self, messages):
+        """
+        Convert messages from Claude format to OpenAI format
+
+        Claude format:
+        - role: "user" | "assistant"
+        - content: string | list of content blocks
+
+        OpenAI format:
+        - role: "user" | "assistant" | "tool"
+        - content: string
+        - tool_calls: list (for assistant)
+        - tool_call_id: string (for tool results)
+        """
+        converted = []
+
+        for msg in messages:
+            role = msg.get("role")
+            content = msg.get("content")
+
+            if role == "user":
+                # Handle user message
+                if isinstance(content, list):
+                    # Extract text from content blocks
+                    text_parts = []
+                    tool_results = []
+
+                    for block in content:
+                        if isinstance(block, dict):
+                            if block.get("type") == "text":
+                                text_parts.append(block.get("text", ""))
+                            elif block.get("type") == "tool_result":
+                                # Tool result should be a separate message with role="tool"
+                                tool_call_id = block.get("tool_use_id") or ""
+                                if not tool_call_id:
+                                    logger.warning(f"[MINIMAX] tool_result missing tool_use_id")
+                                result_content = block.get("content", "")
+                                if not isinstance(result_content, str):
+                                    result_content = json.dumps(result_content, ensure_ascii=False)
+                                tool_results.append({
+                                    "role": "tool",
+                                    "tool_call_id": tool_call_id,
+                                    "content": result_content
+                                })
+
+                    if text_parts:
+                        converted.append({
+                            "role": "user",
+                            "content": "\n".join(text_parts)
+                        })
+
+                    # Add all tool results (not just the last one)
+                    for tool_result in tool_results:
+                        converted.append(tool_result)
+                else:
+                    # Simple text content
+                    converted.append({
+                        "role": "user",
+                        "content": str(content)
+                    })
+
+            elif role == "assistant":
+                # Handle assistant message
+                openai_msg = {"role": "assistant"}
+
+                if isinstance(content, list):
+                    # Parse content blocks
+                    text_parts = []
+                    tool_calls = []
+
+                    for block in content:
+                        if isinstance(block, dict):
+                            if block.get("type") == "text":
+                                text_parts.append(block.get("text", ""))
+                            elif block.get("type") == "tool_use":
+                                # Convert to OpenAI tool_calls format
+                                tool_calls.append({
+                                    "id": block.get("id"),
+                                    "type": "function",
+                                    "function": {
+                                        "name": block.get("name"),
+                                        "arguments": json.dumps(block.get("input", {}))
+                                    }
+                                })
+
+                    # Set content (can be empty if only tool calls)
+                    if text_parts:
+                        openai_msg["content"] = "\n".join(text_parts)
+                    elif not tool_calls:
+                        openai_msg["content"] = ""
+
+                    # Set tool_calls
+                    if tool_calls:
+                        openai_msg["tool_calls"] = tool_calls
+                        # When tool_calls exist and content is empty, set to None
+                        if not text_parts:
+                            openai_msg["content"] = None
+
+                else:
+                    # Simple text content
+                    openai_msg["content"] = str(content) if content else ""
+
+                converted.append(openai_msg)
+
+        return converted
+
+    def _convert_tools_to_openai_format(self, tools):
+        """
+        Convert tools from Claude format to OpenAI format
+
+        Claude format:
+        {
+            "name": "tool_name",
+            "description": "description",
+            "input_schema": {...}
+        }
+
+        OpenAI format:
+        {
+            "type": "function",
+            "function": {
+                "name": "tool_name",
+                "description": "description",
+                "parameters": {...}
+            }
+        }
+        """
+        converted = []
+
+        for tool in tools:
+            converted.append({
+                "type": "function",
+                "function": {
+                    "name": tool.get("name"),
+                    "description": tool.get("description"),
+                    "parameters": tool.get("input_schema", {})
+                }
+            })
+
+        return converted
+
+    def _handle_sync_response(self, request_body):
+        """Handle synchronous API response"""
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}"
+            }
+
+            # Remove stream from body for sync request
+            request_body.pop("stream", None)
+
+            url = f"{self.api_base}/chat/completions"
+            response = requests.post(url, headers=headers, json=request_body, timeout=60)
+
+            if response.status_code != 200:
+                error_msg = response.text
+                logger.error(f"[MINIMAX] API error: status={response.status_code}, msg={error_msg}")
+                yield {"error": True, "message": error_msg, "status_code": response.status_code}
+                return
+
+            result = response.json()
+            message = result["choices"][0]["message"]
+            finish_reason = result["choices"][0]["finish_reason"]
+
+            # Build response in Claude-like format
+            response_data = {
+                "role": "assistant",
+                "content": []
+            }
+
+            # Add reasoning_details (thinking) if present
+            if "reasoning_details" in message:
+                for reasoning in message["reasoning_details"]:
+                    if "text" in reasoning:
+                        response_data["content"].append({
+                            "type": "thinking",
+                            "thinking": reasoning["text"]
+                        })
+
+            # Add text content if present
+            if message.get("content"):
+                response_data["content"].append({
+                    "type": "text",
+                    "text": message["content"]
+                })
+
+            # Add tool calls if present
+            if message.get("tool_calls"):
+                for tool_call in message["tool_calls"]:
+                    response_data["content"].append({
+                        "type": "tool_use",
+                        "id": tool_call["id"],
+                        "name": tool_call["function"]["name"],
+                        "input": json.loads(tool_call["function"]["arguments"])
+                    })
+
+            # Set stop_reason
+            if finish_reason == "tool_calls":
+                response_data["stop_reason"] = "tool_use"
+            elif finish_reason == "stop":
+                response_data["stop_reason"] = "end_turn"
+            else:
+                response_data["stop_reason"] = finish_reason
+
+            yield response_data
+
+        except requests.exceptions.Timeout:
+            logger.error("[MINIMAX] Request timeout")
+            yield {"error": True, "message": "Request timeout", "status_code": 500}
+        except Exception as e:
+            logger.error(f"[MINIMAX] sync response error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            yield {"error": True, "message": str(e), "status_code": 500}
+
+    def _handle_stream_response(self, request_body, show_thinking=False):
+        """Handle streaming API response
+        
+        Args:
+            request_body: API request parameters
+            show_thinking: Whether to show thinking/reasoning process to users
+        """
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}"
+            }
+
+            url = f"{self.api_base}/chat/completions"
+            response = requests.post(url, headers=headers, json=request_body, stream=True, timeout=60)
+
+            if response.status_code != 200:
+                error_msg = response.text
+                logger.error(f"[MINIMAX] API error: status={response.status_code}, msg={error_msg}")
+                yield {"error": True, "message": error_msg, "status_code": response.status_code}
+                return
+
+            current_content = []
+            current_tool_calls = {}
+            current_reasoning = []
+            finish_reason = None
+            chunk_count = 0
+
+            # Process SSE stream
+            for line in response.iter_lines():
+                if not line:
+                    continue
+
+                line = line.decode('utf-8')
+                if not line.startswith('data: '):
+                    continue
+
+                data_str = line[6:]  # Remove 'data: ' prefix
+                if data_str.strip() == '[DONE]':
+                    break
+
+                try:
+                    chunk = json.loads(data_str)
+                    chunk_count += 1
+                except json.JSONDecodeError as e:
+                    logger.warning(f"[MINIMAX] JSON decode error: {e}, data: {data_str[:100]}")
+                    continue
+
+                # Check for error response (MiniMax format)
+                if chunk.get("type") == "error" or "error" in chunk:
+                    error_data = chunk.get("error", {})
+                    error_msg = error_data.get("message", "Unknown error")
+                    error_type = error_data.get("type", "")
+                    http_code = error_data.get("http_code", "")
+                    
+                    logger.error(f"[MINIMAX] API error: {error_msg} (type: {error_type}, code: {http_code})")
+                    
+                    yield {
+                        "error": True,
+                        "message": error_msg,
+                        "status_code": int(http_code) if http_code.isdigit() else 500
+                    }
+                    return
+
+                if not chunk.get("choices"):
+                    continue
+
+                choice = chunk["choices"][0]
+                delta = choice.get("delta", {})
+
+                # Handle reasoning_details (thinking)
+                if "reasoning_details" in delta:
+                    for reasoning in delta["reasoning_details"]:
+                        if "text" in reasoning:
+                            reasoning_id = reasoning.get("id", "reasoning-text-1")
+                            reasoning_index = reasoning.get("index", 0)
+                            reasoning_text = reasoning["text"]
+
+                            # Accumulate reasoning text
+                            if reasoning_index >= len(current_reasoning):
+                                current_reasoning.append({"id": reasoning_id, "text": ""})
+
+                            current_reasoning[reasoning_index]["text"] += reasoning_text
+
+                            # Optionally yield thinking as visible content
+                            if show_thinking:
+                                # Yield thinking text as-is (without emoji decoration)
+                                # The reasoning text will be displayed to users
+                                yield {
+                                    "choices": [{
+                                        "index": 0,
+                                        "delta": {
+                                            "role": "assistant",
+                                            "content": reasoning_text
+                                        }
+                                    }]
+                                }
+
+                # Handle text content
+                if "content" in delta and delta["content"]:
+                    # Start new content block if needed
+                    if not any(block.get("type") == "text" for block in current_content):
+                        current_content.append({"type": "text", "text": ""})
+
+                    # Accumulate text
+                    for block in current_content:
+                        if block.get("type") == "text":
+                            block["text"] += delta["content"]
+                            break
+
+                    # Yield OpenAI-format delta (for agent_stream.py compatibility)
+                    yield {
+                        "choices": [{
+                            "index": 0,
+                            "delta": {
+                                "role": "assistant",
+                                "content": delta["content"]
+                            }
+                        }]
+                    }
+
+                # Handle tool calls
+                if "tool_calls" in delta:
+                    for tool_call_chunk in delta["tool_calls"]:
+                        index = tool_call_chunk.get("index", 0)
+                        if index not in current_tool_calls:
+                            # Start new tool call
+                            current_tool_calls[index] = {
+                                "id": tool_call_chunk.get("id", ""),
+                                "type": "tool_use",
+                                "name": tool_call_chunk.get("function", {}).get("name", ""),
+                                "input": ""
+                            }
+                        
+                        # Accumulate tool call arguments
+                        if "function" in tool_call_chunk and "arguments" in tool_call_chunk["function"]:
+                            current_tool_calls[index]["input"] += tool_call_chunk["function"]["arguments"]
+
+                        # Yield OpenAI-format tool call delta
+                        yield {
+                            "choices": [{
+                                "index": 0,
+                                "delta": {
+                                    "tool_calls": [tool_call_chunk]
+                                }
+                            }]
+                        }
+
+                # Handle finish_reason
+                if choice.get("finish_reason"):
+                    finish_reason = choice["finish_reason"]
+
+            # Log complete reasoning_details for debugging
+            if current_reasoning:
+                logger.debug(f"[MINIMAX] ===== Complete Reasoning Details =====")
+                for i, reasoning in enumerate(current_reasoning):
+                    reasoning_text = reasoning.get("text", "")
+                    logger.debug(f"[MINIMAX] Reasoning {i+1} (length={len(reasoning_text)}):")
+                    logger.debug(f"[MINIMAX] {reasoning_text}")
+                logger.debug(f"[MINIMAX] ===== End Reasoning Details =====")
+
+            # Yield final chunk with finish_reason (OpenAI format)
+            yield {
+                "choices": [{
+                    "index": 0,
+                    "delta": {},
+                    "finish_reason": finish_reason
+                }]
+            }
+
+        except requests.exceptions.Timeout:
+            logger.error("[MINIMAX] Request timeout")
+            yield {"error": True, "message": "Request timeout", "status_code": 500}
+        except Exception as e:
+            logger.error(f"[MINIMAX] stream response error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            yield {"error": True, "message": str(e), "status_code": 500}

models/moonshot/moonshot_bot.py

@@ -1,9 +1,9 @@
 # encoding:utf-8
 
+import json
 import time
 
-import openai
-import openai.error
+import requests
 from models.bot import Bot
 from models.session_manager import SessionManager
 from bridge.context import ContextType
@@ -11,10 +11,9 @@ from bridge.reply import Reply, ReplyType
 from common.log import logger
 from config import conf, load_config
 from .moonshot_session import MoonshotSession
-import requests
 
 
-# ZhipuAI对话模型API
+# Moonshot (Kimi) API Bot
 class MoonshotBot(Bot):
     def __init__(self):
         super().__init__()
@@ -23,17 +22,22 @@ class MoonshotBot(Bot):
         if model == "moonshot":
             model = "moonshot-v1-32k"
         self.args = {
-            "model": model,  # 对话模型的名称
-            "temperature": conf().get("temperature", 0.3),  # 如果设置，值域须为 [0, 1] 我们推荐 0.3，以达到较合适的效果。
-            "top_p": conf().get("top_p", 1.0),  # 使用默认值
+            "model": model,
+            "temperature": conf().get("temperature", 0.3),
+            "top_p": conf().get("top_p", 1.0),
         }
         self.api_key = conf().get("moonshot_api_key")
-        self.base_url = conf().get("moonshot_base_url", "https://api.moonshot.cn/v1/chat/completions")
+        self.base_url = conf().get("moonshot_base_url", "https://api.moonshot.cn/v1")
+        # Ensure base_url does not end with /chat/completions (backward compat)
+        if self.base_url.endswith("/chat/completions"):
+            self.base_url = self.base_url.rsplit("/chat/completions", 1)[0]
+        if self.base_url.endswith("/"):
+            self.base_url = self.base_url.rstrip("/")
 
     def reply(self, query, context=None):
         # acquire reply content
         if context.type == ContextType.TEXT:
-            logger.info("[MOONSHOT_AI] query={}".format(query))
+            logger.info("[MOONSHOT] query={}".format(query))
 
             session_id = context["session_id"]
             reply = None
@@ -50,19 +54,16 @@ class MoonshotBot(Bot):
             if reply:
                 return reply
             session = self.sessions.session_query(query, session_id)
-            logger.debug("[MOONSHOT_AI] session query={}".format(session.messages))
+            logger.debug("[MOONSHOT] session query={}".format(session.messages))
 
             model = context.get("moonshot_model")
             new_args = self.args.copy()
             if model:
                 new_args["model"] = model
-            # if context.get('stream'):
-            #     # reply in stream
-            #     return self.reply_text_stream(query, new_query, session_id)
 
             reply_content = self.reply_text(session, args=new_args)
             logger.debug(
-                "[MOONSHOT_AI] new_query={}, session_id={}, reply_cont={}, completion_tokens={}".format(
+                "[MOONSHOT] new_query={}, session_id={}, reply_cont={}, completion_tokens={}".format(
                     session.messages,
                     session_id,
                     reply_content["content"],
@@ -76,17 +77,17 @@ class MoonshotBot(Bot):
                 reply = Reply(ReplyType.TEXT, reply_content["content"])
             else:
                 reply = Reply(ReplyType.ERROR, reply_content["content"])
-                logger.debug("[MOONSHOT_AI] reply {} used 0 tokens.".format(reply_content))
+                logger.debug("[MOONSHOT] reply {} used 0 tokens.".format(reply_content))
             return reply
         else:
             reply = Reply(ReplyType.ERROR, "Bot不支持处理{}类型的消息".format(context.type))
             return reply
 
-    def reply_text(self, session: MoonshotSession, args=None, retry_count=0) -> dict:
+    def reply_text(self, session: MoonshotSession, args=None, retry_count: int = 0) -> dict:
         """
-        call openai's ChatCompletion to get the answer
+        Call Moonshot chat completion API to get the answer
         :param session: a conversation session
-        :param session_id: session id
+        :param args: model args
         :param retry_count: retry count
         :return: {}
         """
@@ -97,10 +98,8 @@ class MoonshotBot(Bot):
             }
             body = args
             body["messages"] = session.messages
-            # logger.debug("[MOONSHOT_AI] response={}".format(response))
-            # logger.info("[MOONSHOT_AI] reply={}, total_tokens={}".format(response.choices[0]['message']['content'], response["usage"]["total_tokens"]))
             res = requests.post(
-                self.base_url,
+                f"{self.base_url}/chat/completions",
                 headers=headers,
                 json=body
             )
@@ -114,14 +113,13 @@ class MoonshotBot(Bot):
             else:
                 response = res.json()
                 error = response.get("error")
-                logger.error(f"[MOONSHOT_AI] chat failed, status_code={res.status_code}, "
+                logger.error(f"[MOONSHOT] chat failed, status_code={res.status_code}, "
                              f"msg={error.get('message')}, type={error.get('type')}")
 
                 result = {"completion_tokens": 0, "content": "提问太快啦，请休息一下再问我吧"}
                 need_retry = False
                 if res.status_code >= 500:
-                    # server error, need retry
-                    logger.warn(f"[MOONSHOT_AI] do retry, times={retry_count}")
+                    logger.warn(f"[MOONSHOT] do retry, times={retry_count}")
                     need_retry = retry_count < 2
                 elif res.status_code == 401:
                     result["content"] = "授权失败，请检查API Key是否正确"
@@ -144,3 +142,380 @@ class MoonshotBot(Bot):
                 return self.reply_text(session, args, retry_count + 1)
             else:
                 return result
+
+    # ==================== Agent mode support ====================
+
+    def call_with_tools(self, messages, tools=None, stream: bool = False, **kwargs):
+        """
+        Call Moonshot API with tool support for agent integration.
+
+        This method handles:
+        1. Format conversion (Claude format -> OpenAI format)
+        2. System prompt injection
+        3. Streaming SSE response with tool_calls
+        4. Thinking (reasoning) is disabled by default to avoid tool_choice conflicts
+
+        Args:
+            messages: List of messages (may be in Claude format from agent)
+            tools: List of tool definitions (may be in Claude format from agent)
+            stream: Whether to use streaming
+            **kwargs: Additional parameters (max_tokens, temperature, system, model, etc.)
+
+        Returns:
+            Generator yielding OpenAI-format chunks (for streaming)
+        """
+        try:
+            # Convert messages from Claude format to OpenAI format
+            converted_messages = self._convert_messages_to_openai_format(messages)
+
+            # Inject system prompt if provided
+            system_prompt = kwargs.pop("system", None)
+            if system_prompt:
+                if not converted_messages or converted_messages[0].get("role") != "system":
+                    converted_messages.insert(0, {"role": "system", "content": system_prompt})
+                else:
+                    converted_messages[0] = {"role": "system", "content": system_prompt}
+
+            # Convert tools from Claude format to OpenAI format
+            converted_tools = None
+            if tools:
+                converted_tools = self._convert_tools_to_openai_format(tools)
+
+            # Resolve model / temperature
+            model = kwargs.pop("model", None) or self.args["model"]
+            max_tokens = kwargs.pop("max_tokens", None)
+            # Don't pop temperature, just ignore it
+            kwargs.pop("temperature", None)
+
+            # Build request body (omit temperature, let the API use its own default)
+            request_body = {
+                "model": model,
+                "messages": converted_messages,
+                "stream": stream,
+            }
+            if max_tokens is not None:
+                request_body["max_tokens"] = max_tokens
+
+            # Add tools
+            if converted_tools:
+                request_body["tools"] = converted_tools
+                request_body["tool_choice"] = "auto"
+
+            # Explicitly disable thinking to avoid reasoning_content issues in multi-turn tool calls.
+            # kimi-k2.5 may enable thinking by default; without preserving reasoning_content
+            # in conversation history the API will reject subsequent requests.
+            request_body["thinking"] = {"type": "disabled"}
+
+            logger.debug(f"[MOONSHOT] API call: model={model}, "
+                         f"tools={len(converted_tools) if converted_tools else 0}, stream={stream}")
+
+            if stream:
+                return self._handle_stream_response(request_body)
+            else:
+                return self._handle_sync_response(request_body)
+
+        except Exception as e:
+            logger.error(f"[MOONSHOT] call_with_tools error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+
+            def error_generator():
+                yield {"error": True, "message": str(e), "status_code": 500}
+            return error_generator()
+
+    # -------------------- streaming --------------------
+
+    def _handle_stream_response(self, request_body: dict):
+        """Handle streaming SSE response from Moonshot API and yield OpenAI-format chunks."""
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}"
+            }
+
+            url = f"{self.base_url}/chat/completions"
+            response = requests.post(url, headers=headers, json=request_body, stream=True, timeout=120)
+
+            if response.status_code != 200:
+                error_msg = response.text
+                logger.error(f"[MOONSHOT] API error: status={response.status_code}, msg={error_msg}")
+                yield {"error": True, "message": error_msg, "status_code": response.status_code}
+                return
+
+            current_tool_calls = {}
+            finish_reason = None
+
+            for line in response.iter_lines():
+                if not line:
+                    continue
+
+                line = line.decode("utf-8")
+                if not line.startswith("data: "):
+                    continue
+
+                data_str = line[6:]  # Remove "data: " prefix
+                if data_str.strip() == "[DONE]":
+                    break
+
+                try:
+                    chunk = json.loads(data_str)
+                except json.JSONDecodeError as e:
+                    logger.warning(f"[MOONSHOT] JSON decode error: {e}, data: {data_str[:200]}")
+                    continue
+
+                # Check for error in chunk
+                if chunk.get("error"):
+                    error_data = chunk["error"]
+                    error_msg = error_data.get("message", "Unknown error") if isinstance(error_data, dict) else str(error_data)
+                    logger.error(f"[MOONSHOT] stream error: {error_msg}")
+                    yield {"error": True, "message": error_msg, "status_code": 500}
+                    return
+
+                if not chunk.get("choices"):
+                    continue
+
+                choice = chunk["choices"][0]
+                delta = choice.get("delta", {})
+
+                # Skip reasoning_content (thinking) – don't log or forward
+                if delta.get("reasoning_content"):
+                    continue
+
+                # Handle text content
+                if "content" in delta and delta["content"]:
+                    yield {
+                        "choices": [{
+                            "index": 0,
+                            "delta": {
+                                "role": "assistant",
+                                "content": delta["content"]
+                            }
+                        }]
+                    }
+
+                # Handle tool_calls (streamed incrementally)
+                if "tool_calls" in delta:
+                    for tool_call_chunk in delta["tool_calls"]:
+                        index = tool_call_chunk.get("index", 0)
+                        if index not in current_tool_calls:
+                            current_tool_calls[index] = {
+                                "id": tool_call_chunk.get("id", ""),
+                                "type": "tool_use",
+                                "name": tool_call_chunk.get("function", {}).get("name", ""),
+                                "input": ""
+                            }
+
+                        # Accumulate arguments
+                        if "function" in tool_call_chunk and "arguments" in tool_call_chunk["function"]:
+                            current_tool_calls[index]["input"] += tool_call_chunk["function"]["arguments"]
+
+                        # Yield OpenAI-format tool call delta
+                        yield {
+                            "choices": [{
+                                "index": 0,
+                                "delta": {
+                                    "tool_calls": [tool_call_chunk]
+                                }
+                            }]
+                        }
+
+                # Capture finish_reason
+                if choice.get("finish_reason"):
+                    finish_reason = choice["finish_reason"]
+
+            # Final chunk with finish_reason
+            yield {
+                "choices": [{
+                    "index": 0,
+                    "delta": {},
+                    "finish_reason": finish_reason
+                }]
+            }
+
+        except requests.exceptions.Timeout:
+            logger.error("[MOONSHOT] Request timeout")
+            yield {"error": True, "message": "Request timeout", "status_code": 500}
+        except Exception as e:
+            logger.error(f"[MOONSHOT] stream response error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            yield {"error": True, "message": str(e), "status_code": 500}
+
+    # -------------------- sync --------------------
+
+    def _handle_sync_response(self, request_body: dict):
+        """Handle synchronous API response and yield a single result dict."""
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}"
+            }
+
+            request_body.pop("stream", None)
+            url = f"{self.base_url}/chat/completions"
+            response = requests.post(url, headers=headers, json=request_body, timeout=120)
+
+            if response.status_code != 200:
+                error_msg = response.text
+                logger.error(f"[MOONSHOT] API error: status={response.status_code}, msg={error_msg}")
+                yield {"error": True, "message": error_msg, "status_code": response.status_code}
+                return
+
+            result = response.json()
+            message = result["choices"][0]["message"]
+            finish_reason = result["choices"][0]["finish_reason"]
+
+            response_data = {"role": "assistant", "content": []}
+
+            # Add text content
+            if message.get("content"):
+                response_data["content"].append({
+                    "type": "text",
+                    "text": message["content"]
+                })
+
+            # Add tool calls
+            if message.get("tool_calls"):
+                for tool_call in message["tool_calls"]:
+                    response_data["content"].append({
+                        "type": "tool_use",
+                        "id": tool_call["id"],
+                        "name": tool_call["function"]["name"],
+                        "input": json.loads(tool_call["function"]["arguments"])
+                    })
+
+            # Map finish_reason
+            if finish_reason == "tool_calls":
+                response_data["stop_reason"] = "tool_use"
+            elif finish_reason == "stop":
+                response_data["stop_reason"] = "end_turn"
+            else:
+                response_data["stop_reason"] = finish_reason
+
+            yield response_data
+
+        except requests.exceptions.Timeout:
+            logger.error("[MOONSHOT] Request timeout")
+            yield {"error": True, "message": "Request timeout", "status_code": 500}
+        except Exception as e:
+            logger.error(f"[MOONSHOT] sync response error: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            yield {"error": True, "message": str(e), "status_code": 500}
+
+    # -------------------- format conversion --------------------
+
+    def _convert_messages_to_openai_format(self, messages):
+        """
+        Convert messages from Claude format to OpenAI format.
+
+        Claude format uses content blocks: tool_use / tool_result / text
+        OpenAI format uses tool_calls in assistant, role=tool for results
+        """
+        if not messages:
+            return []
+
+        converted = []
+
+        for msg in messages:
+            role = msg.get("role")
+            content = msg.get("content")
+
+            # Already a simple string – pass through
+            if isinstance(content, str):
+                converted.append(msg)
+                continue
+
+            if not isinstance(content, list):
+                converted.append(msg)
+                continue
+
+            if role == "user":
+                text_parts = []
+                tool_results = []
+
+                for block in content:
+                    if not isinstance(block, dict):
+                        continue
+                    if block.get("type") == "text":
+                        text_parts.append(block.get("text", ""))
+                    elif block.get("type") == "tool_result":
+                        tool_call_id = block.get("tool_use_id") or ""
+                        result_content = block.get("content", "")
+                        if not isinstance(result_content, str):
+                            result_content = json.dumps(result_content, ensure_ascii=False)
+                        tool_results.append({
+                            "role": "tool",
+                            "tool_call_id": tool_call_id,
+                            "content": result_content
+                        })
+
+                # Tool results first (must come right after assistant with tool_calls)
+                for tr in tool_results:
+                    converted.append(tr)
+
+                if text_parts:
+                    converted.append({"role": "user", "content": "\n".join(text_parts)})
+
+            elif role == "assistant":
+                openai_msg = {"role": "assistant"}
+                text_parts = []
+                tool_calls = []
+
+                for block in content:
+                    if not isinstance(block, dict):
+                        continue
+                    if block.get("type") == "text":
+                        text_parts.append(block.get("text", ""))
+                    elif block.get("type") == "tool_use":
+                        tool_calls.append({
+                            "id": block.get("id"),
+                            "type": "function",
+                            "function": {
+                                "name": block.get("name"),
+                                "arguments": json.dumps(block.get("input", {}))
+                            }
+                        })
+
+                if text_parts:
+                    openai_msg["content"] = "\n".join(text_parts)
+                elif not tool_calls:
+                    openai_msg["content"] = ""
+
+                if tool_calls:
+                    openai_msg["tool_calls"] = tool_calls
+                    if not text_parts:
+                        openai_msg["content"] = None
+
+                converted.append(openai_msg)
+            else:
+                converted.append(msg)
+
+        return converted
+
+    def _convert_tools_to_openai_format(self, tools):
+        """
+        Convert tools from Claude format to OpenAI format.
+
+        Claude: {name, description, input_schema}
+        OpenAI: {type: "function", function: {name, description, parameters}}
+        """
+        if not tools:
+            return None
+
+        converted = []
+        for tool in tools:
+            # Already in OpenAI format
+            if "type" in tool and tool["type"] == "function":
+                converted.append(tool)
+            else:
+                converted.append({
+                    "type": "function",
+                    "function": {
+                        "name": tool.get("name"),
+                        "description": tool.get("description"),
+                        "parameters": tool.get("input_schema", {})
+                    }
+                })
+
+        return converted

models/openai_compatible_bot.py

@@ -230,43 +230,69 @@ class OpenAICompatibleBot:
             if isinstance(content, list):
                 # Check if this is a tool result message (user role with tool_result blocks)
                 if role == "user" and any(block.get("type") == "tool_result" for block in content):
-                    # Convert each tool_result block to a separate tool message
+                    # Separate text content and tool_result blocks
+                    text_parts = []
+                    tool_results = []
+
                     for block in content:
-                        if block.get("type") == "tool_result":
-                            openai_messages.append({
-                                "role": "tool",
-                                "tool_call_id": block.get("tool_use_id"),
-                                "content": block.get("content", "")
-                            })
-                
+                        if block.get("type") == "text":
+                            text_parts.append(block.get("text", ""))
+                        elif block.get("type") == "tool_result":
+                            tool_results.append(block)
+
+                    # First, add tool result messages (must come immediately after assistant with tool_calls)
+                    for block in tool_results:
+                        tool_call_id = block.get("tool_use_id") or ""
+                        if not tool_call_id:
+                            logger.warning(f"[OpenAICompatible] tool_result missing tool_use_id, using empty string")
+                        # Ensure content is a string (some providers require string content)
+                        result_content = block.get("content", "")
+                        if not isinstance(result_content, str):
+                            result_content = json.dumps(result_content, ensure_ascii=False)
+                        openai_messages.append({
+                            "role": "tool",
+                            "tool_call_id": tool_call_id,
+                            "content": result_content
+                        })
+
+                    # Then, add text content as a separate user message if present
+                    if text_parts:
+                        openai_messages.append({
+                            "role": "user",
+                            "content": " ".join(text_parts)
+                        })
+
                 # Check if this is an assistant message with tool_use blocks
                 elif role == "assistant":
                     # Separate text content and tool_use blocks
                     text_parts = []
                     tool_calls = []
-                    
+
                     for block in content:
                         if block.get("type") == "text":
                             text_parts.append(block.get("text", ""))
                         elif block.get("type") == "tool_use":
+                            tool_id = block.get("id") or ""
+                            if not tool_id:
+                                logger.warning(f"[OpenAICompatible] tool_use missing id for '{block.get('name')}'")
                             tool_calls.append({
-                                "id": block.get("id"),
+                                "id": tool_id,
                                 "type": "function",
                                 "function": {
                                     "name": block.get("name"),
                                     "arguments": json.dumps(block.get("input", {}))
                                 }
                             })
-                    
+
                     # Build OpenAI format assistant message
                     openai_msg = {
                         "role": "assistant",
                         "content": " ".join(text_parts) if text_parts else None
                     }
-                    
+
                     if tool_calls:
                         openai_msg["tool_calls"] = tool_calls
-                    
+
                     openai_messages.append(openai_msg)
                 else:
                     # Other list content, keep as is

models/zhipuai/zhipu_ai_image.py

@@ -6,8 +6,17 @@ from config import conf
 
 class ZhipuAIImage(object):
     def __init__(self):
-        from zhipuai import ZhipuAI
-        self.client = ZhipuAI(api_key=conf().get("zhipu_ai_api_key"))
+        from zai import ZhipuAiClient
+        # 初始化客户端，支持自定义 API base URL（例如智谱国际版 z.ai）
+        api_key = conf().get("zhipu_ai_api_key")
+        api_base = conf().get("zhipu_ai_api_base")
+        
+        if api_base:
+            self.client = ZhipuAiClient(api_key=api_key, base_url=api_base)
+            logger.info(f"[ZHIPU_AI_IMAGE] 使用自定义 API Base URL: {api_base}")
+        else:
+            self.client = ZhipuAiClient(api_key=api_key)
+            logger.info("[ZHIPU_AI_IMAGE] 使用默认 API Base URL")
 
     def create_img(self, query, retry_count=0, api_key=None, api_base=None):
         try:

models/zhipuai/zhipuai_bot.py

@@ -1,9 +1,8 @@
 # encoding:utf-8
 
 import time
+import json
 
-import openai
-import openai.error
 from models.bot import Bot
 from models.zhipuai.zhipu_ai_session import ZhipuAISession
 from models.zhipuai.zhipu_ai_image import ZhipuAIImage
@@ -12,7 +11,7 @@ from bridge.context import ContextType
 from bridge.reply import Reply, ReplyType
 from common.log import logger
 from config import conf, load_config
-from zhipuai import ZhipuAI
+from zai import ZhipuAiClient
 
 
 # ZhipuAI对话模型API
@@ -25,7 +24,16 @@ class ZHIPUAIBot(Bot, ZhipuAIImage):
             "temperature": conf().get("temperature", 0.9),  # 值在(0,1)之间(智谱AI 的温度不能取 0 或者 1)
             "top_p": conf().get("top_p", 0.7),  # 值在(0,1)之间(智谱AI 的 top_p 不能取 0 或者 1)
         }
-        self.client = ZhipuAI(api_key=conf().get("zhipu_ai_api_key"))
+        # 初始化客户端，支持自定义 API base URL（例如智谱国际版 z.ai）
+        api_key = conf().get("zhipu_ai_api_key")
+        api_base = conf().get("zhipu_ai_api_base")
+        
+        if api_base:
+            self.client = ZhipuAiClient(api_key=api_key, base_url=api_base)
+            logger.info(f"[ZHIPU_AI] 使用自定义 API Base URL: {api_base}")
+        else:
+            self.client = ZhipuAiClient(api_key=api_key)
+            logger.info("[ZHIPU_AI] 使用默认 API Base URL")
 
     def reply(self, query, context=None):
         # acquire reply content
@@ -49,17 +57,13 @@ class ZHIPUAIBot(Bot, ZhipuAIImage):
             session = self.sessions.session_query(query, session_id)
             logger.debug("[ZHIPU_AI] session query={}".format(session.messages))
 
-            api_key = context.get("openai_api_key") or openai.api_key
             model = context.get("gpt_model")
             new_args = None
             if model:
                 new_args = self.args.copy()
                 new_args["model"] = model
-            # if context.get('stream'):
-            #     # reply in stream
-            #     return self.reply_text_stream(query, new_query, session_id)
 
-            reply_content = self.reply_text(session, api_key, args=new_args)
+            reply_content = self.reply_text(session, args=new_args)
             logger.debug(
                 "[ZHIPU_AI] new_query={}, session_id={}, reply_cont={}, completion_tokens={}".format(
                     session.messages,
@@ -90,21 +94,17 @@ class ZHIPUAIBot(Bot, ZhipuAIImage):
             reply = Reply(ReplyType.ERROR, "Bot不支持处理{}类型的消息".format(context.type))
             return reply
 
-    def reply_text(self, session: ZhipuAISession, api_key=None, args=None, retry_count=0) -> dict:
+    def reply_text(self, session: ZhipuAISession, args=None, retry_count=0) -> dict:
         """
-        call openai's ChatCompletion to get the answer
+        Call ZhipuAI API to get the answer
         :param session: a conversation session
-        :param session_id: session id
+        :param args: request arguments
         :param retry_count: retry count
         :return: {}
         """
         try:
-            # if conf().get("rate_limit_chatgpt") and not self.tb4chatgpt.get_token():
-            #     raise openai.error.RateLimitError("RateLimitError: rate limit exceeded")
-            # if api_key == None, the default openai.api_key will be used
             if args is None:
                 args = self.args
-            # response = openai.ChatCompletion.create(api_key=api_key, messages=session.messages, **args)
             response = self.client.chat.completions.create(messages=session.messages, **args)
             # logger.debug("[ZHIPU_AI] response={}".format(response))
             # logger.info("[ZHIPU_AI] reply={}, total_tokens={}".format(response.choices[0]['message']['content'], response["usage"]["total_tokens"]))
@@ -117,23 +117,26 @@ class ZHIPUAIBot(Bot, ZhipuAIImage):
         except Exception as e:
             need_retry = retry_count < 2
             result = {"completion_tokens": 0, "content": "我现在有点累了，等会再来吧"}
-            if isinstance(e, openai.error.RateLimitError):
+            error_str = str(e).lower()
+            
+            # Check error type by error message content
+            if "rate" in error_str and "limit" in error_str:
                 logger.warn("[ZHIPU_AI] RateLimitError: {}".format(e))
                 result["content"] = "提问太快啦，请休息一下再问我吧"
                 if need_retry:
                     time.sleep(20)
-            elif isinstance(e, openai.error.Timeout):
+            elif "timeout" in error_str or "timed out" in error_str:
                 logger.warn("[ZHIPU_AI] Timeout: {}".format(e))
                 result["content"] = "我没有收到你的消息"
                 if need_retry:
                     time.sleep(5)
-            elif isinstance(e, openai.error.APIError):
-                logger.warn("[ZHIPU_AI] Bad Gateway: {}".format(e))
+            elif "api" in error_str and ("error" in error_str or "gateway" in error_str):
+                logger.warn("[ZHIPU_AI] APIError: {}".format(e))
                 result["content"] = "请再问我一次"
                 if need_retry:
                     time.sleep(10)
-            elif isinstance(e, openai.error.APIConnectionError):
-                logger.warn("[ZHIPU_AI] APIConnectionError: {}".format(e))
+            elif "connection" in error_str or "network" in error_str:
+                logger.warn("[ZHIPU_AI] ConnectionError: {}".format(e))
                 result["content"] = "我连接不到你的网络"
                 if need_retry:
                     time.sleep(5)
@@ -144,6 +147,321 @@ class ZHIPUAIBot(Bot, ZhipuAIImage):
 
             if need_retry:
                 logger.warn("[ZHIPU_AI] 第{}次重试".format(retry_count + 1))
-                return self.reply_text(session, api_key, args, retry_count + 1)
+                return self.reply_text(session, args, retry_count + 1)
             else:
                 return result
+
+    def call_with_tools(self, messages, tools=None, stream=False, **kwargs):
+        """
+        Call ZhipuAI API with tool support for agent integration
+        
+        This method handles:
+        1. Format conversion (Claude format → ZhipuAI format)
+        2. System prompt injection
+        3. API calling with ZhipuAI SDK
+        4. Tool stream support (tool_stream=True for GLM-4.7)
+        
+        Args:
+            messages: List of messages (may be in Claude format from agent)
+            tools: List of tool definitions (may be in Claude format from agent)
+            stream: Whether to use streaming
+            **kwargs: Additional parameters (max_tokens, temperature, system, etc.)
+            
+        Returns:
+            Formatted response or generator for streaming
+        """
+        try:
+            # Convert messages from Claude format to ZhipuAI format
+            messages = self._convert_messages_to_zhipu_format(messages)
+            
+            # Convert tools from Claude format to ZhipuAI format
+            if tools:
+                tools = self._convert_tools_to_zhipu_format(tools)
+            
+            # Handle system prompt
+            system_prompt = kwargs.get('system')
+            if system_prompt:
+                # Add system message at the beginning if not already present
+                if not messages or messages[0].get('role') != 'system':
+                    messages = [{"role": "system", "content": system_prompt}] + messages
+                else:
+                    # Replace existing system message
+                    messages[0] = {"role": "system", "content": system_prompt}
+            
+            # Build request parameters
+            request_params = {
+                "model": kwargs.get("model", self.args.get("model", "glm-4")),
+                "messages": messages,
+                "temperature": kwargs.get("temperature", self.args.get("temperature", 0.9)),
+                "top_p": kwargs.get("top_p", self.args.get("top_p", 0.7)),
+                "stream": stream
+            }
+            
+            # Add max_tokens if specified
+            if kwargs.get("max_tokens"):
+                request_params["max_tokens"] = kwargs["max_tokens"]
+            
+            # Add tools if provided
+            if tools:
+                request_params["tools"] = tools
+                # GLM-4.7 with zai-sdk supports tool_stream for streaming tool calls
+                if stream:
+                    request_params["tool_stream"] = kwargs.get("tool_stream", True)
+            
+            # Add thinking parameter for deep thinking mode (GLM-4.7)
+            thinking = kwargs.get("thinking")
+            if thinking:
+                request_params["thinking"] = thinking
+            elif "glm-4.7" in request_params["model"]:
+                # Enable thinking by default for GLM-4.7
+                request_params["thinking"] = {"type": "disabled"}
+            
+            # Make API call with ZhipuAI SDK
+            if stream:
+                return self._handle_stream_response(request_params)
+            else:
+                return self._handle_sync_response(request_params)
+                
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"[ZHIPU_AI] call_with_tools error: {error_msg}")
+            if stream:
+                def error_generator():
+                    yield {
+                        "error": True,
+                        "message": error_msg,
+                        "status_code": 500
+                    }
+                return error_generator()
+            else:
+                return {
+                    "error": True,
+                    "message": error_msg,
+                    "status_code": 500
+                }
+    
+    def _handle_sync_response(self, request_params):
+        """Handle synchronous ZhipuAI API response"""
+        try:
+            response = self.client.chat.completions.create(**request_params)
+            
+            # Convert ZhipuAI response to OpenAI-compatible format
+            return {
+                "id": response.id,
+                "object": "chat.completion",
+                "created": response.created,
+                "model": response.model,
+                "choices": [{
+                    "index": 0,
+                    "message": {
+                        "role": response.choices[0].message.role,
+                        "content": response.choices[0].message.content,
+                        "tool_calls": self._convert_tool_calls_to_openai_format(
+                            getattr(response.choices[0].message, 'tool_calls', None)
+                        )
+                    },
+                    "finish_reason": response.choices[0].finish_reason
+                }],
+                "usage": {
+                    "prompt_tokens": response.usage.prompt_tokens,
+                    "completion_tokens": response.usage.completion_tokens,
+                    "total_tokens": response.usage.total_tokens
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"[ZHIPU_AI] sync response error: {e}")
+            return {
+                "error": True,
+                "message": str(e),
+                "status_code": 500
+            }
+    
+    def _handle_stream_response(self, request_params):
+        """Handle streaming ZhipuAI API response"""
+        try:
+            stream = self.client.chat.completions.create(**request_params)
+            
+            # Stream chunks to caller, converting to OpenAI format
+            for chunk in stream:
+                if not chunk.choices:
+                    continue
+                
+                delta = chunk.choices[0].delta
+                
+                # Convert to OpenAI-compatible format
+                openai_chunk = {
+                    "id": chunk.id,
+                    "object": "chat.completion.chunk",
+                    "created": chunk.created,
+                    "model": chunk.model,
+                    "choices": [{
+                        "index": 0,
+                        "delta": {},
+                        "finish_reason": chunk.choices[0].finish_reason
+                    }]
+                }
+                
+                # Add role if present
+                if hasattr(delta, 'role') and delta.role:
+                    openai_chunk["choices"][0]["delta"]["role"] = delta.role
+                
+                # Add content if present
+                if hasattr(delta, 'content') and delta.content:
+                    openai_chunk["choices"][0]["delta"]["content"] = delta.content
+                
+                # Add reasoning_content as separate field if present (GLM-5/GLM-4.7 thinking)
+                if hasattr(delta, 'reasoning_content') and delta.reasoning_content:
+                    openai_chunk["choices"][0]["delta"]["reasoning_content"] = delta.reasoning_content
+                
+                # Add tool_calls if present
+                if hasattr(delta, 'tool_calls') and delta.tool_calls:
+                    # For streaming, tool_calls need special handling
+                    openai_tool_calls = []
+                    for tc in delta.tool_calls:
+                        tool_call_dict = {
+                            "index": getattr(tc, 'index', 0),
+                            "id": getattr(tc, 'id', None),
+                            "type": "function",
+                            "function": {}
+                        }
+                        
+                        # Add function name if present
+                        if hasattr(tc, 'function') and hasattr(tc.function, 'name') and tc.function.name:
+                            tool_call_dict["function"]["name"] = tc.function.name
+                        
+                        # Add function arguments if present
+                        if hasattr(tc, 'function') and hasattr(tc.function, 'arguments') and tc.function.arguments:
+                            tool_call_dict["function"]["arguments"] = tc.function.arguments
+                        
+                        openai_tool_calls.append(tool_call_dict)
+                    
+                    openai_chunk["choices"][0]["delta"]["tool_calls"] = openai_tool_calls
+                
+                yield openai_chunk
+                
+        except Exception as e:
+            logger.error(f"[ZHIPU_AI] stream response error: {e}")
+            yield {
+                "error": True,
+                "message": str(e),
+                "status_code": 500
+            }
+    
+    def _convert_tools_to_zhipu_format(self, tools):
+        """
+        Convert tools from Claude format to ZhipuAI format
+        
+        Claude format: {name, description, input_schema}
+        ZhipuAI format: {type: "function", function: {name, description, parameters}}
+        """
+        if not tools:
+            return None
+        
+        zhipu_tools = []
+        for tool in tools:
+            # Check if already in ZhipuAI/OpenAI format
+            if 'type' in tool and tool['type'] == 'function':
+                zhipu_tools.append(tool)
+            else:
+                # Convert from Claude format
+                zhipu_tools.append({
+                    "type": "function",
+                    "function": {
+                        "name": tool.get("name"),
+                        "description": tool.get("description"),
+                        "parameters": tool.get("input_schema", {})
+                    }
+                })
+        
+        return zhipu_tools
+    
+    def _convert_messages_to_zhipu_format(self, messages):
+        """
+        Convert messages from Claude format to ZhipuAI format
+        
+        Claude uses content blocks with types like 'tool_use', 'tool_result'
+        ZhipuAI uses 'tool_calls' in assistant messages and 'tool' role for results
+        """
+        if not messages:
+            return []
+        
+        zhipu_messages = []
+        
+        for msg in messages:
+            role = msg.get("role")
+            content = msg.get("content")
+            
+            # Handle string content (already in correct format)
+            if isinstance(content, str):
+                zhipu_messages.append(msg)
+                continue
+            
+            # Handle list content (Claude format with content blocks)
+            if isinstance(content, list):
+                # Check if this is a tool result message (user role with tool_result blocks)
+                if role == "user" and any(block.get("type") == "tool_result" for block in content):
+                    # Convert each tool_result block to a separate tool message
+                    for block in content:
+                        if block.get("type") == "tool_result":
+                            zhipu_messages.append({
+                                "role": "tool",
+                                "tool_call_id": block.get("tool_use_id"),
+                                "content": block.get("content", "")
+                            })
+                
+                # Check if this is an assistant message with tool_use blocks
+                elif role == "assistant":
+                    # Separate text content and tool_use blocks
+                    text_parts = []
+                    tool_calls = []
+                    
+                    for block in content:
+                        if block.get("type") == "text":
+                            text_parts.append(block.get("text", ""))
+                        elif block.get("type") == "tool_use":
+                            tool_calls.append({
+                                "id": block.get("id"),
+                                "type": "function",
+                                "function": {
+                                    "name": block.get("name"),
+                                    "arguments": json.dumps(block.get("input", {}))
+                                }
+                            })
+                    
+                    # Build ZhipuAI format assistant message
+                    zhipu_msg = {
+                        "role": "assistant",
+                        "content": " ".join(text_parts) if text_parts else None
+                    }
+                    
+                    if tool_calls:
+                        zhipu_msg["tool_calls"] = tool_calls
+                    
+                    zhipu_messages.append(zhipu_msg)
+                else:
+                    # Other list content, keep as is
+                    zhipu_messages.append(msg)
+            else:
+                # Other formats, keep as is
+                zhipu_messages.append(msg)
+        
+        return zhipu_messages
+    
+    def _convert_tool_calls_to_openai_format(self, tool_calls):
+        """Convert ZhipuAI tool_calls to OpenAI format"""
+        if not tool_calls:
+            return None
+        
+        openai_tool_calls = []
+        for tool_call in tool_calls:
+            openai_tool_calls.append({
+                "id": tool_call.id,
+                "type": "function",
+                "function": {
+                    "name": tool_call.function.name,
+                    "arguments": tool_call.function.arguments
+                }
+            })
+        
+        return openai_tool_calls

plugins/agent/agent.py

@@ -38,7 +38,7 @@ class AgentPlugin(Plugin):
         """Load configuration from config.yaml file."""
         config_path = os.path.join(self.path, "config.yaml")
         if not os.path.exists(config_path):
-            logger.warning(f"Config file not found at {config_path}")
+            logger.debug(f"Config file not found at {config_path}")
             return {}
             
         with open(config_path, 'r', encoding='utf-8') as f:

plugins/banwords/banwords.py

@@ -51,7 +51,7 @@ class Banwords(Plugin):
                 self.reply_action = conf.get("reply_action", "ignore")
             logger.debug("[Banwords] inited")
         except Exception as e:
-            logger.warn("[Banwords] init failed, ignore or see https://github.com/zhayujie/chatgpt-on-wechat/tree/master/plugins/banwords .")
+            logger.debug("[Banwords] init failed, ignore or see https://github.com/zhayujie/chatgpt-on-wechat/tree/master/plugins/banwords .")
             raise e
 
     def on_handle_context(self, e_context: EventContext):

plugins/godcmd/godcmd.py

@@ -140,7 +140,9 @@ def get_help_text(isadmin, isgroup):
     for cmd, info in COMMANDS.items():
         if cmd in ["auth", "set_openai_api_key", "reset_openai_api_key", "set_gpt_model", "reset_gpt_model", "gpt_model"]:  # 不显示帮助指令
             continue
-        if cmd == "id" and conf().get("channel_type", "wx") not in ["wxy", "wechatmp"]:
+        raw_ct = conf().get("channel_type", "web")
+        active_channels = raw_ct if isinstance(raw_ct, list) else [c.strip() for c in str(raw_ct).split(",")]
+        if cmd == "id" and not any(c in ["wxy", "wechatmp"] for c in active_channels):
             continue
         alias = ["#" + a for a in info["alias"][:1]]
         help_text += f"{','.join(alias)} "

requirements-optional.txt

@@ -15,14 +15,9 @@ elevenlabs==1.0.3 # elevenlabs TTS
 #install plugin
 dulwich
 
-# wechatmp && wechatcom && feishu
-web.py
-wechatpy
-
 # xunfei spark
 websocket-client==1.2.0
 
-
 # claude API
 anthropic==0.25.0
 
@@ -32,11 +27,5 @@ broadscope_bailian
 # google
 google-generativeai
 
-# zhipuai
-zhipuai>=2.0.1
-
-# tongyi qwen new sdk
-dashscope
-
 # tencentcloud sdk
 tencentcloud-sdk-python>=3.0.0

requirements.txt

@@ -1,4 +1,5 @@
 openai==0.27.8
+aiohttp>=3.8.6,<3.10
 HTMLParser>=0.0.2
 PyQRCode==1.2.1
 qrcode==7.4.2
@@ -13,6 +14,15 @@ python-dotenv>=1.0.0
 PyYAML>=6.0
 croniter>=2.0.0
 
+# wechatcom & wechatmp
+web.py
+wechatpy
+
+# zhipuai
+zai-sdk
+# tongyi qwen sdk
+dashscope
+
 # feishu websocket mode
 lark-oapi
 # dingtalk

skills/bocha-search/SKILL.md

@@ -1,91 +0,0 @@
----
-name: bocha-search
-description: High-quality web search with AI-optimized results. Use when user needs to search the internet for current information, news, or research topics.
-homepage: https://open.bocha.cn/
-metadata:
-  emoji: 🔍
-  requires:
-    bins: ["curl"]
-    env: ["BOCHA_API_KEY"]
-  primaryEnv: "BOCHA_API_KEY"
----
-
-# Bocha Search
-
-High-quality web search powered by Bocha AI, optimized for AI consumption. Returns web pages, images, and detailed metadata.
-
-## Setup
-
-This skill requires a Bocha API key. If not configured:
-
-1. Visit https://open.bocha.cn to get an API key
-2. Set the key using: `env_config(action="set", key="BOCHA_API_KEY", value="your-key")`
-3. Or manually add to `~/cow/.env`: `BOCHA_API_KEY=your-key`
-
-## Usage
-
-**Important**: Scripts are located relative to this skill's base directory.
-
-When you see this skill in `<available_skills>`, note the `<base_dir>` path.
-
-```bash
-# General pattern:
-bash "<base_dir>/scripts/search.sh" "<query>" [count] [freshness] [summary]
-
-# Parameters:
-# - query: Search query (required)
-# - count: Number of results (1-50, default: 10)
-# - freshness: Time range filter (default: noLimit)
-#   Options: noLimit, oneDay, oneWeek, oneMonth, oneYear, YYYY-MM-DD..YYYY-MM-DD
-# - summary: Include text summary (true/false, default: false)
-```
-
-## Examples
-
-### Basic search
-```bash
-bash "<base_dir>/scripts/search.sh" "latest AI news"
-```
-
-### Search with more results
-```bash
-bash "<base_dir>/scripts/search.sh" "Python tutorials" 20
-```
-
-### Search recent content with summary
-```bash
-bash "<base_dir>/scripts/search.sh" "阿里巴巴ESG报告" 10 oneWeek true
-```
-
-### Search specific date range
-```bash
-bash "<base_dir>/scripts/search.sh" "tech news" 15 "2025-01-01..2025-02-01"
-```
-
-## Response Format
-
-The API returns structured data compatible with Bing Search API:
-
-**Web Pages** (in `data.webPages.value`):
-- `name`: Page title
-- `url`: Page URL
-- `snippet`: Short description
-- `summary`: Full text summary (if requested)
-- `siteName`: Website name
-- `siteIcon`: Website icon URL
-- `datePublished`: Publication date (UTC+8)
-- `language`: Page language
-
-**Images** (in `data.images.value`):
-- `contentUrl`: Image URL
-- `hostPageUrl`: Source page URL
-- `width`, `height`: Image dimensions
-- `thumbnailUrl`: Thumbnail URL
-
-## Notes
-
-- **Optimized for AI**: Results include summaries and structured metadata
-- **Time range**: Use `noLimit` for best results (algorithm auto-optimizes time range)
-- **Timeout**: 30 seconds
-- **Rate limits**: Check your API plan at https://open.bocha.cn
-- **Response format**: Compatible with Bing Search API for easy integration