@tencent-weixin/openclaw-weixin 2.4.2 → 2.4.4

package/src/messaging/outbound-hooks.ts

@@ -20,6 +20,7 @@ export async function applyWeixinMessageSendingHook(params: {
   text: string;
   accountId?: string;
   mediaUrl?: string;
+  runId?: string;
 }): Promise<{ cancelled: boolean; text: string }> {
   const hookRunner = getGlobalHookRunner();
   if (!hookRunner?.hasHooks("message_sending")) {
@@ -33,6 +34,7 @@ export async function applyWeixinMessageSendingHook(params: {
         metadata: {
           channel: CHANNEL_ID,
           accountId: params.accountId,
+          runId: params.runId,
           ...(params.mediaUrl ? { mediaUrls: [params.mediaUrl] } : {}),
         },
       },
@@ -60,6 +62,7 @@ export function emitWeixinMessageSent(params: {
   success: boolean;
   error?: string;
   accountId?: string;
+  runId?: string;
 }): void {
   const hookRunner = getGlobalHookRunner();
   if (!hookRunner?.hasHooks("message_sent")) return;
@@ -71,6 +74,7 @@ export function emitWeixinMessageSent(params: {
     channelId: CHANNEL_ID,
     accountId: params.accountId,
     conversationId: params.to,
+    runId: params.runId,
   });
   fireAndForgetHook(
     Promise.resolve(

package/src/messaging/process-message.ts

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { randomUUID } from "node:crypto";
 
 import { createTypingCallbacks } from "openclaw/plugin-sdk/channel-runtime";
 import {
@@ -14,6 +15,7 @@ import { MessageItemType, TypingStatus } from "../api/types.js";
 import { loadWeixinAccount } from "../auth/accounts.js";
 import { readFrameworkAllowFromList } from "../auth/pairing.js";
 import { downloadRemoteImageToTemp } from "../cdn/upload.js";
+import { resolveReplyProgressMessagesEnabled } from "../config/reply-progress.js";
 import { downloadMediaFromItem } from "../media/media-download.js";
 import { logger } from "../util/logger.js";
 import { redactBody, redactToken } from "../util/redact.js";
@@ -31,6 +33,7 @@ import type { WeixinInboundMediaOpts } from "./inbound.js";
 import { sendWeixinMediaFile } from "./send-media.js";
 import { StreamingMarkdownFilter } from "./markdown-filter.js";
 import { sendMessageWeixin } from "./send.js";
+import { WeixinReplyProgressSender } from "./reply-progress-sender.js";
 import { handleSlashCommand } from "./slash-commands.js";
 
 const MEDIA_OUTBOUND_TEMP_DIR = path.join(resolvePreferredOpenClawTmpDir(), "weixin/media/outbound-temp");
@@ -270,6 +273,19 @@ export async function processOneMessage(
   if (contextToken) {
     setContextToken(deps.accountId, full.from_user_id ?? "", contextToken);
   }
+  const runId = randomUUID();
+  const replyProgressSender = resolveReplyProgressMessagesEnabled(deps.config)
+    ? new WeixinReplyProgressSender({
+        runId,
+        to: ctx.To,
+        accountId: deps.accountId,
+        opts: {
+          baseUrl: deps.baseUrl,
+          token: deps.token,
+          contextToken,
+        },
+      })
+    : undefined;
   const humanDelay = deps.channelRuntime.reply.resolveHumanDelayConfig(deps.config, route.agentId);
 
   const hasTypingTicket = Boolean(deps.typingTicket);
@@ -336,6 +352,7 @@ export async function processOneMessage(
           text,
           accountId: deps.accountId,
           mediaUrl,
+          runId,
         });
         if (sendingResult.cancelled) {
           logger.info(`outbound: cancelled by message_sending hook to=${ctx.To}`);
@@ -368,8 +385,9 @@ export async function processOneMessage(
                 baseUrl: deps.baseUrl,
                 token: deps.token,
                 contextToken,
+                runId,
               }});
-              emitWeixinMessageSent({ to: ctx.To, content: text, success: true, accountId: deps.accountId });
+              emitWeixinMessageSent({ to: ctx.To, content: text, success: true, accountId: deps.accountId, runId });
               logger.info(`outbound: text sent to=${ctx.To}`);
               return;
             }
@@ -377,10 +395,10 @@ export async function processOneMessage(
               filePath,
               to: ctx.To,
               text,
-              opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken },
+              opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken, runId },
               cdnBaseUrl: deps.cdnBaseUrl,
             });
-            emitWeixinMessageSent({ to: ctx.To, content: text, success: true, accountId: deps.accountId });
+            emitWeixinMessageSent({ to: ctx.To, content: text, success: true, accountId: deps.accountId, runId });
             logger.info(`outbound: media sent OK to=${ctx.To}`);
           } else {
             logger.debug(`outbound: sending text message to=${ctx.To}`);
@@ -388,12 +406,13 @@ export async function processOneMessage(
               baseUrl: deps.baseUrl,
               token: deps.token,
               contextToken,
+              runId,
             }});
