@yanhaidao/wecom 2.3.160 → 2.3.180

package/src/runtime/session-manager.ts

@@ -1,8 +1,8 @@
 import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
-
-import { resolveRuntimeRoute } from "./routing-bridge.js";
-import type { UnifiedInboundEvent } from "../types/index.js";
 import type { WecomMediaService } from "../shared/media-service.js";
+import type { UnifiedInboundEvent } from "../types/index.js";
+import { resolveRuntimeRoute } from "./routing-bridge.js";
+import { registerWecomSourceSnapshot } from "./source-registry.js";
 
 export type PreparedSession = {
   route: ReturnType<typeof resolveRuntimeRoute>;
@@ -18,6 +18,14 @@ export async function prepareInboundSession(params: {
 }): Promise<PreparedSession> {
   const { core, cfg, event, mediaService } = params;
   const route = resolveRuntimeRoute({ core, cfg, event });
+  if (event.transport === "bot-ws") {
+    registerWecomSourceSnapshot({
+      accountId: event.accountId,
+      source: "bot-ws",
+      messageId: event.messageId,
+      sessionKey: route.sessionKey,
+    });
+  }
   const storePath = core.channel.session.resolveStorePath(cfg.session?.store, {
     agentId: route.agentId,
   });
@@ -47,7 +55,10 @@ export async function prepareInboundSession(params: {
       event.conversation.peerKind === "group"
         ? `wecom:group:${event.conversation.peerId}`
         : `wecom:user:${event.conversation.senderId}`,
-    To: event.conversation.peerKind === "group" ? `wecom:group:${event.conversation.peerId}` : `wecom:user:${event.conversation.peerId}`,
+    To:
+      event.conversation.peerKind === "group"
+        ? `wecom:group:${event.conversation.peerId}`
+        : `wecom:user:${event.conversation.peerId}`,
     SessionKey: route.sessionKey,
     AccountId: route.accountId,
     ChatType: event.conversation.peerKind,
@@ -57,7 +68,10 @@ export async function prepareInboundSession(params: {
     Provider: "wecom",
     Surface: "wecom",
     OriginatingChannel: "wecom",
-    OriginatingTo: event.conversation.peerKind === "group" ? `wecom:group:${event.conversation.peerId}` : `wecom:user:${event.conversation.peerId}`,
+    OriginatingTo:
+      event.conversation.peerKind === "group"
+        ? `wecom:group:${event.conversation.peerId}`
+        : `wecom:user:${event.conversation.peerId}`,
     MessageSid: event.messageId,
     CommandAuthorized: true,
     MediaPath: mediaPath,
@@ -69,7 +83,7 @@ export async function prepareInboundSession(params: {
     storePath,
     sessionKey: ctx.SessionKey ?? route.sessionKey,
     ctx,
-    onRecordError: () => { },
+    onRecordError: () => {},
   });
 
   return { route, ctx, storePath };

package/src/runtime/source-registry.ts

@@ -0,0 +1,165 @@
+export type WecomSourcePlane = "bot-ws" | "agent-callback";
+
+export type WecomSourceSnapshot = {
+  accountId: string;
+  source: WecomSourcePlane;
+  recordedAt: number;
+  messageId?: string;
+  sessionKey?: string;
+  sessionId?: string;
+};
+
+const MAX_MESSAGE_FACTS = 2048;
+const MAX_SESSION_SNAPSHOTS = 1024;
+
+const messageFacts = new Map<string, WecomSourceSnapshot>();
+const sessionSnapshotsByAccountKey = new Map<string, WecomSourceSnapshot>();
+const sessionSnapshotsByLooseKey = new Map<string, WecomSourceSnapshot>();
+
+function normalizeOptional(value: string | null | undefined): string | undefined {
+  const trimmed = String(value ?? "").trim();
+  return trimmed || undefined;
+}
+
+function messageFactKey(accountId: string, messageId: string): string {
+  return `${accountId}::${messageId}`;
+}
+
+function accountScopedSessionKey(
+  accountId: string,
+  kind: "sessionKey" | "sessionId",
+  value: string,
+): string {
+  return `${accountId}::${kind}::${value}`;
+}
+
+function pruneOldest<T>(map: Map<string, T>, maxSize: number): void {
+  while (map.size > maxSize) {
+    const oldestKey = map.keys().next().value;
+    if (!oldestKey) return;
+    map.delete(oldestKey);
+  }
+}
+
+function writeSessionSnapshot(snapshot: WecomSourceSnapshot): void {
+  const sessionKey = normalizeOptional(snapshot.sessionKey);
+  const sessionId = normalizeOptional(snapshot.sessionId);
+  if (sessionKey) {
+    sessionSnapshotsByAccountKey.set(
+      accountScopedSessionKey(snapshot.accountId, "sessionKey", sessionKey),
+      snapshot,
+    );
+    sessionSnapshotsByLooseKey.set(`sessionKey::${sessionKey}`, snapshot);
+  }
+  if (sessionId) {
+    sessionSnapshotsByAccountKey.set(
+      accountScopedSessionKey(snapshot.accountId, "sessionId", sessionId),
+      snapshot,
+    );
+    sessionSnapshotsByLooseKey.set(`sessionId::${sessionId}`, snapshot);
+  }
+  pruneOldest(sessionSnapshotsByAccountKey, MAX_SESSION_SNAPSHOTS * 2);
+  pruneOldest(sessionSnapshotsByLooseKey, MAX_SESSION_SNAPSHOTS * 2);
+}
+
+export function registerWecomSourceSnapshot(params: {
+  accountId: string;
+  source: WecomSourcePlane;
+  messageId?: string | null;
+  sessionKey?: string | null;
+  sessionId?: string | null;
+}): void {
+  const accountId = normalizeOptional(params.accountId);
+  if (!accountId) return;
+
+  const snapshot: WecomSourceSnapshot = {
+    accountId,
+    source: params.source,
+    recordedAt: Date.now(),
+    ...(normalizeOptional(params.messageId)
+      ? { messageId: normalizeOptional(params.messageId) }
+      : {}),
+    ...(normalizeOptional(params.sessionKey)
+      ? { sessionKey: normalizeOptional(params.sessionKey) }
+      : {}),
+    ...(normalizeOptional(params.sessionId)
+      ? { sessionId: normalizeOptional(params.sessionId) }
+      : {}),
+  };
+
+  if (snapshot.messageId) {
+    messageFacts.set(messageFactKey(accountId, snapshot.messageId), snapshot);
+    pruneOldest(messageFacts, MAX_MESSAGE_FACTS);
+  }
+
+  writeSessionSnapshot(snapshot);
+}
+
+export function resolveWecomSourceSnapshot(params: {
+  accountId?: string | null;
+  sessionKey?: string | null;
+  sessionId?: string | null;
+}): WecomSourceSnapshot | undefined {
+  const accountId = normalizeOptional(params.accountId);
+  const sessionKey = normalizeOptional(params.sessionKey);
+  const sessionId = normalizeOptional(params.sessionId);
+
+  if (accountId && sessionKey) {
+    const scoped = sessionSnapshotsByAccountKey.get(
+      accountScopedSessionKey(accountId, "sessionKey", sessionKey),
+    );
+    if (scoped) return scoped;
+  }
+  if (accountId && sessionId) {
+    const scoped = sessionSnapshotsByAccountKey.get(
+      accountScopedSessionKey(accountId, "sessionId", sessionId),
+    );
+    if (scoped) return scoped;
+  }
+  if (sessionKey) {
+    const loose = sessionSnapshotsByLooseKey.get(`sessionKey::${sessionKey}`);
+    if (loose) return loose;
+  }
+  if (sessionId) {
+    const loose = sessionSnapshotsByLooseKey.get(`sessionId::${sessionId}`);
+    if (loose) return loose;
+  }
+  return undefined;
+}
+
+export function clearWecomSourceAccount(accountId: string): void {
+  const normalized = normalizeOptional(accountId);
+  if (!normalized) return;
+
+  for (const [key, value] of messageFacts) {
+    if (value.accountId === normalized || key.startsWith(`${normalized}::`)) {
+      messageFacts.delete(key);
+    }
+  }
+  for (const [key, value] of sessionSnapshotsByAccountKey) {
+    if (value.accountId === normalized || key.startsWith(`${normalized}::`)) {
+      sessionSnapshotsByAccountKey.delete(key);
+    }
+  }
+  for (const [key, value] of sessionSnapshotsByLooseKey) {
+    if (value.accountId === normalized) {
+      sessionSnapshotsByLooseKey.delete(key);
+    }
+  }
+}
+
+export function isWecomBotWsSource(params: {
+  accountId?: string | null;
+  sessionKey?: string | null;
+  sessionId?: string | null;
+}): boolean {
+  return resolveWecomSourceSnapshot(params)?.source === "bot-ws";
+}
+
+export function isWecomAgentSource(params: {
+  accountId?: string | null;
+  sessionKey?: string | null;
+  sessionId?: string | null;
+}): boolean {
+  return resolveWecomSourceSnapshot(params)?.source === "agent-callback";
+}

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

@@ -0,0 +1,269 @@
+import type { WeComMediaType, WsFrameHeaders, WSClient } from "@wecom/aibot-node-sdk";
+import { detectMime, loadOutboundMediaFromUrl } from "openclaw/plugin-sdk";
+
+const IMAGE_MAX_BYTES = 10 * 1024 * 1024;
+const VIDEO_MAX_BYTES = 10 * 1024 * 1024;
+const VOICE_MAX_BYTES = 2 * 1024 * 1024;
+const FILE_MAX_BYTES = 20 * 1024 * 1024;
+
+type FileSizeCheckResult = {
+  finalType: WeComMediaType;
+  shouldReject: boolean;
+  rejectReason?: string;
+  downgraded: boolean;
+  downgradeNote?: string;
+};
+
+export type BotWsMediaSendResult = {
+  ok: boolean;
+  messageId?: string;
+  finalType?: WeComMediaType;
+  rejected?: boolean;
+  rejectReason?: string;
+  downgraded?: boolean;
+  downgradeNote?: string;
+  error?: string;
+};
+
+type ResolvedMediaFile = {
+  buffer: Buffer;
+  contentType: string;
+  fileName: string;
+};
+
+const VOICE_SUPPORTED_MIMES = new Set(["audio/amr"]);
+
+function detectWeComMediaType(mimeType: string): WeComMediaType {
+  const mime = mimeType.toLowerCase();
+  if (mime.startsWith("image/")) return "image";
+  if (mime.startsWith("video/")) return "video";
+  if (mime.startsWith("audio/") || mime === "application/ogg") return "voice";
+  return "file";
+}
+
+function mimeToExtension(mime: string): string {
+  const map: Record<string, string> = {
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "image/bmp": ".bmp",
+    "image/svg+xml": ".svg",
+    "video/mp4": ".mp4",
+    "video/quicktime": ".mov",
+    "video/x-msvideo": ".avi",
+    "video/webm": ".webm",
+    "audio/mpeg": ".mp3",
+    "audio/ogg": ".ogg",
+    "audio/wav": ".wav",
+    "audio/amr": ".amr",
+    "audio/aac": ".aac",
+    "application/pdf": ".pdf",
+    "application/zip": ".zip",
+    "application/msword": ".doc",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+    "application/vnd.ms-excel": ".xls",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+    "text/plain": ".txt",
+  };
+  return map[mime] || ".bin";
+}
+
+function extractFileName(
+  mediaUrl: string,
+  providedFileName?: string,
+  contentType?: string,
+): string {
+  if (providedFileName) return providedFileName;
+  try {
+    const url = new URL(mediaUrl, "file://");
+    const lastPart = url.pathname.split("/").filter(Boolean).pop();
+    if (lastPart && lastPart.includes(".")) {
+      return decodeURIComponent(lastPart);
+    }
+  } catch {
+    const lastPart = mediaUrl.split("/").filter(Boolean).pop();
+    if (lastPart && lastPart.includes(".")) {
+      return lastPart;
+    }
+  }
+  return `media_${Date.now()}${mimeToExtension(contentType || "application/octet-stream")}`;
+}
+
+function applyFileSizeLimits(
+  fileSize: number,
+  detectedType: WeComMediaType,
+  contentType?: string,
+): FileSizeCheckResult {
+  const fileSizeMB = (fileSize / (1024 * 1024)).toFixed(2);
+  if (fileSize > FILE_MAX_BYTES) {
+    return {
+      finalType: detectedType,
+      shouldReject: true,
+      rejectReason: `文件大小 ${fileSizeMB}MB 超过了企业微信允许的最大限制 20MB，无法发送。`,
+      downgraded: false,
+    };
+  }
+
+  switch (detectedType) {
+    case "image":
+      if (fileSize > IMAGE_MAX_BYTES) {
+        return {
+          finalType: "file",
+          shouldReject: false,
+          downgraded: true,
+          downgradeNote: `图片大小 ${fileSizeMB}MB 超过 10MB 限制，已转为文件格式发送`,
+        };
+      }
+      break;
+    case "video":
+      if (fileSize > VIDEO_MAX_BYTES) {
+        return {
+          finalType: "file",
+          shouldReject: false,
+          downgraded: true,
+          downgradeNote: `视频大小 ${fileSizeMB}MB 超过 10MB 限制，已转为文件格式发送`,
+        };
+      }
+      break;
+    case "voice":
+      if (contentType && !VOICE_SUPPORTED_MIMES.has(contentType.toLowerCase())) {
+        return {
+          finalType: "file",
+          shouldReject: false,
+          downgraded: true,
+          downgradeNote: `语音格式 ${contentType} 不支持，企微仅支持 AMR 格式，已转为文件格式发送`,
+        };
+      }
+      if (fileSize > VOICE_MAX_BYTES) {
+        return {
+          finalType: "file",
+          shouldReject: false,
+          downgraded: true,
+          downgradeNote: `语音大小 ${fileSizeMB}MB 超过 2MB 限制，已转为文件格式发送`,
+        };
+      }
+      break;
+    default:
+      break;
+  }
+
+  return {
+    finalType: detectedType,
+    shouldReject: false,
+    downgraded: false,
+  };
+}
+
+async function resolveMediaFile(
+  mediaUrl: string,
+  mediaLocalRoots?: readonly string[],
+): Promise<ResolvedMediaFile> {
+  const result = await loadOutboundMediaFromUrl(mediaUrl, {
+    maxBytes: FILE_MAX_BYTES,
+    mediaLocalRoots,
+  });
+  let contentType = result.contentType || "application/octet-stream";
+  if (contentType === "application/octet-stream" || contentType === "text/plain") {
+    const detected = await detectMime({
+      buffer: result.buffer,
+      filePath: result.fileName ?? mediaUrl,
+    });
+    if (detected) {
+      contentType = detected;
+    }
+  }
+  return {
+    buffer: result.buffer,
+    contentType,
+    fileName: extractFileName(mediaUrl, result.fileName, contentType),
+  };
+}
+
+export async function uploadAndSendBotWsMedia(params: {
+  wsClient: WSClient;
+  mediaUrl: string;
+  chatId: string;
+  mediaLocalRoots?: readonly string[];
+}): Promise<BotWsMediaSendResult> {
+  try {
+    const media = await resolveMediaFile(params.mediaUrl, params.mediaLocalRoots);
+    const detectedType = detectWeComMediaType(media.contentType);
+    const sizeCheck = applyFileSizeLimits(media.buffer.length, detectedType, media.contentType);
+    if (sizeCheck.shouldReject) {
+      return {
+        ok: false,
+        rejected: true,
+        rejectReason: sizeCheck.rejectReason,
+        finalType: sizeCheck.finalType,
+      };
+    }
+
+    const uploadResult = await params.wsClient.uploadMedia(media.buffer, {
+      type: sizeCheck.finalType,
+      filename: media.fileName,
+    });
+    const sendResult = await params.wsClient.sendMediaMessage(
+      params.chatId,
+      sizeCheck.finalType,
+      uploadResult.media_id,
+    );
+
+    return {
+      ok: true,
+      messageId: sendResult?.headers?.req_id ?? `wecom-media-${Date.now()}`,
+      finalType: sizeCheck.finalType,
+      downgraded: sizeCheck.downgraded,
+      downgradeNote: sizeCheck.downgradeNote,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export async function uploadAndReplyBotWsMedia(params: {
+  wsClient: WSClient;
+  frame: WsFrameHeaders;
+  mediaUrl: string;
+  mediaLocalRoots?: readonly string[];
+}): Promise<BotWsMediaSendResult> {
+  try {
+    const media = await resolveMediaFile(params.mediaUrl, params.mediaLocalRoots);
+    const detectedType = detectWeComMediaType(media.contentType);
+    const sizeCheck = applyFileSizeLimits(media.buffer.length, detectedType, media.contentType);
+    if (sizeCheck.shouldReject) {
+      return {
+        ok: false,
+        rejected: true,
+        rejectReason: sizeCheck.rejectReason,
+        finalType: sizeCheck.finalType,
+      };
+    }
+
+    const uploadResult = await params.wsClient.uploadMedia(media.buffer, {
+      type: sizeCheck.finalType,
+      filename: media.fileName,
+    });
+    const replyResult = await params.wsClient.replyMedia(
+      params.frame,
+      sizeCheck.finalType,
+      uploadResult.media_id,
+    );
+
+    return {
+      ok: true,
+      messageId: replyResult?.headers?.req_id ?? `wecom-reply-media-${Date.now()}`,
+      finalType: sizeCheck.finalType,
+      downgraded: sizeCheck.downgraded,
+      downgradeNote: sizeCheck.downgradeNote,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

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

@@ -1,7 +1,5 @@
-import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
-
 import type { WSClient } from "@wecom/aibot-node-sdk";
-
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
 import { createBotWsReplyHandle } from "./reply.js";
 
 type ReplyHandleParams = Parameters<typeof createBotWsReplyHandle>[0];
@@ -43,10 +41,10 @@ describe("createBotWsReplyHandle", () => {
     vi.advanceTimersByTime(3000);
     // Let promises flush
     await Promise.resolve();
-    
+
     expect(mockClient.replyStream).toHaveBeenCalledWith(
       expect.objectContaining({
-        headers: { req_id: "req-1" }
+        headers: { req_id: "req-1" },
       }),
       expect.any(String),
       "正在思考...",
@@ -69,7 +67,7 @@ describe("createBotWsReplyHandle", () => {
     vi.advanceTimersByTime(3000);
     // Flush the microtasks so `placeholderInFlight` becomes false
     for (let i = 0; i < 10; i++) await Promise.resolve();
-    
+
     // Now trigger the next timer
     vi.advanceTimersByTime(3000);
     for (let i = 0; i < 10; i++) await Promise.resolve();
@@ -90,7 +88,7 @@ describe("createBotWsReplyHandle", () => {
     // Ensure interval is cleared
     vi.advanceTimersByTime(6000);
     await Promise.resolve();
-    expect(mockClient.replyStream).toHaveBeenCalledTimes(3); 
+    expect(mockClient.replyStream).toHaveBeenCalledTimes(3);
   });
 
   it("does not auto-send placeholder when disabled", async () => {
@@ -149,6 +147,73 @@ describe("createBotWsReplyHandle", () => {
     );
   });
 
+  it("streams block text even when media is deferred to final", async () => {
+    const handle = createBotWsReplyHandle({
+      client: mockClient,
+      frame: {
+        headers: { req_id: "req-block-media" },
+        body: {},
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      inboundKind: "text",
+      autoSendPlaceholder: false,
+    });
+
+    await handle.deliver(
+      {
+        text: "正文先发",
+        mediaUrls: ["/tmp/a.png", "/tmp/b.png"],
+        isReasoning: false,
+      },
+      { kind: "block" },
+    );
+
+    expect(mockClient.replyStream).toHaveBeenCalledWith(
+      expect.objectContaining({ headers: { req_id: "req-block-media" } }),
+      expect.any(String),
+      "正文先发",
+      false,
+    );
+  });
+
+  it("stops placeholder keepalive when the first block contains media", async () => {
+    const handle = createBotWsReplyHandle({
+      client: mockClient,
+      frame: {
+        headers: { req_id: "req-placeholder-media" },
+        body: {},
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      inboundKind: "text",
+      placeholderContent: "正在思考...",
+    });
+
+    vi.advanceTimersByTime(3000);
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+    expect(mockClient.replyStream).toHaveBeenCalledTimes(1);
+
+    await handle.deliver(
+      {
+        text: "正文先发",
+        mediaUrls: ["/tmp/a.png"],
+        isReasoning: false,
+      },
+      { kind: "block" },
+    );
+
+    vi.advanceTimersByTime(6000);
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+
+    expect(mockClient.replyStream).toHaveBeenCalledTimes(2);
+    expect(mockClient.replyStream).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ headers: { req_id: "req-placeholder-media" } }),
+      expect.any(String),
+      "正文先发",
+      false,
+    );
+  });
+
   it("swallows expired stream update errors during delivery", async () => {
     const expiredError = {
       headers: { req_id: "req-expired" },
@@ -157,7 +222,7 @@ describe("createBotWsReplyHandle", () => {
     };
     mockClient.replyStream.mockRejectedValueOnce(expiredError);
     const onFail = vi.fn();
-    
+
     const handle = createBotWsReplyHandle({
       client: mockClient,
       frame: {
@@ -178,7 +243,13 @@ describe("createBotWsReplyHandle", () => {
 
   it.each([
     [{ headers: { req_id: "req-invalid" }, errcode: 846605, errmsg: "invalid req_id" }],
-    [{ headers: { req_id: "req-expired" }, errcode: 846608, errmsg: "stream message update expired (>6 minutes), cannot update" }],
+    [
+      {
+        headers: { req_id: "req-expired" },
+        errcode: 846608,
+        errmsg: "stream message update expired (>6 minutes), cannot update",
+      },
+    ],
   ])("does not retry error reply when the ws reply window is already closed", async (error) => {
     const onFail = vi.fn();
     const handle = createBotWsReplyHandle({
@@ -218,13 +289,10 @@ describe("createBotWsReplyHandle", () => {
     handle.deliver({ text: "Event Reply", isReasoning: false }, { kind: "final" });
     await Promise.resolve();
 
-    expect(mockClient.sendMessage).toHaveBeenCalledWith(
-      "alice",
-      {
-        msgtype: "markdown",
-        markdown: { content: "Event Reply" },
-      }
-    );
+    expect(mockClient.sendMessage).toHaveBeenCalledWith("alice", {
+      msgtype: "markdown",
+      markdown: { content: "Event Reply" },
+    });
   });
 
   it("sends replyWelcome for welcome events", async () => {
@@ -246,7 +314,7 @@ describe("createBotWsReplyHandle", () => {
       {
         msgtype: "text",
         text: { content: "Hello Bob" },
-      }
+      },
     );
   });
 });