@yanhaidao/wecom 2.3.160 → 2.3.190

package/src/outbound.ts

@@ -1,7 +1,12 @@
 import type { ChannelOutboundAdapter, ChannelOutboundContext } from "openclaw/plugin-sdk";
-
-import { resolveWecomAccount, resolveWecomAccountConflict, resolveWecomAccounts } from "./config/index.js";
 import { WecomAgentDeliveryService } from "./capability/agent/index.js";
+import {
+  resolveWecomMergedMediaLocalRoots,
+  resolveWecomMediaMaxBytes,
+  resolveWecomAccount,
+  resolveWecomAccountConflict,
+  resolveWecomAccounts,
+} from "./config/index.js";
 import { getAccountRuntime, getBotWsPushHandle, getWecomRuntime } from "./runtime.js";
 import { resolveScopedWecomTarget } from "./target.js";
 
@@ -49,7 +54,9 @@ function resolveAgentConfigOrThrow(params: {
     );
   }
   // 注意：不要在日志里输出 corpSecret 等敏感信息
-  getAccountRuntime(account.accountId)?.log.info?.(`[wecom-outbound] Using agent config: accountId=${account.accountId}, corpId=${account.corpId}, agentId=${account.agentId}`);
+  getAccountRuntime(account.accountId)?.log.info?.(
+    `[wecom-outbound] Using agent config: accountId=${account.accountId}, corpId=${account.corpId}, agentId=${account.agentId}`,
+  );
   return account;
 }
 
@@ -89,7 +96,13 @@ function shouldPreferBotWsOutbound(params: {
     accountId: params.accountId,
   });
   return {
-    preferred: !isExplicitAgentTarget(params.to) && Boolean(account.bot?.configured && account.bot.primaryTransport === "ws" && account.bot.wsConfigured),
+    preferred:
+      !isExplicitAgentTarget(params.to) &&
+      Boolean(
+        account.bot?.configured &&
+        account.bot.primaryTransport === "ws" &&
+        account.bot.wsConfigured,
+      ),
     accountId: account.accountId,
   };
 }
@@ -122,12 +135,71 @@ async function sendTextViaBotWs(params: {
       `WeCom outbound account=${accountId} is configured for Bot WS active push, but the WS transport is not connected.`,
     );
   }
-  console.log(`[wecom-outbound] Sending Bot WS active message to target=${String(params.to ?? "")} chatId=${chatId} (len=${params.text.length})`);
+  console.log(
+    `[wecom-outbound] Sending Bot WS active message to target=${String(params.to ?? "")} chatId=${chatId} (len=${params.text.length})`,
+  );
   await handle.sendMarkdown(chatId, params.text);
   console.log(`[wecom-outbound] Successfully sent Bot WS active message to ${chatId}`);
   return true;
 }
 
