@sunnoy/wecom 1.6.2 → 1.7.1

package/README.md

@@ -2,6 +2,41 @@
 
 `openclaw-plugin-wecom` 是一个专为 [OpenClaw](https://github.com/openclaw/openclaw) 框架开发的企业微信（WeCom）集成插件。它允许你将强大的 AI 能力无缝接入企业微信，支持 AI 机器人模式和自建应用模式，并具备多层消息投递回退机制。
 
+## 目录导航
+
+### 快速开始
+- [核心特性](#核心特性)
+- [前置要求](#前置要求)
+- [安装](#安装)
+- [运行测试](#运行测试)
+- [运行真实 E2E 测试（远程 OpenClaw）](#运行真实-e2e-测试远程-openclaw)
+
+### 配置与接入
+- [配置](#配置)
+- [配置说明](#配置说明)
+- [企业微信后台配置](#企业微信后台配置)
+- [方式一：创建 AI 机器人 (Bot 模式)](#方式一创建-ai-机器人-bot-模式)
+- [方式二：创建自建应用 (Agent 模式)](#方式二创建自建应用-agent-模式)
+- [方式三：配置群机器人 (Webhook 模式)](#方式三配置群机器人-webhook-模式)
+
+### 能力与路由
+- [三种模式消息能力对比](#三种模式消息能力对比)
+- [支持的消息类型](#支持的消息类型)
+- [流式回复能力](#流式回复能力)
+- [管理员用户](#管理员用户)
+- [动态 Agent 路由](#动态-agent-路由)
+- [支持的目标格式](#支持的目标格式)
+- [指令白名单](#指令白名单)
+- [消息防抖合并](#消息防抖合并)
+
+### 运维与参考
+- [常见问题 (FAQ)](#常见问题-faq)
+- [项目结构](#项目结构)
+- [贡献规范](#贡献规范)
+- [开源协议](#开源协议)
+- [配置示例参考](#配置示例参考)
+- [自定义 Skills 配合沙箱使用实践](#自定义-skills-配合沙箱使用实践)
+
 ## 核心特性
 
 ### 消息模式支持
@@ -9,6 +44,12 @@
 - **自建应用模式 (Agent Mode)**: 支持企业微信自建应用，可处理 XML 格式的回调消息，支持收发消息、上传下载媒体文件。
 - **Webhook Bot 模式**: 支持通过 Webhook 发送消息到群聊，适用于群通知场景。
 
+### 流式回复增强
+- **Markdown 格式支持**: 流式回复的 `content` 字段支持常见 Markdown 格式，包括加粗、斜体、代码块、列表、标题、链接等，企业微信客户端会自动渲染。
+- **思考过程展示**: 当 LLM 回复包含 `<think>...</think>` 标签时，插件自动解析并通过 `thinking_content` 字段在客户端展示可折叠的思考过程。
+- **被动回复思考模式**: 首次被动回复即启用思考模式 UI（通过 `thinking_content` 字段），用户无需等待即可看到模型正在思考的状态。
+- **图片混合回复**: 支持在最终回复（`finish=true`）时包含 `msgtype` 为 `image` 的 `msg_item`，流式过程中图片会排队等待最终发送。
+
 ### 智能消息投递
 - **四层投递回退机制**: 确保消息可靠送达
   1. **流式通道**: 优先通过活跃流式通道发送
@@ -282,6 +323,131 @@ Webhook Bot 用于向群聊发送通知消息。
 - 每个群聊可添加多个机器人
 - Webhook 地址请妥善保管，避免泄露
 
+## 三种模式消息能力对比
+
+企业微信提供了三种不同的接入方式，每种方式在私聊和群聊场景下的消息收发能力不同：
+
+### 能力矩阵
+
+| 能力 | Bot 模式 (AI 机器人) | Agent 模式 (自建应用) | Webhook 模式 (群机器人) |
+|------|---------------------|---------------------|----------------------|
+| **私聊接收** | ✅ JSON 回调 | ✅ XML 回调 | ❌ 不支持 |
+| **私聊被动回复** | ✅ 流式 stream | ✅ 同步回复 | ❌ 不支持 |
+| **私聊主动发送** | ❌ 不支持 | ✅ 应用消息 API | ❌ 不支持 |
+| **群聊接收** | ✅ @提及 JSON 回调 | ✅ @提及 XML 回调 | ❌ 不支持 |
+| **群聊被动回复** | ✅ 流式 stream | ✅ 同步回复 | ❌ 不支持 |
+| **群聊主动发送** | ❌ 不支持 | ✅ 应用消息 API | ✅ Webhook URL |
+| **流式回复** | ✅ 打字机效果 | ❌ 仅完整消息 | ❌ 仅完整消息 |
+| **思考过程展示** | ✅ thinking_content | ❌ | ❌ |
+| **媒体发送** | ✅ msg_item (图片) | ✅ API 上传 (图片/文件) | ✅ base64/upload |
+| **Markdown** | ✅ stream content | ✅ Markdown 消息类型 | ✅ Markdown 消息类型 |
+
+### 各模式详细说明
+
+#### Bot 模式 (AI 机器人)
+
+> 📖 [企业微信 AI 机器人开发指南](https://developer.work.weixin.qq.com/document/path/101039)
+
+**消息接收机制**：企业微信将用户消息以 **JSON 格式**通过 HTTP POST 回调到配置的 URL。支持私聊消息和群聊中 @提及机器人的消息。
+
+**消息回复机制**：采用**流式分片（streaming）**回复。收到回调后立即返回 `stream_id`，后续通过 `stream_refresh` 轮询接口推送增量内容。客户端展示打字机效果。
+
+- **被动回复**：用户发消息 → 回调触发 → 流式回复（支持文本、Markdown、图片、思考过程）
+- **主动发送**：❌ 不支持。AI 机器人没有主动发送 API，只能在收到消息后回复
+- **适用场景**：实时对话、问答，流式体验好
+
+#### Agent 模式 (自建应用)
+
+> 📖 [企业微信自建应用开发指南](https://developer.work.weixin.qq.com/document/path/90226)
+> 📖 [应用消息发送 API](https://developer.work.weixin.qq.com/document/path/90236)
+
+**消息接收机制**：企业微信将用户消息以 **XML 格式**通过 HTTP POST 回调到配置的 URL。支持私聊和群聊消息，以及图片、语音、文件等多种消息类型。
+
+**消息回复机制**：
+- **被动回复**：在回调响应中直接返回 XML 格式回复（需在 5 秒内响应）
+- **主动发送**：通过[应用消息 API](https://developer.work.weixin.qq.com/document/path/90236) 可主动向用户发送文本、图片、文件、Markdown 等消息。支持指定 `touser`（用户）、`toparty`（部门）、`totag`（标签）
+
+- **适用场景**：需要主动推送的场景（异步任务完成通知、定时报告），需要收发文件的场景
+
+#### Webhook 模式 (群机器人)
+
+> 📖 [企业微信群机器人配置说明](https://developer.work.weixin.qq.com/document/path/99110)
+
+**消息发送机制**：通过 HTTP POST 请求向 Webhook URL 发送消息。支持文本、Markdown、图片（base64）、文件（需先上传获取 media_id）。
+
+- **接收消息**：❌ 不支持。Webhook 仅为单向发送通道
+- **主动发送**：✅ 向 Webhook URL POST 即可发送到群聊
+- **适用场景**：单向通知（告警、日报）、定时推送
+
+### Webhook 消息发送方式
+
+Webhook 配置好后（见[方式三](#方式三配置群机器人-webhook-模式)），有以下方式发送消息：
+
+#### CLI 直接发送
+
+```bash
+openclaw message send --channel wecom --to "webhook:ops-group" "服务已恢复正常"
+```
+
+#### Agent 处理后投递到群
+
+让 agent 处理消息后将回复发到 webhook 群：
+
+```bash
+openclaw agent --agent myagent \
+  --message "帮我总结今天的监控告警" \
+  --deliver \
+  --reply-channel wecom \
+  --reply-to "webhook:ops-group"
+```
+
+#### Heartbeat 定时推送（推荐）
+
+在 agent 配置中添加 heartbeat，自动定时触发并将回复发到 webhook 群：
+
+```json
+{
+  "id": "report-agent",
+  "heartbeat": {
+    "every": "1h",
+    "target": "webhook:ops-group",
+    "prompt": "请总结最新的系统监控状态",
+    "activeHours": {
+      "start": "09:00",
+      "end": "18:00",
+      "timezone": "Asia/Shanghai"
+    }
+  }
+}
+```
+
+- `every` — 触发间隔（如 `30m`, `1h`, `6h`）
+- `target` — 回复目标，`webhook:` 前缀加配置中的 webhook 名称
+- `prompt` — 每次触发时给 agent 的提示语
+- `activeHours` — 可选，限制只在工作时间段内触发
+
+#### 系统 Crontab 定时发送
+
+```bash
+# crontab -e
+# 每天早上9点发送日报
+0 9 * * * openclaw agent --agent report-agent --message "生成今日晨报" --deliver --reply-channel wecom --reply-to "webhook:ops-group"
+
+# 每小时发送监控摘要
+0 * * * * openclaw message send --channel wecom --to "webhook:monitor-group" "$(curl -s http://localhost:9090/api/v1/alerts | jq -r '.data.alerts | length') 条活跃告警"
+```
+
+### 模式选择建议
+
+| 需求 | 推荐模式 |
+|------|---------|
+| 实时对话，流式打字机体验 | **Bot 模式** |
+| 双向对话 + 主动推送 + 文件处理 | **Agent 模式** |
+| 仅需向群聊推送通知 | **Webhook 模式** |
+| 同时需要对话和群通知 | **Bot/Agent 模式 + Webhook 模式** 组合使用 |
+
+> 💡 **三种模式可以同时启用**。例如：Bot 模式处理日常对话，Webhook 模式负责定时推送通知到群。配置时在同一个 `channels.wecom` 下同时填写 `token`/`encodingAesKey`（Bot）、`agent`（Agent）和 `webhooks`（Webhook）即可。
+
 ## 支持的消息类型
 
 | 类型 | 方向 | 说明 |
@@ -294,6 +460,46 @@ Webhook Bot 用于向群聊发送通知消息。
 | 位置 (location) | 收 | 位置分享（转换为文本描述） |
 | 链接 (link) | 收 | 分享链接（提取标题、描述、URL 为文本） |
 
+## 流式回复能力
+
+### Markdown 格式
+
+流式回复的 `content` 字段支持以下 Markdown 格式，企业微信客户端会自动渲染：
+
+| 格式 | 语法 | 示例 |
+|------|------|------|
+| 加粗 | `**text**` | **加粗文本** |
+| 斜体 | `*text*` | *斜体文本* |
+| 行内代码 | `` `code` `` | `code` |
+| 代码块 | ` ```lang ... ``` ` | 多行代码 |
+| 列表 | `- item` / `1. item` | 有序/无序列表 |
+| 标题 | `# H1` / `## H2` | 各级标题 |
+| 链接 | `[text](url)` | 超链接 |
+
+### 思考过程展示（Thinking Mode）
+
+当 LLM 模型（如 DeepSeek、QwQ 等支持思考模式的模型）在回复中输出 `<think>...</think>` 标签时，插件会自动：
+
+1. **解析** `<think>` 标签，将思考内容与可见内容分离
+2. **映射** 思考内容到企业微信流式回复的 `thinking_content` 字段
+3. **展示** 企业微信客户端会以可折叠的方式显示模型的思考过程
+
+**流式处理说明：**
+- 被动回复（首次同步响应）立即启用思考模式 UI，显示「思考中...」
+- 当检测到未闭合的 `<think>` 标签（流式输出中），`thinking_content` 持续更新
+- `</think>` 闭合后，思考内容固定，后续内容显示为可见回复
+- 代码块内的 `<think>` 标签不会被解析（避免误匹配）
+
+**支持的标签变体：** `<think>`, `<thinking>`, `<thought>`（均不区分大小写）
+
+### 图片回复
+
+图片通过 `msg_item` 以 base64 编码在流式回复结束时发送：
+
+- 仅在 `finish=true`（最终回复）时包含 `msgtype` 为 `image` 的 `msg_item`
+- 流式过程中生成的图片会排队，待回复完成后一次性发送
+- 单张图片最大 2MB，支持 JPG/PNG 格式，每条消息最多 10 张
+
 ## 管理员用户
 
 管理员用户默认可以绕过指令白名单限制。若希望管理员用户同时跳过动态 Agent 路由（直接路由到主 Agent），可开启 `dynamicAgents.adminBypass`。
@@ -715,6 +921,7 @@ openclaw-plugin-wecom/
 ├── logger.js                # 日志模块
 ├── utils.js                 # 工具函数（TTL 缓存、消息去重）
 ├── stream-manager.js        # 流式回复管理
+├── think-parser.js          # 思考标签解析（<think> 标签分离）
 ├── image-processor.js       # 图片编码/校验（msg_item）
 ├── webhook.js               # 企业微信 Bot 模式 HTTP 通信处理
 ├── dynamic-agent.js         # 动态 Agent 分配逻辑
@@ -760,176 +967,6 @@ openclaw-plugin-wecom/
 
 本项目采用 [ISC License](./LICENSE) 协议。
 
-## 配置示例参考
-
-以下是一个生产环境的脱敏配置示例，供参考：
-
-```json
-{
-  "meta": {
-    "lastTouchedVersion": "2026.2.25",
-    "lastTouchedAt": "2026-02-28T03:14:11.564Z"
-  },
-  "wizard": {
-    "lastRunAt": "2026-02-26T09:29:04.028Z",
-    "lastRunVersion": "2026.2.25",
-    "lastRunCommand": "onboard",
-    "lastRunMode": "local"
-  },
-  "logging": {
-    "level": "info",
-    "consoleLevel": "debug",
-    "consoleStyle": "pretty"
-  },
-  "models": {
-    "mode": "merge",
-    "providers": {
-      "bailian": {
-        "baseUrl": "https://coding.dashscope.aliyuncs.com/v1",
-        "apiKey": "sk-xxxxxxxxxxxxxxxxxxxxxx",
-        "api": "openai-completions",
-        "models": [
-          { "id": "qwen3.5-plus", "name": "qwen3.5-plus", "reasoning": false, "input": ["text", "image"], "contextWindow": 1000000, "maxTokens": 65536 },
-          { "id": "MiniMax-M2.5", "name": "MiniMax-M2.5", "reasoning": false, "input": ["text"], "contextWindow": 1000000, "maxTokens": 65536 },
-          { "id": "glm-5", "name": "glm-5", "reasoning": false, "input": ["text"], "contextWindow": 202752, "maxTokens": 16384 },
-          { "id": "glm-4.7", "name": "glm-4.7", "reasoning": false, "input": ["text"], "contextWindow": 202752, "maxTokens": 16384 },
-          { "id": "kimi-k2.5", "name": "kimi-k2.5", "reasoning": false, "input": ["text", "image"], "contextWindow": 262144, "maxTokens": 32768 }
-        ]
-      }
-    }
-  },
-  "agents": {
-    "defaults": {
-      "model": { "primary": "bailian/kimi-k2.5" },
-      "models": {
-        "bailian/qwen3.5-plus": {},
-        "bailian/MiniMax-M2.5": {},
-        "bailian/glm-5": {},
-        "bailian/glm-4.7": {},
-        "bailian/kimi-k2.5": {}
-      },
-      "workspace": "/path/to/workspace",
-      "userTimezone": "Asia/Shanghai",
-      "timeFormat": "24",
-      "compaction": {
-        "mode": "safeguard",
-        "reserveTokensFloor": 20000,
-        "memoryFlush": {
-          "enabled": true,
-          "softThresholdTokens": 4000
-        }
-      },
-      "thinkingDefault": "medium",
-      "verboseDefault": "on",
-      "heartbeat": {
-        "every": "10m",
-        "target": "last",
-        "directPolicy": "allow"
-      },
-      "sandbox": {
-        "mode": "all",
-        "workspaceAccess": "rw",
-        "scope": "agent",
-        "docker": {
-          "image": "your-registry.com/openclaw-agent:v2026.x.x",
-          "readOnlyRoot": false,
-          "network": "bridge",
-          "extraHosts": [
-            "your-domain.internal:xxx.xxx.xxx.xxx"
-          ],
-          "binds": [
-            "/path/to/skills:/workspace/skills:ro"
-          ],
-          "dangerouslyAllowReservedContainerTargets": true,
-          "dangerouslyAllowExternalBindSources": true
-        },
-        "prune": {
-          "idleHours": 87600,
-          "maxAgeDays": 3650
-        }
-      }
-    },
-    "list": [
-      { "id": "main" },
-      { "id": "wecom-dm-xxxxxx" }
-    ]
-  },
-  "commands": {
-    "native": "auto",
-    "nativeSkills": "auto",
-    "restart": true,
-    "ownerDisplay": "raw"
-  },
-  "session": {
-    "dmScope": "per-channel-peer"
-  },
-  "hooks": {
-    "internal": {
-      "enabled": true,
-      "entries": {
-        "boot-md": { "enabled": true },
-        "command-logger": { "enabled": true },
-        "session-memory": { "enabled": true },
-        "bootstrap-extra-files": { "enabled": true }
-      }
-    }
-  },
-  "channels": {
-    "wecom": {
-      "enabled": true,
-      "token": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-      "encodingAesKey": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-      "commands": {
-        "enabled": true,
-        "allowlist": ["/help", "/commands", "/status", "/context", "/whoami", "/new", "/compact", "/stop", "/reset", "/usage", "/think", "/thinking", "/t", "/verbose", "/v", "/reasoning", "/reason", "/model", "/models", "/skill"]
-      },
-      "dynamicAgents": { "enabled": true },
-      "dm": { "createAgentOnFirstMessage": true },
-      "groupChat": { "enabled": true, "requireMention": true },
-      "adminUsers": ["admin_userid"],
-      "workspaceTemplate": "/path/to/workspace-template",
-      "agent": {
-        "corpId": "wwxxxxxxxxxxxxxxxx",
-        "corpSecret": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
-        "agentId": 1000002,
-        "token": "xxxxxxxxxxxxxxx",
-        "encodingAesKey": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-      }
-    }
-  },
-  "gateway": {
-    "port": 18789,
-    "mode": "local",
-    "bind": "lan",
-    "controlUi": {
-      "dangerouslyAllowHostHeaderOriginFallback": true,
-      "allowInsecureAuth": true
-    },
-    "auth": {
-      "mode": "token",
-      "token": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-    },
-    "tailscale": {
-      "mode": "off",
-      "resetOnExit": false
-    }
-  },
-  "skills": {
-    "allowBundled": ["_none_"],
-    "load": {
-      "extraDirs": ["/path/to/skills"],
-      "watch": true,
-      "watchDebounceMs": 250
-    },
-    "install": { "nodeManager": "npm" }
-  },
-  "plugins": {
-    "allow": ["wecom"],
-    "entries": { "wecom": { "enabled": true } }
-  }
-}
-```
-
 ## 自定义 Skills 配合沙箱使用实践
 
 OpenClaw 支持自定义 Skills 并通过沙箱（Docker）隔离执行，以下是生产环境的实践配置：

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@sunnoy/wecom",
-    "version": "1.6.2",
+    "version": "1.7.1",
     "description": "Enterprise WeChat AI Bot channel plugin for OpenClaw",
     "type": "module",
     "main": "index.js",
@@ -15,6 +15,7 @@
         "LICENSE",
         "CONTRIBUTING.md",
         "stream-manager.js",
+        "think-parser.js",
         "utils.js",
         "webhook.js",
         "openclaw.plugin.json"

package/think-parser.js

@@ -0,0 +1,119 @@
+/**
+ * Parse <think>...</think> tags from LLM output.
+ *
+ * Separates content into visible text and thinking process for WeCom's
+ * thinking_content stream field. Handles streaming (unclosed tags) and
+ * ignores tags inside code blocks.
+ */
+
+const QUICK_TAG_RE = /<\s*\/?\s*(?:think(?:ing)?|thought)\b/i;
+const THINK_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought)\b[^<>]*>/gi;
+
+/**
+ * Find code regions (``` blocks and `inline`) to avoid processing think tags
+ * that appear inside code.
+ * @param {string} text
+ * @returns {Array<[number, number]>}
+ */
+function findCodeRegions(text) {
+  const regions = [];
+  // Fenced code blocks (triple backtick).
+  const blockRe = /```[\s\S]*?```/g;
+  for (const m of text.matchAll(blockRe)) {
+    regions.push([m.index, m.index + m[0].length]);
+  }
+  // Inline code (single backtick, same line).
+  const inlineRe = /`[^`\n]+`/g;
+  for (const m of text.matchAll(inlineRe)) {
+    if (!isInsideRegion(m.index, regions)) {
+      regions.push([m.index, m.index + m[0].length]);
+    }
+  }
+  return regions;
+}
+
+/**
+ * @param {number} pos
+ * @param {Array<[number, number]>} regions
+ */
+function isInsideRegion(pos, regions) {
+  for (const [start, end] of regions) {
+    if (pos >= start && pos < end) return true;
+  }
+  return false;
+}
+
+/**
+ * Parse thinking content from text that may contain <think>...</think> tags.
+ *
+ * @param {string} text - Raw accumulated stream text
+ * @returns {{ visibleContent: string, thinkingContent: string, isThinking: boolean }}
+ *   - visibleContent: text with think blocks removed (for content field)
+ *   - thinkingContent: concatenated thinking text (for thinking_content field)
+ *   - isThinking: true when an unclosed <think> tag is present (streaming)
+ */
+export function parseThinkingContent(text) {
+  if (!text) {
+    return { visibleContent: "", thinkingContent: "", isThinking: false };
+  }
+
+  // Fast path: no think tags at all.
+  if (!QUICK_TAG_RE.test(text)) {
+    return { visibleContent: text, thinkingContent: "", isThinking: false };
+  }
+
+  const codeRegions = findCodeRegions(text);
+
+  const visibleParts = [];
+  const thinkingParts = [];
+  let lastIndex = 0;
+  let inThinking = false;
+
+  THINK_TAG_RE.lastIndex = 0;
+  for (const match of text.matchAll(THINK_TAG_RE)) {
+    const idx = match.index;
+    const isClose = match[1] === "/";
+
+    // Skip tags inside code blocks.
+    if (isInsideRegion(idx, codeRegions)) {
+      continue;
+    }
+
+    const segment = text.slice(lastIndex, idx);
+
+    if (!inThinking) {
+      if (!isClose) {
+        // Opening <think>: preceding text is visible.
+        visibleParts.push(segment);
+        inThinking = true;
+      } else {
+        // Stray </think> without opening: treat as visible text.
+        visibleParts.push(segment);
+      }
+    } else {
+      if (isClose) {
+        // Closing </think>: text since opening is thinking content.
+        thinkingParts.push(segment);
+        inThinking = false;
+      }
+      // Nested or duplicate opening tag inside thinking: ignore.
+    }
+
+    lastIndex = idx + match[0].length;
+  }
+
+  // Remaining text after the last tag.
+  const remaining = text.slice(lastIndex);
+  if (inThinking) {
+    // Unclosed <think>: remaining text is part of thinking (streaming state).
+    thinkingParts.push(remaining);
+  } else {
+    visibleParts.push(remaining);
+  }
+
+  return {
+    visibleContent: visibleParts.join("").trim(),
+    thinkingContent: thinkingParts.join("\n").trim(),
+    isThinking: inThinking,
+  };
+}

package/webhook.js

@@ -435,7 +435,12 @@ export class WecomWebhook {
       content: content,
     };
 
-    // Optional mixed media list (images are valid on finished responses).
+    // Thinking content for model reasoning display (collapsible in WeCom client).
+    if (options.thinkingContent) {
+      stream.thinking_content = options.thinkingContent;
+    }
+
+    // Optional mixed media list (images are valid only on finished responses).
     if (options.msgItem && options.msgItem.length > 0) {
       stream.msg_item = options.msgItem;
     }

package/wecom/agent-inbound.js

@@ -43,6 +43,7 @@ import {
 
 const RECENT_MSGID_TTL_MS = 10 * 60 * 1000;
 const recentAgentMsgIds = new Map();
+const AGENT_INBOUND_ALLOWED_MSG_TYPES = new Set(["text", "image", "voice", "video", "file"]);
 
 function rememberAgentMsgId(msgId) {
   const now = Date.now();
@@ -157,6 +158,21 @@ async function handleMessageCallback(req, res, crypto, agentConfig, config, acco
     const msgId = extractMsgId(msg);
     const content = extractContent(msg);
 
+    // White-list inbound message types to prevent event callbacks
+    // (for example subscribe/unsubscribe) from triggering LLM replies.
+    if (!AGENT_INBOUND_ALLOWED_MSG_TYPES.has(msgType)) {
+      logger.info("[agent-inbound] unsupported msgType ignored", {
+        msgType,
+        fromUser,
+        chatId: chatId || "N/A",
+        msgId: msgId || "N/A",
+        contentPreview: content.substring(0, 100),
+      });
+      res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
+      res.end("success");
+      return true;
+    }
+
     // Deduplication
     if (msgId) {
       if (!rememberAgentMsgId(msgId)) {

package/wecom/channel-plugin.js

@@ -282,12 +282,20 @@ export const wecomChannelPlugin = {
       // `to` format: "wecom:userid" or "userid".
       const userId = to.replace(/^wecom:/, "");
 
-      // Prefer stream from async context (correct for concurrent processing).
+      // Prefer async-context stream only when it is still writable.
+      // If the context stream already finished (common with concurrent messages),
+      // fall back to the latest recoverable active stream for this user/group.
       const ctx = streamContext.getStore();
-      const streamId = ctx?.streamId ?? resolveRecoverableStream(userId);
+      const ctxStreamId = ctx?.streamId ?? null;
+      const ctxStream = ctxStreamId ? streamManager.getStream(ctxStreamId) : null;
+      const canUseCtxStream = !!(ctxStreamId && ctxStream && !ctxStream.finished);
+      const streamId = canUseCtxStream ? ctxStreamId : resolveRecoverableStream(userId);
+      const streamObj = streamId ? streamManager.getStream(streamId) : null;
+      const hasStream = streamId ? streamManager.hasStream(streamId) : false;
+      const finished = streamObj?.finished ?? true;
 
       // Layer 1: Active stream (normal path)
-      if (streamId && streamManager.hasStream(streamId) && !streamManager.getStream(streamId)?.finished) {
+      if (streamId && hasStream && !finished) {
         logger.debug("Appending outbound text to stream", {
           userId,
           streamId,
@@ -303,6 +311,19 @@ export const wecomChannelPlugin = {
         };
       }
 
+      // Log stream miss details for debugging concurrent-message issues.
+      logger.warn("WeCom sendText: Layer 1 stream miss", {
+        userId,
+        streamId: streamId ?? null,
+        hasStream,
+        finished,
+        hasAsyncContext: !!ctx,
+        ctxStreamId,
+        canUseCtxStream,
+        ctxStreamKey: ctx?.streamKey ?? null,
+        textPreview: text.substring(0, 50),
+      });
+
       // Layer 2: Fallback via response_url
       // response_url is valid for 1 hour and can be used only once.
       // responseUrls is keyed by streamKey (fromUser for DM, chatId for group).
@@ -312,7 +333,7 @@ export const wecomChannelPlugin = {
           const response = await wecomFetch(saved.url, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ msgtype: "text", text: { content: text } }),
+            body: JSON.stringify({ msgtype: "markdown", markdown: { content: text } }),
           });
           const responseBody = await response.text().catch(() => "");
           const result = parseResponseUrlResult(response, responseBody);
@@ -400,11 +421,14 @@ export const wecomChannelPlugin = {
     sendMedia: async ({ cfg: _cfg, to, text, mediaUrl, accountId: _accountId }) => {
       const userId = to.replace(/^wecom:/, "");
 
-      // Prefer stream from async context (correct for concurrent processing).
+      // Prefer async-context stream only when it is still writable.
       const ctx = streamContext.getStore();
-      const streamId = ctx?.streamId ?? resolveRecoverableStream(userId);
+      const ctxStreamId = ctx?.streamId ?? null;
+      const ctxStream = ctxStreamId ? streamManager.getStream(ctxStreamId) : null;
+      const canUseCtxStream = !!(ctxStreamId && ctxStream && !ctxStream.finished);
+      const streamId = canUseCtxStream ? ctxStreamId : resolveRecoverableStream(userId);
 
-      if (streamId && streamManager.hasStream(streamId)) {
+      if (streamId && streamManager.hasStream(streamId) && !streamManager.getStream(streamId)?.finished) {
         // Check if mediaUrl is a local path (sandbox: prefix or absolute path)
         const isLocalPath = mediaUrl.startsWith("sandbox:") || mediaUrl.startsWith("/");
 

package/wecom/http-handler-state.js

@@ -0,0 +1,23 @@
+/**
+ * Shared flag that tracks whether the legacy wildcard HTTP handler was
+ * successfully registered via api.registerHttpHandler().
+ *
+ * When true, gateway.startAccount must NOT also register via
+ * registerPluginHttpRoute — the latter places the path into
+ * registry.httpRoutes which causes shouldEnforceGatewayAuthForPluginPath
+ * → isRegisteredPluginHttpRoutePath to return true → gateway auth
+ * enforcement runs → WeCom webhook callbacks (which carry msg_signature,
+ * not Bearer tokens) get blocked with 401.
+ *
+ * This module is intentionally separate from index.js to avoid circular
+ * ESM imports (index.js ↔ wecom/channel-plugin.js).
+ */
+let _wildcardHttpHandlerRegistered = false;
+
+export function markWildcardHttpHandlerRegistered() {
+  _wildcardHttpHandlerRegistered = true;
+}
+
+export function isWildcardHttpHandlerRegistered() {
+  return _wildcardHttpHandlerRegistered;
+}

package/wecom/http-handler.js

@@ -1,6 +1,7 @@
 import * as crypto from "node:crypto";
 import { logger } from "../logger.js";
 import { streamManager } from "../stream-manager.js";
+import { parseThinkingContent } from "../think-parser.js";
 import { WecomWebhook } from "../webhook.js";
 import { handleAgentInbound } from "./agent-inbound.js";
 import { extractLeadingSlashCommand, isHighPriorityCommand } from "./commands.js";
@@ -151,9 +152,16 @@ async function handleWecomRequest(req, res, targets, query, path) {
       streamManager.createStream(streamId);
       streamManager.appendStream(streamId, THINKING_PLACEHOLDER);
 
-      // Passive reply: return stream id immediately in the sync response.
-      // Include the placeholder so the client displays it right away.
-      const streamResponse = webhook.buildStreamResponse(streamId, THINKING_PLACEHOLDER, false, timestamp, nonce);
+      // Passive reply: return stream id with thinking_content so the WeCom
+      // client shows the collapsible "thinking" UI while the LLM processes.
+      const streamResponse = webhook.buildStreamResponse(
+        streamId,
+        "",
+        false,
+        timestamp,
+        nonce,
+        { thinkingContent: THINKING_PLACEHOLDER },
+      );
 
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(streamResponse);
@@ -266,15 +274,31 @@ async function handleWecomRequest(req, res, targets, query, path) {
         }
       }
 
+      // Parse thinking tags from accumulated content so WeCom can display
+      // the model's reasoning in a collapsible section.
+      const { visibleContent, thinkingContent, isThinking } =
+        parseThinkingContent(stream.content);
+
+      // While the model is still thinking (unclosed <think> tag) and there is
+      // no visible content yet, keep showing the placeholder in thinking_content.
+      const effectiveThinking =
+        thinkingContent || (isThinking ? THINKING_PLACEHOLDER : "");
+
       // Return current stream payload.
       const streamResponse = webhook.buildStreamResponse(
         streamId,
-        stream.content,
+        visibleContent,
         stream.finished,
         timestamp,
         nonce,
-        // Pass msgItem when stream is finished and has images
-        stream.finished && stream.msgItem.length > 0 ? { msgItem: stream.msgItem } : {},
+        {
+          // Pass msgItem only when stream is finished and has images.
+          ...(stream.finished && stream.msgItem.length > 0
+            ? { msgItem: stream.msgItem }
+            : {}),
+          // Include thinking content when available.
+          ...(effectiveThinking ? { thinkingContent: effectiveThinking } : {}),
+        },
       );
 
       res.writeHead(200, { "Content-Type": "application/json" });

package/wecom/inbound-processor.js

@@ -443,7 +443,7 @@ export async function processInboundMessage({
           }
           unregisterActiveStream(streamKey, streamId);
         }
-      }, 3000); // 3s grace after last delivery
+      }, 200); // short grace for I/O flush; dispatcher is already done
     };
 
     // Dispatch reply with AI processing.
@@ -482,14 +482,6 @@ export async function processInboundMessage({
               });
             }
 
-            // Mark stream meta when main response is done.
-            if (streamId && (info.kind === "final" || info.kind === "block")) {
-              streamMeta.set(streamId, {
-                mainResponseDone: true,
-                doneAt: Date.now(),
-              });
-            }
-
             // Schedule / reset stream close timer if dispatch already returned.
             if (streamId && dispatchDone) {
               scheduleStreamClose();
@@ -503,10 +495,17 @@ export async function processInboundMessage({
       });
     });
 
-    // Dispatch returned.
+    // Dispatch returned — the entire LLM turn (all blocks, tool calls,
+    // and final payloads) is complete.  Mark mainResponseDone now so the
+    // idle-close timer in http-handler only starts after there is truly
+    // no more content to deliver.
     dispatchDone = true;
 
     if (streamId) {
+      streamMeta.set(streamId, {
+        mainResponseDone: true,
+        doneAt: Date.now(),
+      });
       const stream = streamManager.getStream(streamId);
       if (!stream || stream.finished) {
         unregisterActiveStream(streamKey, streamId);

package/wecom/outbound-delivery.js

@@ -1,4 +1,4 @@
-import { readFile, stat } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { basename, isAbsolute, relative, resolve, sep } from "node:path";
 import { logger } from "../logger.js";
 import { streamManager } from "../stream-manager.js";
@@ -109,8 +109,8 @@ export async function deliverWecomReply({ payload, senderId, streamId, agentId }
   });
 
   // Handle absolute-path MEDIA lines manually; OpenClaw rejects these paths upstream.
-  // Match both line-start (^MEDIA:) and inline (…MEDIA:) patterns.
-  const mediaRegex = /(?:^|(?<=\s))MEDIA:\s*(.+?)$/gm;
+  // Match only line-start MEDIA directives to align with upstream OpenClaw.
+  const mediaRegex = /^MEDIA:\s*(.+?)$/gm;
   const mediaMatches = [];
   let match;
   while ((match = mediaRegex.exec(text)) !== null) {
@@ -312,114 +312,6 @@ export async function deliverWecomReply({ payload, senderId, streamId, agentId }
     }
   }
 
-  // ──────────────────────────────────────────────────────────────────────────
-  // Auto-detect /workspace/… file paths in LLM reply text.
-  // The sandbox container mounts /workspace → host ~/.openclaw/workspace-{agentId}.
-  // When the LLM mentions a file path like "/workspace/report.pdf", we resolve
-  // the host-side path, verify the file exists, and send it via Agent DM.
-  // ──────────────────────────────────────────────────────────────────────────
-  if (effectiveAgentId && processedText) {
-    // Match /workspace/ paths (non-greedy: stop at whitespace, quotes, backticks,
-    // angle brackets, parentheses, or end of string).
-    const workspacePathRegex = /\/workspace\/[^\s"'`<>()]+/g;
-    const detectedPaths = [];
-    let wpMatch;
-    while ((wpMatch = workspacePathRegex.exec(processedText)) !== null) {
-      const rawPath = wpMatch[0]
-        // Strip trailing punctuation that is likely not part of the filename.
-        .replace(/[.,;:!?。，；：！？）》」』\]]+$/, "");
-      if (rawPath.length > "/workspace/".length) {
-        detectedPaths.push(rawPath);
-      }
-    }
-
-    if (detectedPaths.length > 0) {
-      const workspaceDir = resolveAgentWorkspaceDirLocal(effectiveAgentId);
-      const agentCfgAuto = resolveAgentConfig();
-      const imageExtsAuto = new Set(["jpg", "jpeg", "png", "gif", "bmp", "webp"]);
-
-      for (const wsPath of detectedPaths) {
-        // /workspace/foo.pdf → hostDir/foo.pdf (with traversal guard)
-        const hostPath = resolveWorkspaceHostPathSafe({
-          workspaceDir,
-          workspacePath: wsPath,
-        });
-        if (!hostPath) {
-          processedText = processedText.replace(wsPath, "⚠️ 检测到不安全的 /workspace/ 路径，已拒绝发送");
-          logger.warn("Auto-detect: rejected unsafe /workspace/ path", {
-            streamId,
-            wsPath,
-            workspaceDir,
-          });
-          continue;
-        }
-        const filename = basename(hostPath);
-        const ext = filename.split(".").pop()?.toLowerCase() || "";
-
-        // Skip image files — they are handled by the stream msg_item mechanism.
-        if (imageExtsAuto.has(ext)) continue;
-
-        // Check the path exists on host and is a regular file.
-        try {
-          const st = await stat(hostPath);
-          if (!st.isFile()) {
-            logger.debug("Auto-detect: path is not a regular file, skipping", {
-              wsPath,
-              hostPath,
-            });
-            continue;
-          }
-        } catch {
-          logger.debug("Auto-detect: workspace file not found on host, skipping", {
-            wsPath,
-            hostPath,
-          });
-          continue;
-        }
-
-        // File exists on host — send via Agent DM.
-        if (agentCfgAuto && senderId) {
-          try {
-            const hint = await uploadAndSendFile({
-              hostPath,
-              filename,
-              agent: agentCfgAuto,
-              senderId,
-              streamId,
-            });
-            // Replace the path mention in text with a delivery hint.
-            // Also strip any preceding "MEDIA:" prefix if the LLM wrote "MEDIA:/workspace/…".
-            const escapedPath = wsPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-            const withMediaPrefix = new RegExp(`MEDIA:\\s*${escapedPath}`, "g");
-            if (withMediaPrefix.test(processedText)) {
-              processedText = processedText.replace(withMediaPrefix, hint);
-            } else {
-              processedText = processedText.replace(wsPath, hint);
-            }
-            logger.info("Auto-detect: sent workspace file via Agent DM", {
-              streamId,
-              wsPath,
-              hostPath,
-              filename,
-              senderId,
-            });
-          } catch (autoErr) {
-            processedText = processedText.replace(
-              wsPath,
-              `⚠️ 文件「${filename}」发送失败：${autoErr.message}`,
-            );
-            logger.error("Auto-detect: failed to send workspace file via Agent DM", {
-              streamId,
-              wsPath,
-              hostPath,
-              error: autoErr.message,
-            });
-          }
-        }
-      }
-    }
-  }
-
   // All outbound content is sent via stream updates.
   if (!processedText.trim()) {
     logger.debug("WeCom: empty block after processing, skipping stream update");
@@ -482,7 +374,7 @@ export async function deliverWecomReply({ payload, senderId, streamId, agentId }
         const response = await wecomFetch(saved.url, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ msgtype: "text", text: { content: processedText } }),
+          body: JSON.stringify({ msgtype: "markdown", markdown: { content: processedText } }),
         });
         const responseBody = await response.text().catch(() => "");
         const result = parseResponseUrlResult(response, responseBody);

package/wecom/stream-utils.js

@@ -26,6 +26,12 @@ export function registerActiveStream(streamKey, streamId) {
   activeStreamHistory.set(streamKey, deduped);
   activeStreams.set(streamKey, streamId);
   lastStreamByKey.set(streamKey, streamId);
+  logger.info("registerActiveStream", {
+    streamKey,
+    streamId,
+    historySize: deduped.length,
+    history: deduped,
+  });
 }
 
 export function unregisterActiveStream(streamKey, streamId) {
@@ -38,6 +44,7 @@ export function unregisterActiveStream(streamKey, streamId) {
     if (activeStreams.get(streamKey) === streamId) {
       activeStreams.delete(streamKey);
     }
+    logger.info("unregisterActiveStream (empty history)", { streamKey, streamId });
     return;
   }
 
@@ -45,11 +52,18 @@ export function unregisterActiveStream(streamKey, streamId) {
   if (remaining.length === 0) {
     activeStreamHistory.delete(streamKey);
     activeStreams.delete(streamKey);
+    logger.info("unregisterActiveStream (last stream)", { streamKey, streamId });
     return;
   }
 
   activeStreamHistory.set(streamKey, remaining);
   activeStreams.set(streamKey, remaining[remaining.length - 1]);
+  logger.info("unregisterActiveStream", {
+    streamKey,
+    streamId,
+    remainingSize: remaining.length,
+    remaining,
+  });
 }
 
 export function resolveActiveStream(streamKey) {