@yanhaidao/wecom 2.3.13 → 2.3.14

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

@@ -1,31 +1,52 @@
-import { describe, expect, it, vi, afterEach } from "vitest";
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+
+import type { WSClient } from "@wecom/aibot-node-sdk";
 
 import { createBotWsReplyHandle } from "./reply.js";
 
 type ReplyHandleParams = Parameters<typeof createBotWsReplyHandle>[0];
 
 describe("createBotWsReplyHandle", () => {
+  let mockClient: import("vitest").Mocked<WSClient>;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    mockClient = {
+      replyStream: vi.fn(),
+      sendMessage: vi.fn(),
+      replyWelcome: vi.fn(),
+    } as unknown as import("vitest").Mocked<WSClient>;
+    mockClient.replyStream.mockResolvedValue({} as any);
+    mockClient.sendMessage.mockResolvedValue({} as any);
+    mockClient.replyWelcome.mockResolvedValue({} as any);
+  });
+
   afterEach(() => {
+    vi.clearAllTimers();
     vi.useRealTimers();
+    vi.restoreAllMocks();
   });
 
   it("uses configured placeholder content for immediate ws ack", async () => {
-    const replyStream = vi.fn().mockResolvedValue(undefined);
     createBotWsReplyHandle({
-      client: {
-        replyStream,
-      } as unknown as ReplyHandleParams["client"],
+      client: mockClient,
       frame: {
         headers: { req_id: "req-1" },
-        body: {},
+        body: { chatid: "123", chattype: "group" },
+        cmd: "aibot_msg_callback",
       } as unknown as ReplyHandleParams["frame"],
       accountId: "default",
+      inboundKind: "text",
       placeholderContent: "正在思考...",
     });
 
-    expect(replyStream).toHaveBeenCalledWith(
+    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),
       "正在思考...",
@@ -34,29 +55,30 @@ describe("createBotWsReplyHandle", () => {
   });
 
   it("keeps placeholder alive until the first real ws chunk arrives", async () => {
-    vi.useFakeTimers();
-
-    const replyStream = vi.fn().mockResolvedValue(undefined);
     const handle = createBotWsReplyHandle({
-      client: {
-        replyStream,
-      } as unknown as ReplyHandleParams["client"],
+      client: mockClient,
       frame: {
         headers: { req_id: "req-keepalive" },
         body: {},
       } as unknown as ReplyHandleParams["frame"],
       accountId: "default",
+      inboundKind: "text",
       placeholderContent: "正在思考...",
     });
 
-    await vi.advanceTimersByTimeAsync(3000);
-    expect(replyStream).toHaveBeenCalledTimes(2);
+    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();
+    expect(mockClient.replyStream).toHaveBeenCalledTimes(2);
 
-    await handle.deliver({ text: "最终回复" }, { kind: "final" });
-    await vi.advanceTimersByTimeAsync(6000);
+    handle.deliver({ text: "最终回复", isReasoning: false }, { kind: "final" });
+    await Promise.resolve();
 
-    expect(replyStream).toHaveBeenCalledTimes(3);
-    expect(replyStream).toHaveBeenLastCalledWith(
+    expect(mockClient.replyStream).toHaveBeenCalledWith(
       expect.objectContaining({
         headers: { req_id: "req-keepalive" },
       }),
@@ -64,66 +86,63 @@ describe("createBotWsReplyHandle", () => {
       "最终回复",
       true,
     );
+
+    // Ensure interval is cleared
+    vi.advanceTimersByTime(6000);
+    await Promise.resolve();
+    expect(mockClient.replyStream).toHaveBeenCalledTimes(3); 
   });
 
-  it("does not auto-send placeholder when disabled", () => {
-    const replyStream = vi.fn().mockResolvedValue(undefined);
+  it("does not auto-send placeholder when disabled", async () => {
     createBotWsReplyHandle({
-      client: {
-        replyStream,
-      } as unknown as ReplyHandleParams["client"],
+      client: mockClient,
       frame: {
         headers: { req_id: "req-2" },
         body: {},
       } as unknown as ReplyHandleParams["frame"],
       accountId: "default",
+      inboundKind: "text",
       autoSendPlaceholder: false,
     });
 
-    expect(replyStream).not.toHaveBeenCalled();
+    vi.advanceTimersByTime(3000);
+    await Promise.resolve();
+    expect(mockClient.replyStream).not.toHaveBeenCalled();
   });
 
   it("sends cumulative content for block streaming updates", async () => {
-    const replyStream = vi.fn().mockResolvedValue(undefined);
     const handle = createBotWsReplyHandle({
-      client: {
-        replyStream,
-      } as unknown as ReplyHandleParams["client"],
+      client: mockClient,
       frame: {
         headers: { req_id: "req-blocks" },
         body: {},
       } as unknown as ReplyHandleParams["frame"],
       accountId: "default",
+      inboundKind: "text",
       autoSendPlaceholder: false,
     });
 
-    await handle.deliver({ text: "第一段" }, { kind: "block" });
-    await handle.deliver({ text: "第二段" }, { kind: "block" });
-    await handle.deliver({ text: "收尾" }, { kind: "final" });
+    await handle.deliver({ text: "第一段", isReasoning: false }, { kind: "block" });
+    await handle.deliver({ text: "第二段", isReasoning: false }, { kind: "block" });
+    await handle.deliver({ text: "收尾", isReasoning: false }, { kind: "final" });
 
-    expect(replyStream).toHaveBeenNthCalledWith(
+    expect(mockClient.replyStream).toHaveBeenNthCalledWith(
       1,
-      expect.objectContaining({
-        headers: { req_id: "req-blocks" },
-      }),
+      expect.objectContaining({ headers: { req_id: "req-blocks" } }),
       expect.any(String),
       "第一段",
       false,
     );
-    expect(replyStream).toHaveBeenNthCalledWith(
+    expect(mockClient.replyStream).toHaveBeenNthCalledWith(
       2,
-      expect.objectContaining({
-        headers: { req_id: "req-blocks" },
-      }),
+      expect.objectContaining({ headers: { req_id: "req-blocks" } }),
       expect.any(String),
       "第一段\n第二段",
       false,
     );
-    expect(replyStream).toHaveBeenNthCalledWith(
+    expect(mockClient.replyStream).toHaveBeenNthCalledWith(
       3,
-      expect.objectContaining({
-        headers: { req_id: "req-blocks" },
-      }),
+      expect.objectContaining({ headers: { req_id: "req-blocks" } }),
       expect.any(String),
       "第一段\n第二段\n收尾",
       true,
@@ -136,24 +155,24 @@ describe("createBotWsReplyHandle", () => {
       errcode: 846608,
       errmsg: "stream message update expired (>6 minutes), cannot update",
     };
-    const replyStream = vi.fn().mockRejectedValue(expiredError);
+    mockClient.replyStream.mockRejectedValueOnce(expiredError);
     const onFail = vi.fn();
+    
     const handle = createBotWsReplyHandle({
-      client: {
-        replyStream,
-      } as unknown as ReplyHandleParams["client"],
+      client: mockClient,
       frame: {
         headers: { req_id: "req-expired" },
         body: {},
       } as unknown as ReplyHandleParams["frame"],
       accountId: "default",
+      inboundKind: "text",
       autoSendPlaceholder: false,
       onFail,
     });
 
-    await expect(handle.deliver({ text: "最终回复" }, { kind: "final" })).resolves.toBeUndefined();
+    await handle.deliver({ text: "最终回复", isReasoning: false }, { kind: "final" });
 
-    expect(replyStream).toHaveBeenCalledTimes(1);
+    expect(mockClient.replyStream).toHaveBeenCalledTimes(1);
     expect(onFail).toHaveBeenCalledWith(expiredError);
   });
 
@@ -161,24 +180,73 @@ describe("createBotWsReplyHandle", () => {
     [{ 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" }],
   ])("does not retry error reply when the ws reply window is already closed", async (error) => {
-    const replyStream = vi.fn().mockResolvedValue(undefined);
     const onFail = vi.fn();
     const handle = createBotWsReplyHandle({
-      client: {
-        replyStream,
-      } as unknown as ReplyHandleParams["client"],
+      client: mockClient,
       frame: {
         headers: { req_id: String(error.headers.req_id) },
         body: {},
       } as unknown as ReplyHandleParams["frame"],
       accountId: "default",
+      inboundKind: "text",
       autoSendPlaceholder: false,
       onFail,
     });
 
     await handle.fail?.(error);
 
-    expect(replyStream).not.toHaveBeenCalled();
+    expect(mockClient.replyStream).not.toHaveBeenCalled();
     expect(onFail).toHaveBeenCalledTimes(1);
   });
+
+  it("sends simple fallback message for ordinary events without placeholders", async () => {
+    const handle = createBotWsReplyHandle({
+      client: mockClient,
+      frame: {
+        headers: { req_id: "event_req" },
+        body: { chattype: "single", from: { userid: "alice" } },
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      inboundKind: "event",
+    });
+
+    vi.advanceTimersByTime(3000);
+    await Promise.resolve();
+    // Events should not send stream placeholders
+    expect(mockClient.replyStream).not.toHaveBeenCalled();
+
+    handle.deliver({ text: "Event Reply", isReasoning: false }, { kind: "final" });
+    await Promise.resolve();
+
+    expect(mockClient.sendMessage).toHaveBeenCalledWith(
+      "alice",
+      {
+        msgtype: "markdown",
+        markdown: { content: "Event Reply" },
+      }
+    );
+  });
+
+  it("sends replyWelcome for welcome events", async () => {
+    const handle = createBotWsReplyHandle({
+      client: mockClient,
+      frame: {
+        headers: { req_id: "welcome_req" },
+        body: { chattype: "single", from: { userid: "bob" } },
+      } as unknown as ReplyHandleParams["frame"],
+      accountId: "default",
+      inboundKind: "welcome",
+    });
+
+    handle.deliver({ text: "Hello Bob", isReasoning: false }, { kind: "final" });
+    await Promise.resolve();
+
+    expect(mockClient.replyWelcome).toHaveBeenCalledWith(
+      expect.objectContaining({ headers: { req_id: "welcome_req" } }),
+      {
+        msgtype: "text",
+        text: { content: "Hello Bob" },
+      }
+    );
+  });
 });

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

@@ -4,6 +4,7 @@ import { generateReqId, type WsFrame, type BaseMessage, type EventMessage, type
 import type { ReplyHandle, ReplyPayload } from "../../types/index.js";
 
 const PLACEHOLDER_KEEPALIVE_MS = 3000;
+const MAX_KEEPALIVE_MS = 120 * 1000; // Force stop keepalive after 120s if ignored
 
 function isInvalidReqIdError(error: unknown): boolean {
   if (!error || typeof error !== "object") {
@@ -34,10 +35,18 @@ function isTerminalReplyError(error: unknown): boolean {
   return isInvalidReqIdError(error) || isExpiredStreamUpdateError(error) || isAckTimeoutError(error);
 }
 
+// Global registry to track active keepalives by peerId
+interface ActiveKeepalive {
+  reqId: string;
+  stop: () => void;
+}
+const activeKeepalivesByPeer = new Map<string, Set<ActiveKeepalive>>();
+
 export function createBotWsReplyHandle(params: {
   client: WSClient;
   frame: WsFrame<BaseMessage | EventMessage>;
   accountId: string;
+  inboundKind: string;
   placeholderContent?: string;
   autoSendPlaceholder?: boolean;
   onDeliver?: () => void;
@@ -54,20 +63,49 @@ export function createBotWsReplyHandle(params: {
   let streamSettled = false;
   let placeholderInFlight = false;
   let placeholderKeepalive: ReturnType<typeof setInterval> | undefined;
+  let placeholderTimeout: ReturnType<typeof setTimeout> | undefined;
+
+  // Extract peerId for clustering handles
+  const body = params.frame.body as any;
+  const peerId = String(
+    (body?.chattype === "group" ? body?.chatid || body?.from?.userid : body?.from?.userid) || "unknown"
+  );
+  const reqId = params.frame.headers.req_id || "unknown";
+
+  const isEvent = params.inboundKind === "welcome" || params.inboundKind === "event" || params.inboundKind === "template-card-event";
 
   const stopPlaceholderKeepalive = () => {
-    if (!placeholderKeepalive) return;
-    clearInterval(placeholderKeepalive);
-    placeholderKeepalive = undefined;
+    if (placeholderKeepalive) {
+      clearInterval(placeholderKeepalive);
+      placeholderKeepalive = undefined;
+    }
+    if (placeholderTimeout) {
+      clearTimeout(placeholderTimeout);
+      placeholderTimeout = undefined;
+    }
+    
+    // Remove from registry
+    const keepalives = activeKeepalivesByPeer.get(peerId);
+    if (keepalives) {
+      for (const ka of keepalives) {
+        if (ka.reqId === reqId) {
+          keepalives.delete(ka);
+        }
+      }
+      if (keepalives.size === 0) {
+        activeKeepalivesByPeer.delete(peerId);
+      }
+    }
   };
 
   const settleStream = () => {
+    if (streamSettled) return;
     streamSettled = true;
     stopPlaceholderKeepalive();
   };
 
   const sendPlaceholder = () => {
-    if (streamSettled || placeholderInFlight) return;
+    if (streamSettled || placeholderInFlight || isEvent) return;
     placeholderInFlight = true;
     params.client.replyStream(params.frame, resolveStreamId(), placeholderText, false)
       .catch((error) => {
@@ -82,11 +120,39 @@ export function createBotWsReplyHandle(params: {
       });
   };
 
-  if (params.autoSendPlaceholder !== false) {
+  const notifyPeerActive = () => {
+    // A genuine reply or reasoning is happening on THIS handle.
+    // It means the core SDK has chosen this handle to deliver the response.
+    // We can safely terminate all other orphaned keepalives for this peer to prevent infinite loops.
+    const keepalives = activeKeepalivesByPeer.get(peerId);
+    if (keepalives) {
+      for (const ka of keepalives) {
+        if (ka.reqId !== reqId) {
+          ka.stop();
+        }
+      }
+    }
+  };
+
+  if (params.autoSendPlaceholder !== false && !isEvent) {
     sendPlaceholder();
     placeholderKeepalive = setInterval(() => {
       sendPlaceholder();
     }, PLACEHOLDER_KEEPALIVE_MS);
+    
+    // Safety net: force stop keepalive after MAX_KEEPALIVE_MS 
+    // in case the message is completely ignored by the core and never triggers deliver/fail
+    placeholderTimeout = setTimeout(() => {
+      stopPlaceholderKeepalive();
+    }, MAX_KEEPALIVE_MS);
+
+    // Register keepalive
+    let keepalives = activeKeepalivesByPeer.get(peerId);
+    if (!keepalives) {
+      keepalives = new Set();
+      activeKeepalivesByPeer.set(peerId, keepalives);
+    }
+    keepalives.add({ reqId, stop: stopPlaceholderKeepalive });
   }
 
   return {
@@ -103,7 +169,19 @@ export function createBotWsReplyHandle(params: {
       },
     },
     deliver: async (payload: ReplyPayload, info) => {
-      if (payload.isReasoning) return;
+      // Mark this chat as active on this handle
+      notifyPeerActive();
+
+      if (payload.isReasoning) {
+        // We reset the safety timeout if reasoning is actively streaming
+        if (placeholderTimeout && !isEvent) {
+          clearTimeout(placeholderTimeout);
+          placeholderTimeout = setTimeout(() => {
+            stopPlaceholderKeepalive();
+          }, MAX_KEEPALIVE_MS);
+        }
+        return;
+      }
 
       const text = payload.text?.trim();
       if (!text) return;
@@ -121,14 +199,32 @@ export function createBotWsReplyHandle(params: {
             : text
           : accumulatedText || text;
 
+      // Event frames do not support streaming chunks
+      if (isEvent && info.kind !== "final") {
+        return;
+      }
+
       settleStream();
       try {
-        await params.client.replyStream(
-          params.frame,
-          resolveStreamId(),
-          outboundText,
-          info.kind === "final",
-        );
+        if (params.inboundKind === "welcome") {
+          await params.client.replyWelcome(params.frame, {
+            msgtype: "text",
+            text: { content: outboundText },
+          });
+        } else if (isEvent) {
+          // Send push message for other events
+          await params.client.sendMessage(peerId, {
+            msgtype: "markdown",
+            markdown: { content: outboundText },
+          });
+        } else {
+          await params.client.replyStream(
+            params.frame,
+            resolveStreamId(),
+            outboundText,
+            info.kind === "final",
+          );
+        }
       } catch (error) {
         if (isTerminalReplyError(error)) {
           params.onFail?.(error);
@@ -139,14 +235,26 @@ export function createBotWsReplyHandle(params: {
       params.onDeliver?.();
     },
     fail: async (error: unknown) => {
+      notifyPeerActive();
       settleStream();
       if (isTerminalReplyError(error)) {
         params.onFail?.(error);
         return;
       }
       const message = formatErrorMessage(error);
+      const text = `WeCom WS reply failed: ${message}`;
+      
       try {
-        await params.client.replyStream(params.frame, resolveStreamId(), `WeCom WS reply failed: ${message}`, true);
+        if (params.inboundKind === "welcome") {
+            await params.client.replyWelcome(params.frame, { msgtype: "text", text: { content: text }});
+        } else if (isEvent) {
+            await params.client.sendMessage(peerId, {
+              msgtype: "markdown",
+              markdown: { content: text },
+            });
+        } else {
+            await params.client.replyStream(params.frame, resolveStreamId(), text, true);
+        }
       } catch (sendError) {
         params.onFail?.(sendError);
         return;

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

@@ -149,6 +149,7 @@ export class BotWsSdkAdapter {
         client,
         frame,
         accountId: this.runtime.account.accountId,
+        inboundKind: event.inboundKind,
         placeholderContent: botAccount.config.streamPlaceholderContent,
         autoSendPlaceholder:
           event.inboundKind === "text" ||

package/src/types/runtime.ts

@@ -19,7 +19,10 @@ export type WecomInboundKind =
   | "image"
   | "file"
   | "voice"
+  | "video"
   | "mixed"
+  | "location"
+  | "link"
   | "event"
   | "welcome"
   | "template-card-event";