@yanhaidao/wecom 2.3.180 → 2.3.260

package/src/runtime/source-registry.ts

@@ -7,14 +7,19 @@ export type WecomSourceSnapshot = {
   messageId?: string;
   sessionKey?: string;
   sessionId?: string;
+  peerKind?: "direct" | "group";
+  peerId?: string;
 };
 
 const MAX_MESSAGE_FACTS = 2048;
 const MAX_SESSION_SNAPSHOTS = 1024;
+const MAX_CONVERSATION_SNAPSHOTS = 1024;
 
 const messageFacts = new Map<string, WecomSourceSnapshot>();
 const sessionSnapshotsByAccountKey = new Map<string, WecomSourceSnapshot>();
 const sessionSnapshotsByLooseKey = new Map<string, WecomSourceSnapshot>();
+const conversationSnapshotsByAccountKey = new Map<string, WecomSourceSnapshot>();
+const conversationSnapshotsByLooseKey = new Map<string, WecomSourceSnapshot>();
 
 function normalizeOptional(value: string | null | undefined): string | undefined {
   const trimmed = String(value ?? "").trim();
@@ -33,6 +38,24 @@ function accountScopedSessionKey(
   return `${accountId}::${kind}::${value}`;
 }
 
+function normalizePeerId(value: string | null | undefined): string | undefined {
+  const trimmed = String(value ?? "").trim();
+  return trimmed ? trimmed.toLowerCase() : undefined;
+}
+
+function normalizePeerKind(value: string | null | undefined): "direct" | "group" | undefined {
+  const trimmed = String(value ?? "").trim().toLowerCase();
+  return trimmed === "direct" || trimmed === "group" ? trimmed : undefined;
+}
+
+function accountScopedConversationKey(
+  accountId: string,
+  peerKind: "direct" | "group",
+  peerId: string,
+): string {
+  return `${accountId}::peer::${peerKind}::${peerId}`;
+}
+
 function pruneOldest<T>(map: Map<string, T>, maxSize: number): void {
   while (map.size > maxSize) {
     const oldestKey = map.keys().next().value;
@@ -62,12 +85,37 @@ function writeSessionSnapshot(snapshot: WecomSourceSnapshot): void {
   pruneOldest(sessionSnapshotsByLooseKey, MAX_SESSION_SNAPSHOTS * 2);
 }
 
+function writeConversationSnapshot(snapshot: WecomSourceSnapshot): void {
+  const peerKind = normalizePeerKind(snapshot.peerKind);
+  const peerId = normalizePeerId(snapshot.peerId);
+  if (!peerKind || !peerId) {
+    return;
+  }
+  conversationSnapshotsByAccountKey.set(
+    accountScopedConversationKey(snapshot.accountId, peerKind, peerId),
+    {
+      ...snapshot,
+      peerKind,
+      peerId,
+    },
+  );
+  conversationSnapshotsByLooseKey.set(`peer::${peerKind}::${peerId}`, {
+    ...snapshot,
+    peerKind,
+    peerId,
+  });
+  pruneOldest(conversationSnapshotsByAccountKey, MAX_CONVERSATION_SNAPSHOTS);
+  pruneOldest(conversationSnapshotsByLooseKey, MAX_CONVERSATION_SNAPSHOTS);
+}
+
 export function registerWecomSourceSnapshot(params: {
   accountId: string;
   source: WecomSourcePlane;
   messageId?: string | null;
   sessionKey?: string | null;
   sessionId?: string | null;
+  peerKind?: "direct" | "group" | null;
+  peerId?: string | null;
 }): void {
   const accountId = normalizeOptional(params.accountId);
   if (!accountId) return;
@@ -85,6 +133,8 @@ export function registerWecomSourceSnapshot(params: {
     ...(normalizeOptional(params.sessionId)
       ? { sessionId: normalizeOptional(params.sessionId) }
       : {}),
+    ...(normalizePeerKind(params.peerKind) ? { peerKind: normalizePeerKind(params.peerKind) } : {}),
+    ...(normalizePeerId(params.peerId) ? { peerId: normalizePeerId(params.peerId) } : {}),
   };
 
   if (snapshot.messageId) {
@@ -93,16 +143,21 @@ export function registerWecomSourceSnapshot(params: {
   }
 
   writeSessionSnapshot(snapshot);
+  writeConversationSnapshot(snapshot);
 }
 
 export function resolveWecomSourceSnapshot(params: {
   accountId?: string | null;
   sessionKey?: string | null;
   sessionId?: string | null;
+  peerKind?: "direct" | "group" | null;
+  peerId?: string | null;
 }): WecomSourceSnapshot | undefined {
   const accountId = normalizeOptional(params.accountId);
   const sessionKey = normalizeOptional(params.sessionKey);
   const sessionId = normalizeOptional(params.sessionId);
+  const peerKind = normalizePeerKind(params.peerKind);
+  const peerId = normalizePeerId(params.peerId);
 
   if (accountId && sessionKey) {
     const scoped = sessionSnapshotsByAccountKey.get(
@@ -124,6 +179,16 @@ export function resolveWecomSourceSnapshot(params: {
     const loose = sessionSnapshotsByLooseKey.get(`sessionId::${sessionId}`);
     if (loose) return loose;
   }
+  if (accountId && peerKind && peerId) {
+    const scoped = conversationSnapshotsByAccountKey.get(
+      accountScopedConversationKey(accountId, peerKind, peerId),
+    );
+    if (scoped) return scoped;
+  }
+  if (peerKind && peerId) {
+    const loose = conversationSnapshotsByLooseKey.get(`peer::${peerKind}::${peerId}`);
+    if (loose) return loose;
+  }
   return undefined;
 }
 
@@ -146,12 +211,24 @@ export function clearWecomSourceAccount(accountId: string): void {
       sessionSnapshotsByLooseKey.delete(key);
     }
   }
+  for (const [key, value] of conversationSnapshotsByAccountKey) {
+    if (value.accountId === normalized || key.startsWith(`${normalized}::`)) {
+      conversationSnapshotsByAccountKey.delete(key);
+    }
+  }
+  for (const [key, value] of conversationSnapshotsByLooseKey) {
+    if (value.accountId === normalized) {
+      conversationSnapshotsByLooseKey.delete(key);
+    }
+  }
 }
 
 export function isWecomBotWsSource(params: {
   accountId?: string | null;
   sessionKey?: string | null;
   sessionId?: string | null;
+  peerKind?: "direct" | "group" | null;
+  peerId?: string | null;
 }): boolean {
   return resolveWecomSourceSnapshot(params)?.source === "bot-ws";
 }
@@ -160,6 +237,8 @@ export function isWecomAgentSource(params: {
   accountId?: string | null;
   sessionKey?: string | null;
   sessionId?: string | null;
+  peerKind?: "direct" | "group" | null;
+  peerId?: string | null;
 }): boolean {
   return resolveWecomSourceSnapshot(params)?.source === "agent-callback";
 }

package/src/runtime.ts

@@ -1,11 +1,14 @@
 export {
+  getActiveBotWsReplyHandle,
   getAccountRuntime,
   getAccountRuntimeSnapshot,
   getBotWsPushHandle,
   getWecomRuntime,
+  registerActiveBotWsReplyHandle,
   registerAccountRuntime,
   registerBotWsPushHandle,
   setWecomRuntime,
+  unregisterActiveBotWsReplyHandle,
   unregisterBotWsPushHandle,
   unregisterAccountRuntime,
 } from "./app/index.js";

package/src/target.ts

@@ -26,6 +26,18 @@ export interface ScopedWecomTarget {
     rawTarget: string;
 }
 
+export function buildWecomContextTarget(contextToken: string): string {
+    return `wecom:context:${contextToken}`;
+}
+
+export function resolveWecomContextTarget(raw: string | undefined): { contextToken: string } | undefined {
+    const trimmed = raw?.trim();
+    if (!trimmed) return undefined;
+    const match = trimmed.match(/^(?:wecom|wechatwork|wework|qywx):context:(.+)$/i);
+    const contextToken = match?.[1]?.trim();
+    return contextToken ? { contextToken } : undefined;
+}
+
 /**
  * Parses a raw target string into a WeComTarget object.
  * 解析原始目标字符串为 WeComTarget 对象。
@@ -86,16 +98,16 @@ export function resolveWecomTarget(raw: string | undefined, options?: { preferUs
         return { chatid: clean };
     }
 
-    // Pure digits: Default to Party (纯数字默认为部门)
-    // 原因：1) 定时任务可能直接配置 to: "1" 发送给根部门
-    //      2) 企业微信官方文档示例使用纯数字表示部门
-    //      3) 用户 ID 应该使用显式前缀 "user:xxx"
-    // 但如果 preferUserForDigits 为 true 则视为 User ID（用于 agent scoped 场景）
+    // Pure digits: Default to User (纯数字默认为用户)
+    // 原因：1) Bot WS 主动推送只接受 touser/chatid，不接受 toparty/totag
+    //      2) 用户 ID 在企业微信中常为纯数字
+    //      3) 部门推送应使用显式前缀 "party:xxx" 或通过 Agent 模式
+    // 如果确实需要发送到部门，请使用 party: 前缀或 Agent 路径
     if (/^\d+$/.test(clean)) {
-        if (options?.preferUserForDigits) {
-            return { touser: clean };
+        if (options?.preferUserForDigits === false) {
+            return { toparty: clean };
         }
-        return { toparty: clean };
+        return { touser: clean };
     }
 
     // Default to User (默认为用户)

package/src/transport/bot-webhook/inbound-normalizer.ts

@@ -257,7 +257,7 @@ export async function processBotInboundMessage(params: {
   const { target, msg, recordOperationalIssue } = params;
   const msgtype = String(msg.msgtype ?? "").toLowerCase();
   const aesKey = target.account.encodingAESKey;
-  const maxBytes = resolveWecomMediaMaxBytes(target.config);
+  const maxBytes = resolveWecomMediaMaxBytes(target.config, target.account.accountId);
   const proxyUrl = resolveWecomEgressProxyUrl(target.config);
 
   if (msgtype === "image") {
@@ -275,7 +275,7 @@ export async function processBotInboundMessage(params: {
         });
         return { body: "[image]", media: { buffer: decrypted.buffer, contentType: inferred.contentType, filename: inferred.filename } };
       } catch (err) {
-        target.runtime.error?.(`图片解密失败: ${String(err)}; 可调大 channels.wecom.media.maxBytes（当前=${maxBytes}）例如：openclaw config set channels.wecom.media.maxBytes ${50 * 1024 * 1024}`);
+        target.runtime.error?.(`图片解密失败: ${String(err)}; 可调大 channels.wecom.mediaMaxMb（当前=${Math.round(maxBytes / (1024 * 1024))}MB）例如：openclaw config set channels.wecom.mediaMaxMb 50`);
         recordOperationalIssue({
           category: "media-decrypt-failed",
           messageId: msg.msgid ? String(msg.msgid) : undefined,
@@ -304,7 +304,7 @@ export async function processBotInboundMessage(params: {
         });
         return { body: "[file]", media: { buffer: decrypted.buffer, contentType: inferred.contentType, filename: inferred.filename } };
       } catch (err) {
-        target.runtime.error?.(`Failed to decrypt inbound file: ${String(err)}; 可调大 channels.wecom.media.maxBytes（当前=${maxBytes}）例如：openclaw config set channels.wecom.media.maxBytes ${50 * 1024 * 1024}`);
+        target.runtime.error?.(`Failed to decrypt inbound file: ${String(err)}; 可调大 channels.wecom.mediaMaxMb（当前=${Math.round(maxBytes / (1024 * 1024))}MB）例如：openclaw config set channels.wecom.mediaMaxMb 50`);
         recordOperationalIssue({
           category: "media-decrypt-failed",
           messageId: msg.msgid ? String(msg.msgid) : undefined,
@@ -347,7 +347,7 @@ export async function processBotInboundMessage(params: {
               bodyParts.push(`[${t}]`);
               continue;
             } catch (err) {
-              target.runtime.error?.(`Failed to decrypt mixed ${t}: ${String(err)}; 可调大 channels.wecom.media.maxBytes（当前=${maxBytes}）例如：openclaw config set channels.wecom.media.maxBytes ${50 * 1024 * 1024}`);
+              target.runtime.error?.(`Failed to decrypt mixed ${t}: ${String(err)}; 可调大 channels.wecom.mediaMaxMb（当前=${Math.round(maxBytes / (1024 * 1024))}MB）例如：openclaw config set channels.wecom.mediaMaxMb 50`);
               recordOperationalIssue({
                 category: "media-decrypt-failed",
                 messageId: msg.msgid ? String(msg.msgid) : undefined,

package/src/transport/bot-ws/media.test.ts

@@ -0,0 +1,44 @@
+import type { WSClient } from "@wecom/aibot-node-sdk";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/media-runtime";
+
+import { uploadAndSendBotWsMedia } from "./media.js";
+
+vi.mock("openclaw/plugin-sdk/media-runtime", () => ({
+  detectMime: vi.fn(),
+  loadOutboundMediaFromUrl: vi.fn(),
+}));
+
+describe("uploadAndSendBotWsMedia", () => {
+  const loadOutboundMediaFromUrlMock = vi.mocked(loadOutboundMediaFromUrl);
+
+  beforeEach(() => {
+    loadOutboundMediaFromUrlMock.mockReset();
+    loadOutboundMediaFromUrlMock.mockResolvedValue({
+      buffer: Buffer.from("png"),
+      contentType: "image/png",
+      fileName: "sample.png",
+    } as never);
+  });
+
+  it("passes the configured maxBytes to outbound media loading", async () => {
+    const wsClient = {
+      uploadMedia: vi.fn().mockResolvedValue({ media_id: "media-1" }),
+      sendMediaMessage: vi.fn().mockResolvedValue({ headers: { req_id: "req-1" } }),
+    } as unknown as WSClient;
+
+    await uploadAndSendBotWsMedia({
+      wsClient,
+      chatId: "hidao",
+      mediaUrl: "https://example.com/sample.png",
+      maxBytes: 42 * 1024 * 1024,
+    });
+
+    expect(loadOutboundMediaFromUrlMock).toHaveBeenCalledWith(
+      "https://example.com/sample.png",
+      expect.objectContaining({
+        maxBytes: 42 * 1024 * 1024,
+      }),
+    );
+  });
+});

package/src/transport/bot-ws/media.ts

@@ -1,5 +1,5 @@
 import type { WeComMediaType, WsFrameHeaders, WSClient } from "@wecom/aibot-node-sdk";
-import { detectMime, loadOutboundMediaFromUrl } from "openclaw/plugin-sdk";
+import { detectMime, loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/media-runtime";
 
 const IMAGE_MAX_BYTES = 10 * 1024 * 1024;
 const VIDEO_MAX_BYTES = 10 * 1024 * 1024;
@@ -158,9 +158,10 @@ function applyFileSizeLimits(
 async function resolveMediaFile(
   mediaUrl: string,
   mediaLocalRoots?: readonly string[],
+  maxBytes?: number,
 ): Promise<ResolvedMediaFile> {
   const result = await loadOutboundMediaFromUrl(mediaUrl, {
-    maxBytes: FILE_MAX_BYTES,
+    maxBytes: maxBytes ?? FILE_MAX_BYTES,
     mediaLocalRoots,
   });
   let contentType = result.contentType || "application/octet-stream";
@@ -185,9 +186,10 @@ export async function uploadAndSendBotWsMedia(params: {
   mediaUrl: string;
   chatId: string;
   mediaLocalRoots?: readonly string[];
+  maxBytes?: number;
 }): Promise<BotWsMediaSendResult> {
   try {
-    const media = await resolveMediaFile(params.mediaUrl, params.mediaLocalRoots);
+    const media = await resolveMediaFile(params.mediaUrl, params.mediaLocalRoots, params.maxBytes);
     const detectedType = detectWeComMediaType(media.contentType);
     const sizeCheck = applyFileSizeLimits(media.buffer.length, detectedType, media.contentType);
     if (sizeCheck.shouldReject) {
@@ -229,9 +231,10 @@ export async function uploadAndReplyBotWsMedia(params: {
   frame: WsFrameHeaders;
   mediaUrl: string;
   mediaLocalRoots?: readonly string[];
+  maxBytes?: number;
 }): Promise<BotWsMediaSendResult> {
   try {
-    const media = await resolveMediaFile(params.mediaUrl, params.mediaLocalRoots);
+    const media = await resolveMediaFile(params.mediaUrl, params.mediaLocalRoots, params.maxBytes);
     const detectedType = detectWeComMediaType(media.contentType);
     const sizeCheck = applyFileSizeLimits(media.buffer.length, detectedType, media.contentType);
     if (sizeCheck.shouldReject) {

package/src/transport/bot-ws/reply.test.ts

@@ -1,14 +1,24 @@
+import os from "node:os";
+import path from "node:path";
 import type { WSClient } from "@wecom/aibot-node-sdk";
 import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/infra-runtime";
+import { uploadAndSendBotWsMedia } from "./media.js";
 import { createBotWsReplyHandle } from "./reply.js";
 
+vi.mock("./media.js", () => ({
+  uploadAndSendBotWsMedia: vi.fn(),
+}));
+
 type ReplyHandleParams = Parameters<typeof createBotWsReplyHandle>[0];
 
 describe("createBotWsReplyHandle", () => {
   let mockClient: import("vitest").Mocked<WSClient>;
+  const uploadAndSendBotWsMediaMock = vi.mocked(uploadAndSendBotWsMedia);
 
-  beforeEach(() => {
+  beforeEach(async () => {
     vi.useFakeTimers();
+    vi.stubEnv("OPENCLAW_STATE_DIR", "/tmp/wecom-reply-state");
     mockClient = {
       replyStream: vi.fn(),
       sendMessage: vi.fn(),
@@ -17,12 +27,25 @@ describe("createBotWsReplyHandle", () => {
     mockClient.replyStream.mockResolvedValue({} as any);
     mockClient.sendMessage.mockResolvedValue({} as any);
     mockClient.replyWelcome.mockResolvedValue({} as any);
+    uploadAndSendBotWsMediaMock.mockReset();
+    uploadAndSendBotWsMediaMock.mockResolvedValue({ ok: true, messageId: "media-1" } as any);
+    const runtime = await import("../../runtime.js");
+    runtime.setWecomRuntime({
+      config: {
+        loadConfig: () => ({
+          channels: {
+            wecom: {},
+          },
+        }),
+      },
+    } as any);
   });
 
   afterEach(() => {
     vi.clearAllTimers();
     vi.useRealTimers();
     vi.restoreAllMocks();
+    vi.unstubAllEnvs();
   });
 
   it("uses configured placeholder content for immediate ws ack", async () => {
@@ -176,6 +199,113 @@ describe("createBotWsReplyHandle", () => {
     );
   });
 
+  it("includes default global media local roots for final media sends", async () => {
+    const runtime = await import("../../runtime.js");
+    runtime.setWecomRuntime({
+      config: {
+        loadConfig: () => ({}),
+      },
+    } as any);
+
+    const handle = createBotWsReplyHandle({
+      client: mockClient,
+      frame: {
+        headers: { req_id: "req-final-media-roots" },
+        body: {
+          from: { userid: "hidao" },
+          chattype: "single",
+        },
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      inboundKind: "text",
+      autoSendPlaceholder: false,
+    });
+
+    await handle.deliver(
+      {
+        mediaUrls: ["/Users/YanHaidao/Downloads/01.png"],
+        isReasoning: false,
+      },
+      { kind: "final" },
+    );
+
+    expect(uploadAndSendBotWsMediaMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chatId: "hidao",
+        maxBytes: 80 * 1024 * 1024,
+        mediaUrl: "/Users/YanHaidao/Downloads/01.png",
+        mediaLocalRoots: expect.arrayContaining([
+          path.resolve(resolvePreferredOpenClawTmpDir()),
+          "/tmp/wecom-reply-state",
+          "/tmp/wecom-reply-state/media",
+          path.resolve(os.homedir(), "Desktop"),
+          path.resolve(os.homedir(), "Documents"),
+          path.resolve(os.homedir(), "Downloads"),
+        ]),
+      }),
+    );
+    expect(mockClient.replyStream).toHaveBeenCalledWith(
+      expect.objectContaining({ headers: { req_id: "req-final-media-roots" } }),
+      expect.any(String),
+      "文件已发送。",
+      true,
+    );
+  });
+
+  it("passes configured mediaMaxMb to final media sends", async () => {
+    const runtime = await import("../../runtime.js");
+    runtime.setWecomRuntime({
+      config: {
+        loadConfig: () => ({
+          agents: {
+            defaults: {
+              mediaMaxMb: 12,
+            },
+          },
+          channels: {
+            wecom: {
+              mediaMaxMb: 24,
+              accounts: {
+                default: {
+                  mediaMaxMb: 40,
+                },
+              },
+            },
+          },
+        }),
+      },
+    } as any);
+
+    const handle = createBotWsReplyHandle({
+      client: mockClient,
+      frame: {
+        headers: { req_id: "req-final-media-max-bytes" },
+        body: {
+          from: { userid: "hidao" },
+          chattype: "single",
+        },
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      inboundKind: "text",
+      autoSendPlaceholder: false,
+    });
+
+    await handle.deliver(
+      {
+        mediaUrls: ["/Users/YanHaidao/Downloads/01.png"],
+        isReasoning: false,
+      },
+      { kind: "final" },
+    );
+
+    expect(uploadAndSendBotWsMediaMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        chatId: "hidao",
+        maxBytes: 40 * 1024 * 1024,
+      }),
+    );
+  });
+
   it("stops placeholder keepalive when the first block contains media", async () => {
     const handle = createBotWsReplyHandle({
       client: mockClient,

package/src/transport/bot-ws/reply.ts

@@ -5,8 +5,11 @@ import {
   type EventMessage,
   type WSClient,
 } from "@wecom/aibot-node-sdk";
-import { formatErrorMessage } from "openclaw/plugin-sdk";
+import { formatErrorMessage } from "openclaw/plugin-sdk/infra-runtime";
+import { resolveWecomMediaMaxBytes, resolveWecomMergedMediaLocalRoots } from "../../config/index.js";
+import { getWecomRuntime } from "../../runtime.js";
 import type { ReplyHandle, ReplyPayload } from "../../types/index.js";
+import { toWeComMarkdownV2 } from "../../wecom_msg_adapter/markdown_adapter.js";
 import { uploadAndSendBotWsMedia } from "./media.js";
 
 const PLACEHOLDER_KEEPALIVE_MS = 3000;
@@ -246,6 +249,9 @@ export function createBotWsReplyHandle(params: {
 
       let finalText = outboundText;
       if (info.kind === "final" && mediaUrls.length > 0) {
+        const cfg = getWecomRuntime().config.loadConfig();
+        const mediaLocalRoots = resolveWecomMergedMediaLocalRoots({ cfg });
+        const mediaMaxBytes = resolveWecomMediaMaxBytes(cfg, params.accountId);
         const mediaFailures: string[] = [];
         const mediaNotes: string[] = [];
         let mediaSent = 0;
@@ -254,6 +260,8 @@ export function createBotWsReplyHandle(params: {
             wsClient: params.client,
             chatId: peerId,
             mediaUrl,
+            mediaLocalRoots,
+            maxBytes: mediaMaxBytes,
           });
           if (result.ok) {
             mediaSent += 1;
@@ -300,13 +308,13 @@ export function createBotWsReplyHandle(params: {
           // Send push message for other events
           await params.client.sendMessage(peerId, {
             msgtype: "markdown",
-            markdown: { content: finalText },
+            markdown: { content: toWeComMarkdownV2(finalText) },
           });
         } else {
           await params.client.replyStream(
             params.frame,
             resolveStreamId(),
-            finalText,
+            toWeComMarkdownV2(finalText),
             info.kind === "final",
           );
         }
@@ -349,5 +357,9 @@ export function createBotWsReplyHandle(params: {
       }
       params.onFail?.(error);
     },
+    markExternalActivity: () => {
+      notifyPeerActive();
+      stopPlaceholderKeepalive();
+    },
   };
 }

package/src/transport/bot-ws/sdk-adapter.ts

@@ -80,12 +80,13 @@ export class BotWsSdkAdapter {
           lastError: undefined,
         });
       },
-      sendMedia: async ({ chatId, mediaUrl, text, mediaLocalRoots }) => {
+      sendMedia: async ({ chatId, mediaUrl, text, mediaLocalRoots, maxBytes }) => {
         const result = await uploadAndSendBotWsMedia({
           wsClient: client,
           chatId,
           mediaUrl,
           mediaLocalRoots,
+          maxBytes,
         });
         if (result.ok && text?.trim()) {
           await client.sendMessage(chatId, {

package/src/transport/http/registry.ts

@@ -1,5 +1,5 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/routing";
 
 import type { ResolvedAgentAccount, TransportSessionPatch } from "../../types/index.js";
 import { monitorState } from "../../monitor/state.js";

package/src/types/config.ts

@@ -11,6 +11,7 @@ export type WecomMediaConfig = {
   retentionHours?: number;
   cleanupOnStart?: boolean;
   maxBytes?: number;
+  localRoots?: string[];
 };
 
 export type WecomNetworkConfig = {
@@ -72,12 +73,14 @@ export type WecomDynamicAgentsConfig = {
 export type WecomAccountConfig = {
   enabled?: boolean;
   name?: string;
+  mediaMaxMb?: number;
   bot?: WecomBotConfig;
   agent?: WecomAgentConfig;
 };
 
 export type WecomConfig = {
   enabled?: boolean;
+  mediaMaxMb?: number;
   bot?: WecomBotConfig;
   agent?: WecomAgentConfig;
   accounts?: Record<string, WecomAccountConfig>;

package/src/types/runtime.ts

@@ -95,6 +95,7 @@ export type ReplyHandle = {
   context: ReplyContext;
   deliver: (payload: ReplyPayload, info: ReplyDeliveryInfo) => Promise<void>;
   fail?: (error: unknown) => Promise<void>;
+  markExternalActivity?: () => void;
 };
 
 export type TransportSessionSnapshot = {