@yanhaidao/wecom 2.3.160 → 2.3.180

package/src/config/schema.ts

@@ -1,114 +1,83 @@
-import { z } from "zod";
-
-function bindToJsonSchema<T extends z.ZodTypeAny>(schema: T): T {
-  const schemaWithJson = schema as T & { toJSONSchema?: (...args: unknown[]) => unknown };
-  if (typeof schemaWithJson.toJSONSchema === "function") {
-    schemaWithJson.toJSONSchema = schemaWithJson.toJSONSchema.bind(schema);
-  }
-  return schema;
+export interface DmConfig {
+  policy?: "pairing" | "allowlist" | "open" | "disabled";
+  allowFrom?: (string | number)[];
 }
 
-const dmSchema = z
-  .object({
-    policy: z.enum(["pairing", "allowlist", "open", "disabled"]).optional(),
-    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
-  })
-  .optional();
-
-const mediaSchema = z
-  .object({
-    tempDir: z.string().optional(),
-    retentionHours: z.number().optional(),
-    cleanupOnStart: z.boolean().optional(),
-    maxBytes: z.number().optional(),
-  })
-  .optional();
+export interface MediaConfig {
+  tempDir?: string;
+  retentionHours?: number;
+  cleanupOnStart?: boolean;
+  maxBytes?: number;
+}
 
-const networkSchema = z
-  .object({
-    egressProxyUrl: z.string().optional(),
-  })
-  .optional();
+export interface NetworkConfig {
+  egressProxyUrl?: string;
+}
 
-const routingSchema = z
-  .object({
-    failClosedOnDefaultRoute: z.boolean().optional(),
-  })
-  .optional();
+export interface RoutingConfig {
+  failClosedOnDefaultRoute?: boolean;
+}
 
-const botWsSchema = z
-  .object({
-    botId: z.string(),
-    secret: z.string(),
-  })
-  .optional();
+export interface BotWsConfig {
+  botId: string;
+  secret: string;
+}
 
-const botWebhookSchema = z
-  .object({
-    token: z.string(),
-    encodingAESKey: z.string(),
-    receiveId: z.string().optional(),
-  })
-  .optional();
+export interface BotWebhookConfig {
+  token: string;
+  encodingAESKey: string;
+  receiveId?: string;
+}
 
-const botSchema = z
-  .object({
-    primaryTransport: z.enum(["ws", "webhook"]).optional(),
-    streamPlaceholderContent: z.string().optional(),
-    welcomeText: z.string().optional(),
-    dm: dmSchema,
-    aibotid: z.string().optional(),
-    botIds: z.array(z.string()).optional(),
-    ws: botWsSchema,
-    webhook: botWebhookSchema,
-  })
-  .optional();
+export interface BotConfig {
+  primaryTransport?: "ws" | "webhook";
+  streamPlaceholderContent?: string;
+  welcomeText?: string;
+  dm?: DmConfig;
+  aibotid?: string;
+  botIds?: string[];
+  ws?: BotWsConfig;
+  webhook?: BotWebhookConfig;
+}
 
-const agentSchema = z
-  .object({
-    corpId: z.string(),
-    agentSecret: z.string().optional(),
-    corpSecret: z.string().optional(),
-    agentId: z.union([z.number(), z.string()]).optional(),
-    token: z.string(),
-    encodingAESKey: z.string(),
-    welcomeText: z.string().optional(),
-    dm: dmSchema,
-  })
-  .refine((value) => Boolean(value.agentSecret?.trim() || value.corpSecret?.trim()), {
-    path: ["agentSecret"],
-    message: "agentSecret 不能为空",
-  })
-  .optional();
+export interface AgentConfig {
+  corpId: string;
+  agentSecret?: string;
+  corpSecret?: string;
+  agentId?: number | string;
+  token: string;
+  encodingAESKey: string;
+  welcomeText?: string;
+  dm?: DmConfig;
+}
 
-const dynamicAgentsSchema = z
-  .object({
-    enabled: z.boolean().optional(),
-    dmCreateAgent: z.boolean().optional(),
-    groupEnabled: z.boolean().optional(),
-    adminUsers: z.array(z.string()).optional(),
-  })
-  .optional();
+export interface DynamicAgentsConfig {
+  enabled?: boolean;
+  dmCreateAgent?: boolean;
+  groupEnabled?: boolean;
+  adminUsers?: string[];
+}
 
-const accountSchema = z.object({
-  enabled: z.boolean().optional(),
-  name: z.string().optional(),
-  bot: botSchema,
-  agent: agentSchema,
-});
+export interface AccountConfig {
+  enabled?: boolean;
+  name?: string;
+  bot?: BotConfig;
+  agent?: AgentConfig;
+}
 
-export const WecomConfigSchema = bindToJsonSchema(
-  z.object({
-    enabled: z.boolean().optional(),
-    bot: botSchema,
-    agent: agentSchema,
-    accounts: z.record(z.string(), accountSchema).optional(),
-    defaultAccount: z.string().optional(),
-    media: mediaSchema,
-    network: networkSchema,
-    routing: routingSchema,
-    dynamicAgents: dynamicAgentsSchema,
-  }),
-);
+export interface WecomConfigInput {
+  enabled?: boolean;
+  bot?: BotConfig;
+  agent?: AgentConfig;
+  accounts?: Record<string, AccountConfig>;
+  defaultAccount?: string;
+  media?: MediaConfig;
+  network?: NetworkConfig;
+  routing?: RoutingConfig;
+  dynamicAgents?: DynamicAgentsConfig;
+}
 
-export type WecomConfigInput = z.infer<typeof WecomConfigSchema>;
+/**
+ * @deprecated No longer a Zod schema. Kept as a type-only export for backward compatibility.
+ */
+export const WecomConfigSchema = undefined;

package/src/outbound.test.ts

@@ -1,4 +1,5 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { BotWsPushHandle } from "./app/index.js";
 
 vi.mock("./transport/agent-api/core.js", () => ({
   sendText: vi.fn(),
@@ -7,6 +8,25 @@ vi.mock("./transport/agent-api/core.js", () => ({
 }));
 
 describe("wecomOutbound", () => {
+  const createBotWsHandle = (overrides: Partial<BotWsPushHandle> = {}): BotWsPushHandle => ({
+    isConnected: () => true,
+    sendMarkdown: vi.fn().mockResolvedValue(undefined),
+    replyCommand: vi.fn().mockResolvedValue({ errcode: 0 }),
+    sendMedia: vi.fn().mockResolvedValue({ ok: true, messageId: "ws-media-1" }),
+    ...overrides,
+  });
+
+  beforeEach(async () => {
+    const runtime = await import("./runtime.js");
+    runtime.setWecomRuntime({
+      channel: {
+        text: {
+          chunkText: (text: string) => [text],
+        },
+      },
+    } as any);
+  });
+
   afterEach(async () => {
     const runtime = await import("./runtime.js");
     runtime.unregisterBotWsPushHandle("default");
@@ -80,9 +100,9 @@ describe("wecomOutbound", () => {
     };
 
     // Chat ID (wr/wc) is intentionally NOT supported for Agent outbound.
-    await expect(wecomOutbound.sendText({ cfg, to: "wr123", text: "hello" } as any)).rejects.toThrow(
-      /不支持向群 chatId 发送/,
-    );
+    await expect(
+      wecomOutbound.sendText({ cfg, to: "wr123", text: "hello" } as any),
+    ).rejects.toThrow(/不支持向群 chatId 发送/);
     expect(api.sendText).not.toHaveBeenCalled();
 
     // Test: User ID (Default)
@@ -186,10 +206,12 @@ describe("wecomOutbound", () => {
     const api = await import("./transport/agent-api/core.js");
     const sendMarkdown = vi.fn().mockResolvedValue(undefined);
     const now = vi.spyOn(Date, "now").mockReturnValue(789);
-    runtime.registerBotWsPushHandle("acct-ws", {
-      isConnected: () => true,
-      sendMarkdown,
-    });
+    runtime.registerBotWsPushHandle(
+      "acct-ws",
+      createBotWsHandle({
+        sendMarkdown,
+      }),
+    );
     (api.sendText as any).mockClear();
 
     const cfg = {
@@ -271,15 +293,70 @@ describe("wecomOutbound", () => {
     expect(api.sendText).not.toHaveBeenCalled();
   });
 
-  it("keeps outbound media on Agent even when Bot WS is active", async () => {
+  it("prefers Bot WS for outbound media when ws is the active bot transport", async () => {
     const { wecomOutbound } = await import("./outbound.js");
     const runtime = await import("./runtime.js");
     const api = await import("./transport/agent-api/core.js");
-    const sendMarkdown = vi.fn().mockResolvedValue(undefined);
-    runtime.registerBotWsPushHandle("default", {
-      isConnected: () => true,
-      sendMarkdown,
+    const sendMedia = vi.fn().mockResolvedValue({ ok: true, messageId: "ws-media-1" });
+    runtime.registerBotWsPushHandle(
+      "default",
+      createBotWsHandle({
+        sendMedia,
+      }),
+    );
+    (api.uploadMedia as any).mockResolvedValue("media-1");
+    (api.sendMedia as any).mockResolvedValue(undefined);
+    (api.sendMedia as any).mockClear();
+
+    const cfg = {
+      channels: {
+        wecom: {
+          enabled: true,
+          bot: {
+            primaryTransport: "ws",
+            ws: {
+              botId: "bot-1",
+              secret: "secret-1",
+            },
+          },
+          agent: {
+            corpId: "corp",
+            corpSecret: "secret",
+            agentId: 1000002,
+            token: "token",
+            encodingAESKey: "aes",
+          },
+        },
+      },
+    };
+
+    await wecomOutbound.sendMedia({
+      cfg,
+      to: "user:zhangsan",
+      text: "caption",
+      mediaUrl: "https://example.com/media.png",
+    } as any);
+
+    expect(sendMedia).toHaveBeenCalledWith({
+      chatId: "zhangsan",
+      mediaUrl: "https://example.com/media.png",
+      mediaLocalRoots: undefined,
+      text: "caption",
     });
+    expect(api.sendMedia).not.toHaveBeenCalled();
+  });
+
+  it("falls back to Agent media when Bot WS media delivery returns a non-fatal failure", async () => {
+    const { wecomOutbound } = await import("./outbound.js");
+    const runtime = await import("./runtime.js");
+    const api = await import("./transport/agent-api/core.js");
+    const sendMedia = vi.fn().mockResolvedValue({ ok: false, error: "upload failed" });
+    runtime.registerBotWsPushHandle(
+      "default",
+      createBotWsHandle({
+        sendMedia,
+      }),
+    );
     (api.uploadMedia as any).mockResolvedValue("media-1");
     (api.sendMedia as any).mockResolvedValue(undefined);
     (api.sendMedia as any).mockClear();
@@ -321,8 +398,8 @@ describe("wecomOutbound", () => {
       mediaUrl: "https://example.com/media.png",
     } as any);
 
+    expect(sendMedia).toHaveBeenCalledTimes(1);
     expect(api.sendMedia).toHaveBeenCalledTimes(1);
-    expect(sendMarkdown).not.toHaveBeenCalled();
   });
 
   it("uses account-scoped agent config in matrix mode", async () => {

package/src/outbound.ts

@@ -1,7 +1,10 @@
 import type { ChannelOutboundAdapter, ChannelOutboundContext } from "openclaw/plugin-sdk";
-
-import { resolveWecomAccount, resolveWecomAccountConflict, resolveWecomAccounts } from "./config/index.js";
 import { WecomAgentDeliveryService } from "./capability/agent/index.js";
+import {
+  resolveWecomAccount,
+  resolveWecomAccountConflict,
+  resolveWecomAccounts,
+} from "./config/index.js";
 import { getAccountRuntime, getBotWsPushHandle, getWecomRuntime } from "./runtime.js";
 import { resolveScopedWecomTarget } from "./target.js";
 
@@ -49,7 +52,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 +94,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 +133,66 @@ 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 result = await handle.sendMedia({
+    chatId,
+    mediaUrl: params.mediaUrl,
+    text: params.text,
+    mediaLocalRoots: params.mediaLocalRoots,
+  });
+  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 +220,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 +238,7 @@ export const wecomOutbound: ChannelOutboundAdapter = {
 
     let sentViaBotWs = false;
     let agent: any = null;
-    
+
     try {
       sentViaBotWs = await sendTextViaBotWs({
         cfg,
@@ -185,7 +249,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 +261,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 +274,37 @@ 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(),
+      };
     }
+
     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 +333,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 +393,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",
+    });
+  }
 }