@yanhaidao/wecom 2.3.190 → 2.3.260

package/src/runtime/session-manager.test.ts

@@ -0,0 +1,135 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { prepareInboundSession } from "./session-manager.js";
+
+const {
+  resolveRuntimeRoute,
+  getPeerContextToken,
+  registerWecomSourceSnapshot,
+} = vi.hoisted(() => ({
+  resolveRuntimeRoute: vi.fn(),
+  getPeerContextToken: vi.fn(),
+  registerWecomSourceSnapshot: vi.fn(),
+}));
+
+vi.mock("./routing-bridge.js", () => ({
+  resolveRuntimeRoute,
+}));
+
+vi.mock("../context-store.js", () => ({
+  getPeerContextToken,
+}));
+
+vi.mock("./source-registry.js", () => ({
+  registerWecomSourceSnapshot,
+}));
+
+function createCore() {
+  const finalizeInboundContext = vi.fn((ctx) => ctx);
+  const recordInboundSession = vi.fn(async () => {});
+
+  return {
+    core: {
+      channel: {
+        session: {
+          resolveStorePath: vi.fn(() => "/tmp/wecom-session-store"),
+          readSessionUpdatedAt: vi.fn(() => 1234567890),
+          recordInboundSession,
+        },
+        reply: {
+          resolveEnvelopeFormatOptions: vi.fn(() => ({ envelope: "default" })),
+          formatAgentEnvelope: vi.fn(() => "formatted-body"),
+          finalizeInboundContext,
+        },
+      },
+    } as any,
+    finalizeInboundContext,
+    recordInboundSession,
+  };
+}
+
+function createMediaService() {
+  return {
+    normalizeFirstAttachment: vi.fn(async () => undefined),
+    saveInboundAttachment: vi.fn(async () => undefined),
+  } as any;
+}
+
+describe("prepareInboundSession", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resolveRuntimeRoute.mockReturnValue({
+      sessionKey: "agent:ops_bot:wecom:direct:hidaomax",
+      agentId: "ops_bot",
+      accountId: "default",
+    });
+  });
+
+  it("marks bot-ws turns as the current wecom surface", async () => {
+    getPeerContextToken.mockReturnValue("ctx-bot");
+    const { core, finalizeInboundContext, recordInboundSession } = createCore();
+
+    const result = await prepareInboundSession({
+      core,
+      cfg: {} as any,
+      event: {
+        accountId: "default",
+        transport: "bot-ws",
+        messageId: "msg-bot-1",
+        conversation: {
+          peerKind: "direct",
+          peerId: "HiDaoMax",
+          senderId: "HiDaoMax",
+        },
+        senderName: "HiDaoMax",
+        text: "hello",
+      } as any,
+      mediaService: createMediaService(),
+    });
+
+    expect(finalizeInboundContext).toHaveBeenCalledWith(
+      expect.objectContaining({
+        Provider: "wecom",
+        Surface: "wecom",
+        OriginatingChannel: "wecom",
+        OriginatingTo: "wecom:context:ctx-bot",
+        To: "wecom:user:HiDaoMax",
+      }),
+    );
+    expect(recordInboundSession).toHaveBeenCalledTimes(1);
+    expect(result.ctx.Provider).toBe("wecom");
+    expect(result.ctx.Surface).toBe("wecom");
+  });
+
+  it("keeps agent-callback turns on provider-only context", async () => {
+    getPeerContextToken.mockReturnValue(undefined);
+    const { core, finalizeInboundContext } = createCore();
+
+    const result = await prepareInboundSession({
+      core,
+      cfg: {} as any,
+      event: {
+        accountId: "default",
+        transport: "agent-callback",
+        messageId: "msg-agent-1",
+        conversation: {
+          peerKind: "direct",
+          peerId: "HiDaoMax",
+          senderId: "HiDaoMax",
+        },
+        senderName: "HiDaoMax",
+        text: "hello",
+      } as any,
+      mediaService: createMediaService(),
+    });
+
+    expect(finalizeInboundContext).toHaveBeenCalledWith(
+      expect.objectContaining({
+        Provider: "wecom",
+        OriginatingChannel: "wecom",
+        OriginatingTo: "wecom:user:HiDaoMax",
+      }),
+    );
+    expect(result.ctx.Provider).toBe("wecom");
+    expect(result.ctx).not.toHaveProperty("Surface");
+  });
+});

