@dingxiang-me/openclaw-wechat 1.7.2 → 2.0.0

package/src/wecom/bot-reply-runtime.js

@@ -4,6 +4,13 @@ function assertFunction(name, value) {
   }
 }
 
+function isTimeoutLikeReason(reason) {
+  return String(reason?.message || reason || "")
+    .trim()
+    .toLowerCase()
+    .includes("timed out");
+}
+
 export function createWecomBotDispatchState() {
   return {
     blockText: "",
@@ -49,6 +56,7 @@ export function createWecomBotLateReplyRuntime({
   safeDeliverReply,
   runLateReplyWatcher,
   activeWatchers,
+  clearSessionStoreEntry = null,
   now = () => Date.now(),
   randomToken = () => Math.random().toString(36).slice(2, 8),
 } = {}) {
@@ -64,6 +72,24 @@ export function createWecomBotLateReplyRuntime({
 
   let lateReplyWatcherPromise = null;
 
+  const autoResetTimedOutSession = async (reason) => {
+    if (typeof clearSessionStoreEntry !== "function" || !isTimeoutLikeReason(reason)) return false;
+    try {
+      const result = await clearSessionStoreEntry({
+        storePath,
+        sessionKey: sessionId,
+        logger,
+      });
+      logger?.info?.(
+        `wecom(bot): auto-reset timed out session=${sessionId} cleared=${result?.cleared === true ? "yes" : "no"}`,
+      );
+      return result?.cleared === true;
+    } catch (err) {
+      logger?.warn?.(`wecom(bot): failed to auto-reset timed out session=${sessionId}: ${String(err?.message || err)}`);
+      return false;
+    }
+  };
+
   const readTranscriptFallbackResult = async ({
     runtimeStorePath = storePath,
     runtimeSessionId = sessionId,
@@ -128,12 +154,16 @@ export function createWecomBotLateReplyRuntime({
         if (dispatchState.streamFinished) return;
         const reasonText = String(watchErr?.message || watchErr || "");
         const isTimeout = reasonText.includes("timed out");
-        await safeDeliverReply(
-          isTimeout
-            ? "抱歉，当前模型请求超时或网络不稳定，请稍后重试。"
-            : `抱歉，当前模型请求超时或网络不稳定，请稍后重试。\n故障信息: ${reasonText.slice(0, 160)}`,
-          isTimeout ? "late-timeout-fallback" : "late-watcher-error",
-        );
+        try {
+          await safeDeliverReply(
+            isTimeout
+              ? "抱歉，当前模型请求超时或网络不稳定，请稍后重试。"
+              : `抱歉，当前模型请求超时或网络不稳定，请稍后重试。\n故障信息: ${reasonText.slice(0, 160)}`,
+            isTimeout ? "late-timeout-fallback" : "late-watcher-error",
+          );
+        } finally {
+          await autoResetTimedOutSession(reasonText);
+        }
       },
     }).finally(() => {
       lateReplyWatcherPromise = null;

package/src/wecom/bot-runtime-context.js

@@ -16,6 +16,7 @@ export async function prepareWecomBotRuntimeContext({
   msgId = "",
   messageText = "",
   commandBody = "",
+  commandAuthorized = false,
   originalContent = "",
   fromAddress = "",
   groupChatPolicy = {},
@@ -82,6 +83,8 @@ export async function prepareWecomBotRuntimeContext({
       messageText,
       originalContent,
       commandBody,
+      commandAuthorized,
+      commandSource: commandAuthorized ? "text" : "",
       fromAddress,
       sessionId,
       accountId,

package/src/wecom/bot-state-store.js

@@ -84,13 +84,13 @@ export function createWecomBotStateStore({
     return stream;
   }
 
-  function updateStream(streamId, content, { append = false, finished = false, msgItem } = {}) {
-    return streamManager.update(streamId, content, { append, finished, msgItem });
+  function updateStream(streamId, content, { append = false, finished = false, msgItem, thinkingContent } = {}) {
+    return streamManager.update(streamId, content, { append, finished, msgItem, thinkingContent });
   }
 
-  function finishStream(streamId, content, { msgItem } = {}) {
+  function finishStream(streamId, content, { msgItem, thinkingContent } = {}) {
     const normalizedStreamId = String(streamId ?? "").trim();
-    const stream = streamManager.finish(normalizedStreamId, content, { msgItem });
+    const stream = streamManager.finish(normalizedStreamId, content, { msgItem, thinkingContent });
     if (stream) {
       const sessionId = streamToSession.get(normalizedStreamId);
       if (sessionId) unregisterActiveStream(sessionId, normalizedStreamId);
@@ -184,4 +184,3 @@ export function createWecomBotStateStore({
     startCleanup,
   };
 }
-

package/src/wecom/bot-webhook-dispatch.js

@@ -25,6 +25,7 @@ function buildEncryptedStreamPayload({
   content,
   finish,
   msgItem,
+  thinkingContent,
   feedbackId,
 }) {
   const streamPayload = {
@@ -35,6 +36,9 @@ function buildEncryptedStreamPayload({
   if (Array.isArray(msgItem) && msgItem.length > 0) {
     streamPayload.msg_item = msgItem;
   }
+  if (String(thinkingContent ?? "").trim()) {
+    streamPayload.thinking_content = String(thinkingContent).trim();
+  }
   if (feedbackId) {
     streamPayload.feedback = { id: feedbackId };
   }
@@ -113,6 +117,7 @@ export function createWecomBotParsedDispatcher({
       content: stream?.content ?? "会话已过期",
       finish: stream ? stream.finished === true : true,
       msgItem: stream?.msgItem,
+      thinkingContent: stream?.thinkingContent,
       feedbackId,
     });
     sendEncryptedJson(res, encryptedResponse);

package/src/wecom/bot-webhook-handler.js

@@ -1,5 +1,6 @@
 import crypto from "node:crypto";
 import { createWecomBotParsedDispatcher } from "./bot-webhook-dispatch.js";
+import { markWecomInboundActivity } from "./channel-status-state.js";
 
 export function createWecomBotWebhookHandler({
   api,
@@ -167,6 +168,10 @@ export function createWecomBotWebhookHandler({
       const parsed = parseWecomBotInboundMessage(incomingPayload);
       if (parsed && typeof parsed === "object") {
         parsed.accountId = String(matchedBotConfig.accountId ?? "default").trim().toLowerCase() || "default";
+        markWecomInboundActivity({
+          accountId: parsed.accountId,
+          timestamp: incomingPayload?.create_time ?? incomingPayload?.CreateTime,
+        });
       }
       api.logger.info?.(
         `wecom(bot): inbound ${describeWecomBotParsedMessage(parsed)} account=${matchedBotConfig.accountId || "default"}`,

package/src/wecom/callback-health-diagnostics.js

@@ -0,0 +1,86 @@
+function previewBody(body, maxLength = 120) {
+  return String(body ?? "").slice(0, Math.max(1, maxLength));
+}
+
+function isHtmlBody(body) {
+  return /<!doctype html|<html/i.test(String(body ?? ""));
+}
+
+export function diagnoseWecomCallbackHealth({
+  status,
+  body,
+  mode = "agent",
+  endpoint = "",
+  webhookPath = "",
+  gatewayPort = null,
+  location = "",
+} = {}) {
+  const rawBody = String(body ?? "");
+  const preview = previewBody(rawBody);
+  const normalizedMode = String(mode ?? "agent").trim().toLowerCase() === "bot" ? "bot" : "agent";
+  const healthyMarker = normalizedMode === "bot" ? "wecom bot webhook" : "wecom webhook";
+  const healthy = status === 200 && rawBody.toLowerCase().includes(healthyMarker);
+  if (healthy) {
+    return {
+      ok: true,
+      detail: `status=${status} body=${preview}`,
+      data: null,
+    };
+  }
+
+  const hints = [];
+  let reason = "unexpected-response";
+  const effectivePath = String(webhookPath ?? "").trim() || String(endpoint ?? "").trim() || "/";
+  const authScopeHint =
+    normalizedMode === "bot"
+      ? "为 /wecom/*（以及 legacy /webhooks/wecom*）单独放行，或使用独立回调域名/端口"
+      : "为 /wecom/*（以及 legacy /webhooks/app*）单独放行，或使用独立回调域名/端口";
+
+  if (status === 404) {
+    reason = "route-not-found";
+    hints.push(`路径 ${effectivePath} 未命中${normalizedMode === "bot" ? " Bot" : ""}回调路由`);
+  } else if (status === 401 || status === 403) {
+    reason = "gateway-auth";
+    hints.push("回调路径被 Gateway Auth / Zero Trust / 反向代理鉴权拦截");
+    hints.push("企业微信回调与健康探测必须直达 webhook 路径，不能要求 Authorization、Cookie 或交互登录");
+    hints.push(authScopeHint);
+  } else if ([301, 302, 303, 307, 308].includes(Number(status))) {
+    reason = "redirect-auth";
+    hints.push("回调路径发生了重定向，通常被登录页、SSO 或前端路由接管");
+    if (location) hints.push(`重定向目标：${location}`);
+    hints.push("请让 webhook 路径直接反代到 OpenClaw 网关，不要跳转到登录页或前端应用");
+  } else if (status === 502 || status === 503 || status === 504) {
+    reason = "gateway-unreachable";
+    if (gatewayPort != null) {
+      hints.push(`网关 ${gatewayPort} 端口不可达或反向代理后端异常`);
+    } else {
+      hints.push("网关端口不可达或反向代理后端异常");
+    }
+  } else if (status === 200 && isHtmlBody(rawBody)) {
+    reason = "html-fallback";
+    hints.push("返回了 WebUI HTML，通常表示 webhook 路由未注册或 webhookPath 配置不一致");
+    if (webhookPath) {
+      const configPathHint =
+        normalizedMode === "bot"
+          ? `请确认 channels.wecom.bot.webhookPath=${webhookPath} 与企业微信后台回调地址完全一致`
+          : `请确认 channels.wecom.webhookPath=${webhookPath} 与企业微信后台回调地址完全一致`;
+      hints.push(configPathHint);
+    }
+    hints.push("确认插件已加载：plugins.entries.openclaw-wechat.enabled=true 且 plugins.allow 包含 openclaw-wechat");
+  }
+
+  return {
+    ok: false,
+    detail: `status=${status} body=${preview}${hints.length > 0 ? ` hint=${hints.join("；")}` : ""}`,
+    data: {
+      status,
+      reason,
+      mode: normalizedMode,
+      endpoint: endpoint || null,
+      webhookPath: webhookPath || null,
+      gatewayPort: gatewayPort == null ? null : gatewayPort,
+      location: location || null,
+      hints,
+    },
+  };
+}

package/src/wecom/channel-config-schema.js

@@ -0,0 +1,242 @@
+import pluginManifest from "../../openclaw.plugin.json" with { type: "json" };
+
+function asObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+
+const manifestConfigSchema = asObject(pluginManifest?.configSchema);
+const manifestUiHints = asObject(pluginManifest?.uiHints) ?? {};
+
+const localizedUiHints = {
+  name: {
+    label: "渠道显示名",
+    help: "仅用于展示，不影响消息路由。",
+  },
+  enabled: {
+    label: "启用企业微信渠道",
+    help: "开启后才会接收/发送企业微信消息。",
+  },
+  corpId: {
+    label: "企业 ID（CorpId）",
+    placeholder: "wwxxxxxxxxxxxxxxxx",
+  },
+  corpSecret: {
+    label: "应用 Secret（CorpSecret）",
+    sensitive: true,
+  },
+  agentId: {
+    label: "应用 AgentId",
+    placeholder: "1000002",
+  },
+  callbackToken: {
+    label: "回调 Token",
+    sensitive: true,
+  },
+  callbackAesKey: {
+    label: "回调 EncodingAESKey",
+    sensitive: true,
+  },
+  webhookPath: {
+    label: "自建应用回调路径",
+    placeholder: "/wecom/callback",
+  },
+  outboundProxy: {
+    label: "WeCom 出站代理",
+    placeholder: "http://127.0.0.1:7890",
+  },
+  defaultAccount: {
+    label: "默认账号",
+    help: "文档工具等多账号能力未显式指定账号时优先使用该账号。",
+  },
+  tools: {
+    label: "工具能力",
+    help: "控制 OpenClaw 工具级能力是否启用。",
+  },
+  "tools.doc": {
+    label: "启用文档工具",
+  },
+  "tools.docAutoGrantRequesterCollaborator": {
+    label: "创建后自动加当前发送者为协作者",
+    help: "仅在 WeCom 会话中生效；创建文档后会把当前发送者自动加入协作者。",
+  },
+  accounts: {
+    label: "多账号配置",
+    help: "按账户 ID 管理多套企业微信配置。",
+  },
+  "accounts.*.enabled": {
+    label: "启用该账号",
+  },
+  "accounts.*.name": {
+    label: "账号名称",
+  },
+  "accounts.*.corpId": {
+    label: "账号 CorpId",
+  },
+  "accounts.*.corpSecret": {
+    label: "账号 CorpSecret",
+    sensitive: true,
+  },
+  "accounts.*.agentId": {
+    label: "账号 AgentId",
+  },
+  "accounts.*.callbackToken": {
+    label: "账号回调 Token",
+    sensitive: true,
+  },
+  "accounts.*.callbackAesKey": {
+    label: "账号回调 EncodingAESKey",
+    sensitive: true,
+  },
+  "accounts.*.webhookPath": {
+    label: "账号回调路径",
+  },
+  "accounts.*.tools": {
+    label: "账号工具能力",
+  },
+  "accounts.*.tools.doc": {
+    label: "启用该账号文档工具",
+  },
+  "accounts.*.tools.docAutoGrantRequesterCollaborator": {
+    label: "自动加当前发送者为协作者",
+  },
+  bot: {
+    label: "企业微信 Bot 模式",
+    help: "用于企业微信群机器人/Bot 回调与回包。",
+  },
+  "bot.enabled": {
+    label: "启用 Bot 模式",
+  },
+  "bot.token": {
+    label: "Bot Token",
+    sensitive: true,
+  },
+  "bot.encodingAesKey": {
+    label: "Bot EncodingAESKey",
+    sensitive: true,
+  },
+  "bot.webhookPath": {
+    label: "Bot 回调路径",
+    placeholder: "/wecom/bot/callback",
+  },
+  "bot.longConnection": {
+    label: "Bot 长连接",
+    help: "企业微信智能机器人长连接（WebSocket）模式，无需公网回调地址。",
+  },
+  "bot.longConnection.enabled": {
+    label: "启用 Bot 长连接",
+  },
+  "bot.longConnection.botId": {
+    label: "BotID",
+  },
+  "bot.longConnection.secret": {
+    label: "长连接 Secret",
+    sensitive: true,
+  },
+  "bot.longConnection.url": {
+    label: "长连接地址",
+    placeholder: "wss://openws.work.weixin.qq.com",
+  },
+  "bot.longConnection.pingIntervalMs": {
+    label: "心跳间隔（毫秒）",
+  },
+  "bot.longConnection.reconnectDelayMs": {
+    label: "重连基准延迟（毫秒）",
+  },
+  "bot.longConnection.maxReconnectDelayMs": {
+    label: "最大重连延迟（毫秒）",
+  },
+  "bot.replyTimeoutMs": {
+    label: "Bot 回复超时（毫秒）",
+  },
+  "bot.streamExpireMs": {
+    label: "Bot 流会话保留（毫秒）",
+  },
+  "bot.placeholderText": {
+    label: "Bot 首包占位文本",
+  },
+  "accounts.*.bot.longConnection": {
+    label: "账号 Bot 长连接",
+  },
+  "accounts.*.bot.longConnection.enabled": {
+    label: "启用该账号长连接",
+  },
+  "accounts.*.bot.longConnection.botId": {
+    label: "账号 BotID",
+  },
+  "accounts.*.bot.longConnection.secret": {
+    label: "账号长连接 Secret",
+    sensitive: true,
+  },
+  "accounts.*.bot.longConnection.url": {
+    label: "账号长连接地址",
+  },
+  "accounts.*.bot.longConnection.pingIntervalMs": {
+    label: "账号心跳间隔（毫秒）",
+  },
+  "accounts.*.bot.longConnection.reconnectDelayMs": {
+    label: "账号重连基准延迟（毫秒）",
+  },
+  "accounts.*.bot.longConnection.maxReconnectDelayMs": {
+    label: "账号最大重连延迟（毫秒）",
+  },
+  webhookBot: {
+    label: "Webhook Bot 出站回包",
+  },
+  "webhookBot.enabled": {
+    label: "启用 Webhook Bot 回包",
+  },
+  "webhookBot.url": {
+    label: "Webhook Bot URL",
+  },
+  "webhookBot.key": {
+    label: "Webhook Bot Key",
+    sensitive: true,
+  },
+  groupChat: {
+    label: "群聊触发策略",
+  },
+  "groupChat.triggerMode": {
+    label: "群聊触发模式",
+  },
+  dynamicAgent: {
+    label: "动态 Agent 路由",
+  },
+  dm: {
+    label: "私聊策略",
+  },
+  commands: {
+    label: "指令白名单",
+  },
+  events: {
+    label: "事件消息策略",
+  },
+  voiceTranscription: {
+    label: "语音转写",
+  },
+  "voiceTranscription.enabled": {
+    label: "启用语音转写",
+  },
+  "voiceTranscription.command": {
+    label: "本地转写命令",
+    placeholder: "whisper / whisper-cli",
+  },
+  "voiceTranscription.modelPath": {
+    label: "本地模型路径",
+  },
+  "voiceTranscription.language": {
+    label: "转写语言",
+    placeholder: "zh",
+  },
+};
+
+export const wecomChannelConfigSchema = manifestConfigSchema ?? {
+  type: "object",
+  additionalProperties: true,
+  properties: {},
+};
+
+export const wecomChannelConfigUiHints = {
+  ...manifestUiHints,
+  ...localizedUiHints,
+};

package/src/wecom/channel-plugin.js

@@ -1,9 +1,138 @@
+import { wecomChannelConfigSchema, wecomChannelConfigUiHints } from "./channel-config-schema.js";
+import {
+  getWecomChannelInboundActivity,
+  getWecomInboundActivity,
+} from "./channel-status-state.js";
+
 function assertFunction(name, fn) {
   if (typeof fn !== "function") {
     throw new Error(`createWecomChannelPlugin: ${name} is required`);
   }
 }
 
+function readString(value) {
+  const trimmed = String(value ?? "").trim();
+  return trimmed || "";
+}
+
+function readNumber(value) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : null;
+}
+
+function normalizeTimestampMs(value) {
+  if (value == null || value === "") return null;
+  const direct = Number(value);
+  if (Number.isFinite(direct) && direct > 0) {
+    return direct < 1e12 ? Math.floor(direct * 1000) : Math.floor(direct);
+  }
+  const parsed = Date.parse(String(value));
+  if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+  return null;
+}
+
+function resolveBotCallbackConfig(cfg, accountId = "default") {
+  const normalizedAccountId = readString(accountId).toLowerCase() || "default";
+  const channelConfig = cfg?.channels?.wecom;
+  const accountConfig = channelConfig?.accounts?.[normalizedAccountId];
+  const accountBot = accountConfig?.bot;
+  const channelBot = channelConfig?.bot;
+
+  const enabled =
+    accountBot?.enabled ??
+    channelBot?.enabled ??
+    false;
+  const token = readString(
+    accountBot?.token ??
+      accountBot?.callbackToken ??
+      channelBot?.token ??
+      channelBot?.callbackToken ??
+      channelConfig?.token ??
+      channelConfig?.callbackToken,
+  );
+  const aesKey = readString(
+    accountBot?.encodingAesKey ??
+      accountBot?.callbackAesKey ??
+      channelBot?.encodingAesKey ??
+      channelBot?.callbackAesKey ??
+      channelConfig?.encodingAesKey ??
+      channelConfig?.callbackAesKey,
+  );
+  const webhookPath = readString(
+    accountBot?.webhookPath ?? channelBot?.webhookPath,
+  );
+  const longConnection =
+    accountBot?.longConnection && typeof accountBot.longConnection === "object"
+      ? accountBot.longConnection
+      : channelBot?.longConnection && typeof channelBot.longConnection === "object"
+        ? channelBot.longConnection
+        : {};
+  const longConnectionEnabled = longConnection?.enabled === true;
+  const longConnectionBotId = readString(longConnection?.botId ?? longConnection?.botid);
+  const longConnectionSecret = readString(longConnection?.secret);
+
+  return {
+    enabled: enabled === true,
+    token,
+    aesKey,
+    webhookPath,
+    longConnectionEnabled,
+    longConnectionBotId,
+    longConnectionSecret,
+  };
+}
+
+function hasConfiguredBotCallback(cfg, accountId = "default") {
+  const bot = resolveBotCallbackConfig(cfg, accountId);
+  return (
+    bot.enabled &&
+    ((Boolean(bot.token) && Boolean(bot.aesKey)) ||
+      (bot.longConnectionEnabled && Boolean(bot.longConnectionBotId) && Boolean(bot.longConnectionSecret)))
+  );
+}
+
+function hasConfiguredAgentCredentials(account) {
+  return Boolean(
+    readString(account?.corpId) &&
+      readString(account?.corpSecret) &&
+      readNumber(account?.agentId),
+  );
+}
+
+function buildWecomAccountSnapshot(account, cfg, runtime = {}) {
+  const accountId = readString(account?.accountId).toLowerCase() || "default";
+  const agentConfigured = hasConfiguredAgentCredentials(account);
+  const botConfig = resolveBotCallbackConfig(cfg, accountId);
+  const botConfigured = hasConfiguredBotCallback(cfg, accountId);
+  const configured = agentConfigured || botConfigured;
+  const enabled = account?.enabled !== false;
+  const inboundActivity = getWecomInboundActivity(accountId);
+  const mode = agentConfigured && botConfigured ? "agent+bot" : botConfigured ? "bot" : "agent";
+  const running = runtime?.running ?? (enabled && configured);
+  const connected =
+    runtime?.connected ??
+    inboundActivity?.connected ??
+    (running && configured);
+  const lastInboundAt =
+    normalizeTimestampMs(runtime?.lastInboundAt ?? runtime?.lastInbound) ??
+    normalizeTimestampMs(inboundActivity?.lastInboundAtMs ?? inboundActivity?.lastInbound) ??
+    null;
+  const localizedName = accountId === "default" ? "默认账号" : accountId;
+  return {
+    ...runtime,
+    accountId,
+    name: readString(account?.name) || localizedName,
+    displayName: readString(account?.name) || localizedName,
+    enabled,
+    configured,
+    running,
+    connected,
+    lastInboundAt,
+    mode,
+    webhookPath: readString(account?.webhookPath) || botConfig.webhookPath || runtime?.webhookPath || undefined,
+  };
+}
+
 export function createWecomChannelPlugin({
   listWecomAccountIds,
   getWecomConfig,
@@ -29,12 +158,16 @@ export function createWecomChannelPlugin({
     id: "wecom",
     meta: {
       id: "wecom",
-      label: "WeCom",
-      selectionLabel: "WeCom (企业微信自建应用)",
+      label: "企业微信 WeCom",
+      selectionLabel: "企业微信 WeCom（自建应用/Bot）",
       docsPath: "/channels/wecom",
-      blurb: "Enterprise WeChat internal app via callback + send API.",
+      blurb: "企业微信消息通道（自建应用回调 + Bot 回调 + 发送 API）。",
       aliases: ["wework", "qiwei", "wxwork"],
     },
+    configSchema: {
+      schema: wecomChannelConfigSchema,
+      uiHints: wecomChannelConfigUiHints,
+    },
     capabilities: {
       chatTypes: ["direct", "group"],
       media: {
@@ -44,11 +177,36 @@ export function createWecomChannelPlugin({
       markdown: true,
     },
     config: {
-      listAccountIds: (cfg) => listWecomAccountIds({ config: cfg }),
+      listAccountIds: (cfg) => {
+        const accountIds = listWecomAccountIds({ config: cfg });
+        if (accountIds.length > 0) return accountIds;
+        return hasConfiguredBotCallback(cfg, "default") ? ["default"] : [];
+      },
       resolveAccount: (cfg, accountId) =>
         (getWecomConfig({ config: cfg }, accountId ?? "default") ?? {
           accountId: accountId ?? "default",
         }),
+      isConfigured: (account, cfg) =>
+        hasConfiguredAgentCredentials(account) || hasConfiguredBotCallback(cfg, account?.accountId ?? "default"),
+      describeAccount: (account, cfg) => buildWecomAccountSnapshot(account, cfg),
+    },
+    status: {
+      buildAccountSnapshot: ({ account, cfg, runtime }) =>
+        buildWecomAccountSnapshot(account, cfg, runtime),
+      buildChannelSummary: ({ snapshot }) => ({
+        configured: snapshot?.configured ?? false,
+        running: snapshot?.running ?? false,
+        connected:
+          snapshot?.connected ??
+          (snapshot?.running && snapshot?.configured) ??
+          null,
+        lastInbound:
+          normalizeTimestampMs(snapshot?.lastInboundAt ?? snapshot?.lastInbound) ??
+          normalizeTimestampMs(
+            getWecomChannelInboundActivity([snapshot?.accountId]).lastInboundAtMs,
+          ) ??
+          null,
+      }),
     },
     outbound: {
       deliveryMode: "direct",