+async function sendMediaViaBotWs(params: {
+  cfg: ChannelOutboundContext["cfg"];
+  accountId?: string | null;
+  to: string | undefined;
+  mediaUrl: string;
+  text?: string;
+  mediaLocalRoots?: readonly string[];
+}): Promise<{
+  attempted: boolean;
+  sent: boolean;
+  reason?: string;
+}> {
+  const { preferred, accountId } = shouldPreferBotWsOutbound(params);
+  if (!preferred) {
+    return { attempted: false, sent: false };
+  }
+  const chatId = resolveBotWsChatTarget({
+    to: params.to,
+    accountId,
+  });
+  if (!chatId) {
+    return { attempted: false, sent: false };
+  }
+  const handle = getBotWsPushHandle(accountId);
+  if (!handle) {
+    throw new Error(
+      `WeCom outbound account=${accountId} is configured for Bot WS active push, but no live WS runtime is registered.`,
+    );
+  }
+  if (!handle.isConnected()) {
+    throw new Error(
+      `WeCom outbound account=${accountId} is configured for Bot WS active push, but the WS transport is not connected.`,
+    );
+  }
+  console.log(
+    `[wecom-outbound] Sending Bot WS media to target=${String(params.to ?? "")} chatId=${chatId} media=${params.mediaUrl}`,
+  );
+  const effectiveMediaLocalRoots = resolveWecomMergedMediaLocalRoots({
+    cfg: params.cfg,
+    baseRoots: params.mediaLocalRoots,
+  });
+  const result = await handle.sendMedia({
+    chatId,
+    mediaUrl: params.mediaUrl,
+    text: params.text,
+    mediaLocalRoots: effectiveMediaLocalRoots,
+    maxBytes: resolveWecomMediaMaxBytes(params.cfg, accountId),
+  });
+  if (result.ok) {
+    console.log(`[wecom-outbound] Successfully sent Bot WS media to ${chatId}`);
+    return { attempted: true, sent: true };
+  }
+  const reason = result.rejectReason || result.error || "unknown";
+  console.warn(`[wecom-outbound] Bot WS media failed for ${chatId}: ${reason}`);
+  return { attempted: true, sent: false, reason };
+}
+
 export const wecomOutbound: ChannelOutboundAdapter = {
   deliveryMode: "direct",
   chunkerMode: "text",
@@ -155,8 +227,7 @@ export const wecomOutbound: ChannelOutboundAdapter = {
     const trimmed = String(outgoingText ?? "").trim();
     const rawTo = typeof to === "string" ? to.trim().toLowerCase() : "";
     const isAgentSessionTarget = rawTo.startsWith("wecom-agent:");
-    const looksLikeNewSessionAck =
-      /new session started/i.test(trimmed) && /model:/i.test(trimmed);
+    const looksLikeNewSessionAck = /new session started/i.test(trimmed) && /model:/i.test(trimmed);
 
     if (looksLikeNewSessionAck) {
       if (!isAgentSessionTarget) {
@@ -174,7 +245,7 @@ export const wecomOutbound: ChannelOutboundAdapter = {
 
     let sentViaBotWs = false;
     let agent: any = null;
-    
+
     try {
       sentViaBotWs = await sendTextViaBotWs({
         cfg,
@@ -185,7 +256,9 @@ export const wecomOutbound: ChannelOutboundAdapter = {
       if (!sentViaBotWs) {
         // Defer Agent resolution until needed for fallback
         agent = resolveAgentConfigOrThrow({ cfg, accountId });
-        getAccountRuntime(agent.accountId)?.log.info?.(`[wecom-outbound] Sending text to target=${String(to ?? "")} (len=${outgoingText.length})`);
+        getAccountRuntime(agent.accountId)?.log.info?.(
+          `[wecom-outbound] Sending text to target=${String(to ?? "")} (len=${outgoingText.length})`,
+        );
         const deliveryService = new WecomAgentDeliveryService(agent);
         await deliveryService.sendText({
           to,
@@ -195,7 +268,9 @@ export const wecomOutbound: ChannelOutboundAdapter = {
       }
     } catch (err) {
       if (agent) {
-        getAccountRuntime(agent.accountId)?.log.error?.(`[wecom-outbound] Failed to send text to ${String(to ?? "")}: ${err instanceof Error ? err.message : String(err)}`);
+        getAccountRuntime(agent.accountId)?.log.error?.(
+          `[wecom-outbound] Failed to send text to ${String(to ?? "")}: ${err instanceof Error ? err.message : String(err)}`,
+        );
       }
       throw err;
     }
@@ -206,18 +281,42 @@ export const wecomOutbound: ChannelOutboundAdapter = {
       timestamp: Date.now(),
     };
   },
-  sendMedia: async ({ cfg, to, text, mediaUrl, accountId }: ChannelOutboundContext) => {
+  sendMedia: async ({
+    cfg,
+    to,
+    text,
+    mediaUrl,
+    accountId,
+    mediaLocalRoots,
+  }: ChannelOutboundContext) => {
     // signal removed - not supported in current SDK
+    if (!mediaUrl) {
+      throw new Error("WeCom outbound requires mediaUrl.");
+    }
 
-    const { preferred } = shouldPreferBotWsOutbound({ cfg, accountId, to });
-    if (preferred) {
-      console.log(`[wecom-outbound] Bot WS active push does not support outbound media; falling back to Agent for target=${String(to ?? "")}`);
+    const botWs = await sendMediaViaBotWs({
+      cfg,
+      accountId,
+      to,
+      text,
+      mediaUrl,
+      mediaLocalRoots,
+    });
+    if (botWs.sent) {
+      return {
+        channel: "wecom",
+        messageId: `bot-ws-media-${Date.now()}`,
+        timestamp: Date.now(),
+      };
+    }
+    if (botWs.attempted) {
+      throw new Error(
+        `WeCom Bot WS media delivery failed for ${String(to ?? "")}: ${botWs.reason ?? "unknown"}`,
+      );
     }
+
     const agent = resolveAgentConfigOrThrow({ cfg, accountId });
     const deliveryService = new WecomAgentDeliveryService(agent);
-    if (!mediaUrl) {
-      throw new Error("WeCom outbound requires mediaUrl.");
-    }
 
     let buffer: Buffer;
     let contentType: string;
@@ -246,23 +345,49 @@ export const wecomOutbound: ChannelOutboundAdapter = {
       // 根据扩展名推断 content-type
       const ext = path.extname(mediaUrl).slice(1).toLowerCase();
       const mimeTypes: Record<string, string> = {
-        jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png", gif: "image/gif",
-        webp: "image/webp", bmp: "image/bmp", mp3: "audio/mpeg", wav: "audio/wav",
-        amr: "audio/amr", mp4: "video/mp4", pdf: "application/pdf", doc: "application/msword",
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        png: "image/png",
+        gif: "image/gif",
+        webp: "image/webp",
+        bmp: "image/bmp",
+        mp3: "audio/mpeg",
+        wav: "audio/wav",
+        amr: "audio/amr",
+        mp4: "video/mp4",
+        pdf: "application/pdf",
+        doc: "application/msword",
         docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-        xls: "application/vnd.ms-excel", xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-        ppt: "application/vnd.ms-powerpoint", pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-        txt: "text/plain", csv: "text/csv", tsv: "text/tab-separated-values", md: "text/markdown", json: "application/json",
-        xml: "application/xml", yaml: "application/yaml", yml: "application/yaml",
-        zip: "application/zip", rar: "application/vnd.rar", "7z": "application/x-7z-compressed",
-        tar: "application/x-tar", gz: "application/gzip", tgz: "application/gzip",
-        rtf: "application/rtf", odt: "application/vnd.oasis.opendocument.text",
+        xls: "application/vnd.ms-excel",
+        xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        ppt: "application/vnd.ms-powerpoint",
+        pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        txt: "text/plain",
+        csv: "text/csv",
+        tsv: "text/tab-separated-values",
+        md: "text/markdown",
+        json: "application/json",
+        xml: "application/xml",
+        yaml: "application/yaml",
+        yml: "application/yaml",
+        zip: "application/zip",
+        rar: "application/vnd.rar",
+        "7z": "application/x-7z-compressed",
+        tar: "application/x-tar",
+        gz: "application/gzip",
+        tgz: "application/gzip",
+        rtf: "application/rtf",
+        odt: "application/vnd.oasis.opendocument.text",
       };
       contentType = mimeTypes[ext] || "application/octet-stream";
-      console.log(`[wecom-outbound] Reading local file: ${mediaUrl}, ext=${ext}, contentType=${contentType}`);
+      console.log(
+        `[wecom-outbound] Reading local file: ${mediaUrl}, ext=${ext}, contentType=${contentType}`,
+      );
     }
 
-    console.log(`[wecom-outbound] Sending media to ${String(to ?? "")} (filename=${filename}, contentType=${contentType})`);
+    console.log(
+      `[wecom-outbound] Sending media to ${String(to ?? "")} (filename=${filename}, contentType=${contentType})`,
+    );
 
     try {
       await deliveryService.sendMedia({
@@ -280,7 +405,7 @@ export const wecomOutbound: ChannelOutboundAdapter = {
 
     return {
       channel: "wecom",
-      messageId: `agent-media-${Date.now()}`,
+      messageId: `${botWs.attempted ? "agent-fallback-media" : "agent-media"}-${Date.now()}`,
       timestamp: Date.now(),
     };
   },

package/src/runtime/reply-orchestrator.test.ts

@@ -1,10 +1,11 @@
 import { describe, expect, it, vi } from "vitest";
-
 import { dispatchRuntimeReply } from "./reply-orchestrator.js";
 
 describe("dispatchRuntimeReply", () => {
   it("enables block streaming for bot-ws replies", async () => {
-    const dispatchReplyWithBufferedBlockDispatcher = vi.fn().mockResolvedValue(undefined);
+    const dispatchReplyWithBufferedBlockDispatcher = vi
+      .fn()
+      .mockResolvedValue({ queuedFinal: false, counts: { block: 0, final: 0, tool: 0 } });
     const core = {
       channel: {
         reply: {
@@ -35,4 +36,36 @@ describe("dispatchRuntimeReply", () => {
       }),
     );
   });
+
+  it("synthesizes a final close for bot-ws when only block replies were queued", async () => {
+    const dispatchReplyWithBufferedBlockDispatcher = vi.fn().mockResolvedValue({
+      queuedFinal: false,
+      counts: { block: 1, final: 0, tool: 0 },
+    });
+    const deliver = vi.fn().mockResolvedValue(undefined);
+    const core = {
+      channel: {
+        reply: {
+          dispatchReplyWithBufferedBlockDispatcher,
+        },
+      },
+    } as any;
+
+    await dispatchRuntimeReply({
+      core,
+      cfg: {} as any,
+      session: { ctx: { SessionKey: "session-a" } } as any,
+      replyHandle: {
+        context: {
+          transport: "bot-ws",
+          accountId: "default",
+          raw: { transport: "bot-ws", envelopeType: "ws", body: {} },
+        },
+        deliver,
+      } as any,
+    });
+
+    expect(deliver).toHaveBeenCalledTimes(1);
+    expect(deliver).toHaveBeenCalledWith({ text: "" }, { kind: "final" });
+  });
 });

package/src/runtime/reply-orchestrator.ts

@@ -1,5 +1,4 @@
 import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
-
 import type { ReplyHandle } from "../types/index.js";
 import type { PreparedSession } from "./session-manager.js";
 
@@ -29,7 +28,7 @@ export async function dispatchRuntimeReply(params: {
   replyHandle: ReplyHandle;
 }): Promise<void> {
   const { core, cfg, session, replyHandle } = params;
-  await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+  const result = await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
     ctx: session.ctx,
     cfg,
     replyOptions:
@@ -52,4 +51,17 @@ export async function dispatchRuntimeReply(params: {
       },
     },
   });
+
+  if (
+    replyHandle.context.transport === "bot-ws" &&
+    result &&
+    result.queuedFinal !== true &&
+    (result.counts?.block ?? 0) > 0
+  ) {
+    await dispatchReplyPayload({
+      replyHandle,
+      payload: { text: "" },
+      kind: "final",
+    });
+  }
 }

package/src/runtime/routing-bridge.test.ts

@@ -0,0 +1,115 @@
+import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { resolveRuntimeRoute } from "./routing-bridge.js";
+import { ensureDynamicAgentListed } from "../dynamic-agent.js";
+import type { UnifiedInboundEvent } from "../types/index.js";
+
+vi.mock("../dynamic-agent.js", async () => {
+  const actual = await vi.importActual<typeof import("../dynamic-agent.js")>(
+    "../dynamic-agent.js",
+  );
+  return {
+    ...actual,
+    ensureDynamicAgentListed: vi.fn().mockResolvedValue(undefined),
+  };
+});
+
+describe("resolveRuntimeRoute", () => {
+  beforeEach(() => {
+    vi.mocked(ensureDynamicAgentListed).mockClear();
+  });
+
+  it("overrides WS runtime routes with dynamic agent routing for direct chats", () => {
+    const baseRoute = {
+      agentId: "main",
+      channel: "wecom",
+      accountId: "acct-ws",
+      sessionKey: "agent:main",
+      mainSessionKey: "agent:main:main",
+      lastRoutePolicy: "session" as const,
+      matchedBy: "default" as const,
+    };
+    const resolveAgentRoute = vi.fn().mockReturnValue({ ...baseRoute });
+    const core = {
+      channel: {
+        routing: {
+          resolveAgentRoute,
+        },
+      },
+    } as unknown as PluginRuntime;
+    const cfg = {
+      channels: {
+        wecom: {
+          dynamicAgents: {
+            enabled: true,
+          },
+        },
+      },
+    } as OpenClawConfig;
+    const event = {
+      accountId: "acct-ws",
+      conversation: {
+        accountId: "acct-ws",
+        peerKind: "direct",
+        peerId: "HiDaoMax",
+        senderId: "HiDaoMax",
+      },
+    } as UnifiedInboundEvent;
+
+    const route = resolveRuntimeRoute({ core, cfg, event });
+
+    expect(resolveAgentRoute).toHaveBeenCalledOnce();
+    expect(route.agentId).toBe("wecom-acct-ws-dm-hidaomax");
+    expect(route.sessionKey).toBe(
+      "agent:wecom-acct-ws-dm-hidaomax:wecom:acct-ws:dm:HiDaoMax",
+    );
+    expect(vi.mocked(ensureDynamicAgentListed)).toHaveBeenCalledWith(
+      "wecom-acct-ws-dm-hidaomax",
+      core,
+    );
+  });
+
+  it("keeps the resolved core route when dynamic agent routing is disabled for the sender", () => {
+    const baseRoute = {
+      agentId: "main",
+      channel: "wecom",
+      accountId: "acct-ws",
+      sessionKey: "agent:main",
+      mainSessionKey: "agent:main:main",
+      lastRoutePolicy: "session" as const,
+      matchedBy: "binding.account" as const,
+    };
+    const core = {
+      channel: {
+        routing: {
+          resolveAgentRoute: vi.fn().mockReturnValue({ ...baseRoute }),
+        },
+      },
+    } as unknown as PluginRuntime;
+    const cfg = {
+      channels: {
+        wecom: {
+          dynamicAgents: {
+            enabled: true,
+            adminUsers: ["HiDaoMax"],
+          },
+        },
+      },
+    } as OpenClawConfig;
+    const event = {
+      accountId: "acct-ws",
+      conversation: {
+        accountId: "acct-ws",
+        peerKind: "direct",
+        peerId: "HiDaoMax",
+        senderId: "HiDaoMax",
+      },
+    } as UnifiedInboundEvent;
+
+    const route = resolveRuntimeRoute({ core, cfg, event });
+
+    expect(route).toEqual(baseRoute);
+    expect(vi.mocked(ensureDynamicAgentListed)).not.toHaveBeenCalled();
+  });
+});

package/src/runtime/routing-bridge.ts

@@ -1,5 +1,10 @@
 import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
 
+import {
+  ensureDynamicAgentListed,
+  generateAgentId,
+  shouldUseDynamicAgent,
+} from "../dynamic-agent.js";
 import type { UnifiedInboundEvent } from "../types/index.js";
 
 export function resolveRuntimeRoute(params: {
@@ -7,7 +12,7 @@ export function resolveRuntimeRoute(params: {
   cfg: OpenClawConfig;
   event: UnifiedInboundEvent;
 }) {
-  return params.core.channel.routing.resolveAgentRoute({
+  const route = params.core.channel.routing.resolveAgentRoute({
     cfg: params.cfg,
     channel: "wecom",
     accountId: params.event.accountId,
@@ -16,4 +21,24 @@ export function resolveRuntimeRoute(params: {
       id: params.event.conversation.peerId,
     },
   });
+
+  const chatType = params.event.conversation.peerKind === "group" ? "group" : "dm";
+  const useDynamicAgent = shouldUseDynamicAgent({
+    chatType,
+    senderId: params.event.conversation.senderId,
+    config: params.cfg,
+  });
+  if (!useDynamicAgent) {
+    return route;
+  }
+
+  const targetAgentId = generateAgentId(
+    chatType,
+    params.event.conversation.peerId,
+    params.event.accountId,
+  );
+  route.agentId = targetAgentId;
+  route.sessionKey = `agent:${targetAgentId}:wecom:${params.event.accountId}:${chatType}:${params.event.conversation.peerId}`;
+  ensureDynamicAgentListed(targetAgentId, params.core).catch(() => {});
+  return route;
 }

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 };