-            emitWeixinMessageSent({ to: ctx.To, content: text, success: true, accountId: deps.accountId });
+            emitWeixinMessageSent({ to: ctx.To, content: text, success: true, accountId: deps.accountId, runId });
             logger.info(`outbound: text sent OK to=${ctx.To}`);
           }
         } catch (err) {
-          emitWeixinMessageSent({ to: ctx.To, content: text, success: false, error: String(err), accountId: deps.accountId });
+          emitWeixinMessageSent({ to: ctx.To, content: text, success: false, error: String(err), accountId: deps.accountId, runId });
           logger.error(
             `outbound: FAILED to=${ctx.To} mediaUrl=${mediaUrl ?? "none"} err=${String(err)} stack=${(err as Error).stack ?? ""}`,
           );
@@ -421,6 +440,7 @@ export async function processOneMessage(
           message: notice,
           baseUrl: deps.baseUrl,
           token: deps.token,
+          runId,
           errLog: deps.errLog,
         });
       },
@@ -435,7 +455,11 @@ export async function processOneMessage(
           ctx: finalized,
           cfg: deps.config,
           dispatcher,
-          replyOptions: { ...replyOptions, disableBlockStreaming: true },
+          replyOptions: {
+            ...replyOptions,
+            ...(replyProgressSender?.replyOptions ?? {}),
+            disableBlockStreaming: true,
+          },
         }),
     });
     logger.debug(`dispatchReplyFromConfig: done agentId=${route.agentId ?? "(none)"}`);