package/src/runtime/session-manager.ts

@@ -1,6 +1,8 @@
 import type { OpenClawConfig, PluginRuntime } from "openclaw/plugin-sdk";
 import type { WecomMediaService } from "../shared/media-service.js";
 import type { UnifiedInboundEvent } from "../types/index.js";
+import { getPeerContextToken } from "../context-store.js";
+import { buildWecomContextTarget } from "../target.js";
 import { resolveRuntimeRoute } from "./routing-bridge.js";
 import { registerWecomSourceSnapshot } from "./source-registry.js";
 
@@ -18,12 +20,20 @@ export async function prepareInboundSession(params: {
 }): Promise<PreparedSession> {
   const { core, cfg, event, mediaService } = params;
   const route = resolveRuntimeRoute({ core, cfg, event });
-  if (event.transport === "bot-ws") {
+  const source =
+    event.transport === "bot-ws"
+      ? "bot-ws"
+      : event.transport === "agent-callback"
+        ? "agent-callback"
+        : undefined;
+  if (source) {
     registerWecomSourceSnapshot({
       accountId: event.accountId,
-      source: "bot-ws",
+      source,
       messageId: event.messageId,
       sessionKey: route.sessionKey,
+      peerKind: event.conversation.peerKind,
+      peerId: event.conversation.peerId,
     });
   }
   const storePath = core.channel.session.resolveStorePath(cfg.session?.store, {
@@ -46,6 +56,30 @@ export async function prepareInboundSession(params: {
   const mediaPath = firstAttachment
     ? await mediaService.saveInboundAttachment(event, firstAttachment)
     : undefined;
+  const defaultOriginatingTo =
+    event.conversation.peerKind === "group"
+      ? `wecom:group:${event.conversation.peerId}`
+      : `wecom:user:${event.conversation.peerId}`;
+  const contextToken =
+    event.transport === "bot-ws"
+      ? getPeerContextToken(event.accountId, event.conversation.peerId)
+      : undefined;
+  const originatingTo = contextToken
+    ? buildWecomContextTarget(contextToken)
+    : defaultOriginatingTo;
+  const providerContext =
+    event.transport === "bot-ws"
+      ? {
+          // Bot WS inbound turns already have a live reply handle bound to the
+          // current req_id. Mark the current surface as WeCom so core final text
+          // stays on that handle and replaces the placeholder instead of being
+          // re-routed as a second active-push message.
+          Provider: "wecom" as const,
+          Surface: "wecom" as const,
+        }
+      : {
+          Provider: "wecom" as const,
+        };
 
   const ctx = core.channel.reply.finalizeInboundContext({
     Body: body,
@@ -65,13 +99,11 @@ export async function prepareInboundSession(params: {
     ConversationLabel: `${event.conversation.peerKind}:${event.conversation.peerId}`,
     SenderName: event.senderName ?? event.conversation.senderId,
     SenderId: event.conversation.senderId,
-    Provider: "wecom",
-    Surface: "wecom",
+    // Keep Originating* populated so explicit route-to-origin flows and message
+    // tools can still resolve the active peer context when needed.
+    ...providerContext,
     OriginatingChannel: "wecom",
-    OriginatingTo:
-      event.conversation.peerKind === "group"
-        ? `wecom:group:${event.conversation.peerId}`
-        : `wecom:user:${event.conversation.peerId}`,
+    OriginatingTo: originatingTo,
     MessageSid: event.messageId,
     CommandAuthorized: true,
     MediaPath: mediaPath,

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-ws/media.test.ts

@@ -1,10 +1,10 @@
 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";
-import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk";
 
-vi.mock("openclaw/plugin-sdk", () => ({
+vi.mock("openclaw/plugin-sdk/media-runtime", () => ({
   detectMime: vi.fn(),
   loadOutboundMediaFromUrl: vi.fn(),
 }));

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;

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

@@ -2,7 +2,7 @@ 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";
+import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/infra-runtime";
 import { uploadAndSendBotWsMedia } from "./media.js";
 import { createBotWsReplyHandle } from "./reply.js";
 

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

@@ -5,10 +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;
@@ -307,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",
           );
         }
@@ -356,5 +357,9 @@ export function createBotWsReplyHandle(params: {
       }
       params.onFail?.(error);
     },
+    markExternalActivity: () => {
+      notifyPeerActive();
+      stopPlaceholderKeepalive();
+    },
   };
 }

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/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 = {