@@ -446,6 +470,7 @@ export async function processOneMessage(
     throw err;
   } finally {
     markDispatchIdle();
+    await replyProgressSender?.finalize();
 
     logger.info(
       `debug-check: accountId=${deps.accountId} debug=${String(debug)} hasContextToken=${Boolean(contextToken)}`,
@@ -489,7 +514,7 @@ export async function processOneMessage(
         await sendMessageWeixin({
           to: ctx.To,
           text: timingText,
-          opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken },
+          opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken, runId },
         });
         logger.info(`debug-timing: sent OK`);
       } catch (debugErr) {

package/src/messaging/reply-progress-sender.ts

@@ -0,0 +1,122 @@
+import type { WeixinApiOptions } from "../api/api.js";
+import type { MessageItem } from "../api/types.js";
+import { MessageItemType } from "../api/types.js";
+import { logger } from "../util/logger.js";
+
+import { sendMessageItemWeixin } from "./send.js";
+
+export type WeixinReplyProgressSenderDeps = {
+  runId: string;
+  to: string;
+  accountId: string;
+  opts: WeixinApiOptions & {
+    contextToken?: string;
+    runId?: string;
+  };
+};
+
+type ToolItemEventPayload = {
+  itemId?: string;
+  kind?: string;
+  title?: string;
+  name?: string;
+  phase?: string;
+  status?: string;
+};
+
+function normalizeToolStatus(status?: string): string {
+  if (status === "completed") return "completed";
+  if (status === "failed") return "failed";
+  if (status === "blocked") return "blocked";
+  return "unknown";
+}
+
+export class WeixinReplyProgressSender {
+  readonly runId: string;
+
+  private readonly to: string;
+  private readonly accountId: string;
+  private readonly opts: WeixinReplyProgressSenderDeps["opts"];
+  private finalized = false;
+  private sendChain: Promise<void> = Promise.resolve();
+
+  constructor(deps: WeixinReplyProgressSenderDeps) {
+    this.runId = deps.runId;
+    this.to = deps.to;
+    this.accountId = deps.accountId;
+    this.opts = { ...deps.opts, runId: deps.runId };
+  }
+
+  get replyOptions() {
+    return {
+      runId: this.runId,
+      onItemEvent: (payload: ToolItemEventPayload) => this.handleToolItemEvent(payload),
+    };
+  }
+
+  private enqueueMessage(item: MessageItem, label: string): void {
+    if (this.finalized) return;
+    this.sendChain = this.sendChain
+      .then(async () => {
+        await sendMessageItemWeixin({
+          to: this.to,
+          item,
+          opts: this.opts,
+          label,
+        });
+      })
+      .catch((err) => {
+        logger.warn(`${label}: failed to=${this.to} accountId=${this.accountId} runId=${this.runId} err=${String(err)}`);
+      });
+  }
+
+  private handleToolItemEvent(payload: ToolItemEventPayload): void {
+    if (this.finalized) return;
+    if (payload.kind !== "tool") return;
+    if (payload.phase !== "start" && payload.phase !== "end") return;
+
+    const now = Date.now();
+    const toolName = payload.name?.trim() || payload.title?.trim() || "tool";
+    const toolCallId = payload.itemId?.trim() || undefined;
+
+    if (payload.phase === "start") {
+      this.enqueueMessage(
+        {
+          type: MessageItemType.TOOL_CALL_START,
+          create_time_ms: now,
+          is_completed: false,
+          tool_call_start_item: {
+            tool_name: toolName,
+            tool_call_id: toolCallId,
+          },
+        },
+        "sendToolCallStartMessage",
+      );
+      return;
+    }
+
+    this.enqueueMessage(
+      {
+        type: MessageItemType.TOOL_CALL_RESULT,
+        create_time_ms: now,
+        is_completed: true,
+        tool_call_result_item: {
+          tool_name: toolName,
+          tool_call_id: toolCallId,
+          status: normalizeToolStatus(payload.status),
+        },
+      },
+      "sendToolCallResultMessage",
+    );
+  }
+
+  async finalize(): Promise<void> {
+    if (this.finalized) return;
+    this.finalized = true;
+    try {
+      await this.sendChain;
+    } catch (err) {
+      logger.warn(`WeixinReplyProgressSender.finalize: send drain failed runId=${this.runId} err=${String(err)}`);
+    }
+  }
+}

package/src/messaging/send-media.ts

@@ -18,7 +18,7 @@ export async function sendWeixinMediaFile(params: {
   filePath: string;
   to: string;
   text: string;
-  opts: WeixinApiOptions & { contextToken?: string };
+  opts: WeixinApiOptions & { contextToken?: string; runId?: string };
   cdnBaseUrl: string;
 }): Promise<{ messageId: string }> {
   const { filePath, to, text, opts, cdnBaseUrl } = params;

package/src/messaging/send.ts

@@ -10,6 +10,11 @@ import type { UploadedFileInfo } from "../cdn/upload.js";
 
 export { StreamingMarkdownFilter } from "./markdown-filter.js";
 
+type WeixinMessageSendOptions = WeixinApiOptions & {
+  contextToken?: string;
+  runId?: string;
+};
+
 function generateClientId(): string {
   return generateId("openclaw-weixin");
 }
@@ -19,9 +24,10 @@ function buildTextMessageReq(params: {
   to: string;
   text: string;
   contextToken?: string;
+  runId?: string;
   clientId: string;
 }): SendMessageReq {
-  const { to, text, contextToken, clientId } = params;
+  const { to, text, contextToken, runId, clientId } = params;
   const item_list: MessageItem[] = text
     ? [{ type: MessageItemType.TEXT, text_item: { text } }]
     : [];
@@ -34,6 +40,7 @@ function buildTextMessageReq(params: {
       message_state: MessageState.FINISH,
       item_list: item_list.length ? item_list : undefined,
       context_token: contextToken ?? undefined,
+      run_id: runId ?? undefined,
     },
   };
 }
@@ -42,14 +49,16 @@ function buildTextMessageReq(params: {
 function buildSendMessageReq(params: {
   to: string;
   contextToken?: string;
+  runId?: string;
   payload: ReplyPayload;
   clientId: string;
 }): SendMessageReq {
-  const { to, contextToken, payload, clientId } = params;
+  const { to, contextToken, runId, payload, clientId } = params;
   return buildTextMessageReq({
     to,
     text: payload.text ?? "",
     contextToken,
+    runId,
     clientId,
   });
 }
@@ -60,7 +69,7 @@ function buildSendMessageReq(params: {
 export async function sendMessageWeixin(params: {
   to: string;
   text: string;
-  opts: WeixinApiOptions & { contextToken?: string };
+  opts: WeixinMessageSendOptions;
 }): Promise<{ messageId: string }> {
   const { to, text, opts } = params;
   if (!opts.contextToken) {
@@ -70,6 +79,7 @@ export async function sendMessageWeixin(params: {
   const req = buildSendMessageReq({
     to,
     contextToken: opts.contextToken,
+    runId: opts.runId,
     payload: { text },
     clientId,
   });
@@ -87,6 +97,47 @@ export async function sendMessageWeixin(params: {
   return { messageId: clientId };
 }
 
+/** Send a single structured MessageItem downstream. */
+export async function sendMessageItemWeixin(params: {
+  to: string;
+  item: MessageItem;
+  opts: WeixinMessageSendOptions;
+  clientId?: string;
+  label?: string;
+}): Promise<{ messageId: string }> {
+  const { to, item, opts } = params;
+  if (!opts.contextToken) {
+    logger.warn(`sendMessageItemWeixin: contextToken missing for to=${to}, sending without context`);
+  }
+  const clientId = params.clientId ?? generateClientId();
+  const req: SendMessageReq = {
+    msg: {
+      from_user_id: "",
+      to_user_id: to,
+      client_id: clientId,
+      message_type: MessageType.BOT,
+      message_state: MessageState.FINISH,
+      item_list: [item],
+      context_token: opts.contextToken ?? undefined,
+      run_id: opts.runId,
+    },
+  };
+  try {
+    await sendMessageApi({
+      baseUrl: opts.baseUrl,
+      token: opts.token,
+      timeoutMs: opts.timeoutMs,
+      body: req,
+    });
+  } catch (err) {
+    logger.error(
+      `${params.label ?? "sendMessageItemWeixin"}: failed to=${to} clientId=${clientId} err=${String(err)}`,
+    );
+    throw err;
+  }
+  return { messageId: clientId };
+}
+
 /**
  * Send one or more MessageItems (optionally preceded by a text caption) downstream.
  * Each item is sent as its own request so that item_list always has exactly one entry.
@@ -95,10 +146,11 @@ async function sendMediaItems(params: {
   to: string;
   text: string;
   mediaItem: MessageItem;
-  opts: WeixinApiOptions & { contextToken?: string };
+  opts: WeixinMessageSendOptions;
   label: string;
 }): Promise<{ messageId: string }> {
   const { to, text, mediaItem, opts, label } = params;
+  const runId = opts.runId;
 
   const items: MessageItem[] = [];
   if (text) {
@@ -118,6 +170,7 @@ async function sendMediaItems(params: {
         message_state: MessageState.FINISH,
         item_list: [item],
         context_token: opts.contextToken ?? undefined,
+        run_id: runId,
       },
     };
     try {
@@ -152,7 +205,7 @@ export async function sendImageMessageWeixin(params: {
   to: string;
   text: string;
   uploaded: UploadedFileInfo;
-  opts: WeixinApiOptions & { contextToken?: string };
+  opts: WeixinMessageSendOptions;
 }): Promise<{ messageId: string }> {
   const { to, text, uploaded, opts } = params;
   if (!opts.contextToken) {
@@ -186,7 +239,7 @@ export async function sendVideoMessageWeixin(params: {
   to: string;
   text: string;
   uploaded: UploadedFileInfo;
-  opts: WeixinApiOptions & { contextToken?: string };
+  opts: WeixinMessageSendOptions;
 }): Promise<{ messageId: string }> {
   const { to, text, uploaded, opts } = params;
   if (!opts.contextToken) {
@@ -218,7 +271,7 @@ export async function sendFileMessageWeixin(params: {
   text: string;
   fileName: string;
   uploaded: UploadedFileInfo;
-  opts: WeixinApiOptions & { contextToken?: string };
+  opts: WeixinMessageSendOptions;
 }): Promise<{ messageId: string }> {
   const { to, text, fileName, uploaded, opts } = params;
   if (!opts.contextToken) {

package/src/monitor/monitor.ts

@@ -96,6 +96,9 @@ export async function monitorWeixinProvider(opts: MonitorWeixinOpts): Promise<vo
         token,
         get_updates_buf: getUpdatesBuf,
         timeoutMs: nextTimeoutMs,
+        // Stop/hot-reload should cancel the in-flight long-poll immediately
+        // instead of waiting for the server-side long-poll timeout.
+        abortSignal,
       });
       aLog.debug(
         `getUpdates response: ret=${resp.ret}, msgs=${resp.msgs?.length ?? 0}, get_updates_buf_length=${resp.get_updates_buf?.length ?? 0}`,