@tencent-weixin/openclaw-weixin 2.4.3 → 2.4.4

package/src/api/api.ts

@@ -295,11 +295,42 @@ export async function apiGetFetch(params: {
   }
 }
 
+/**
+ * Combine an internal timeout controller with an optional external abort signal.
+ * This lets gateway channel-stop aborts cancel in-flight long-poll requests
+ * immediately while preserving the existing timeout-driven AbortError path.
+ */
+function combineAbortSignals(params: {
+  internal?: AbortController;
+  external?: AbortSignal;
+}): { signal?: AbortSignal; cleanup: () => void } {
+  const { internal, external } = params;
+  if (!external) {
+    return { signal: internal?.signal, cleanup: () => {} };
+  }
+  if (!internal) {
+    return { signal: external, cleanup: () => {} };
+  }
+  if (external.aborted) {
+    internal.abort();
+    return { signal: internal.signal, cleanup: () => {} };
+  }
+  const onExternalAbort = () => internal.abort();
+  external.addEventListener("abort", onExternalAbort, { once: true });
+  return {
+    signal: internal.signal,
+    cleanup: () => external.removeEventListener("abort", onExternalAbort),
+  };
+}
+
 /**
  * Common fetch wrapper: POST JSON to a Weixin API endpoint.
  * When `timeoutMs` is provided, the request is aborted after that many milliseconds.
  * When omitted, no client-side timeout is applied (relies on OS/TCP stack).
  * Returns the raw response text on success; throws on HTTP error or timeout.
+ *
+ * When `abortSignal` is provided, an external abort (e.g. gateway channel stop)
+ * cancels the in-flight request immediately instead of waiting for `timeoutMs`.
  */
 export async function apiPostFetch(params: {
   baseUrl: string;
@@ -308,6 +339,7 @@ export async function apiPostFetch(params: {
   token?: string;
   timeoutMs?: number;
   label: string;
+  abortSignal?: AbortSignal;
 }): Promise<string> {
   const base = ensureTrailingSlash(params.baseUrl);
   const url = new URL(params.endpoint, base);
@@ -320,12 +352,16 @@ export async function apiPostFetch(params: {
     controller != null && params.timeoutMs !== undefined
       ? setTimeout(() => controller.abort(), params.timeoutMs)
       : undefined;
+  const { signal, cleanup } = combineAbortSignals({
+    internal: controller,
+    external: params.abortSignal,
+  });
   try {
     const res = await fetch(url.toString(), {
       method: "POST",
       headers: hdrs,
       body: params.body,
-      ...(controller ? { signal: controller.signal } : {}),
+      ...(signal ? { signal } : {}),
     });
     if (t !== undefined) clearTimeout(t);
     const rawText = await res.text();
@@ -337,6 +373,8 @@ export async function apiPostFetch(params: {
   } catch (err) {
     if (t !== undefined) clearTimeout(t);
     throw err;
+  } finally {
+    cleanup();
   }
 }
 
@@ -351,6 +389,11 @@ export async function getUpdates(
     baseUrl: string;
     token?: string;
     timeoutMs?: number;
+    /**
+     * Optional external abort signal from the gateway. When stopping the channel,
+     * this aborts the in-flight long-poll immediately so hot reload can restart.
+     */
+    abortSignal?: AbortSignal;
   },
 ): Promise<GetUpdatesResp> {
   const timeout = params.timeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS;
@@ -365,13 +408,19 @@ export async function getUpdates(
       token: params.token,
       timeoutMs: timeout,
       label: "getUpdates",
+      abortSignal: params.abortSignal,
     });
     const resp: GetUpdatesResp = JSON.parse(rawText);
     return resp;
   } catch (err) {
-    // Long-poll timeout is normal; return empty response so caller can retry
+    // Long-poll timeout or external abort are both normal control-flow exits.
+    // The monitor loop checks abortSignal after return and exits when needed.
     if (err instanceof Error && err.name === "AbortError") {
-      logger.debug(`getUpdates: client-side timeout after ${timeout}ms, returning empty response`);
+      if (params.abortSignal?.aborted) {
+        logger.debug(`getUpdates: aborted by external signal`);
+      } else {
+        logger.debug(`getUpdates: client-side timeout after ${timeout}ms, returning empty response`);
+      }
       return { ret: 0, msgs: [], get_updates_buf: params.get_updates_buf };
     }
     throw err;

package/src/api/types.ts

@@ -74,6 +74,8 @@ export const MessageItemType = {
   VOICE: 3,
   FILE: 4,
   VIDEO: 5,
+  TOOL_CALL_START: 11,
+  TOOL_CALL_RESULT: 12,
 } as const;
 
 export const MessageState = {
@@ -147,6 +149,17 @@ export interface RefMessage {
   title?: string; // 摘要
 }
 
+export interface ToolCallStartItem {
+  tool_name?: string;
+  tool_call_id?: string;
+}
+
+export interface ToolCallResultItem {
+  tool_name?: string;
+  tool_call_id?: string;
+  status?: string;
+}
+
 export interface MessageItem {
   type?: number;
   create_time_ms?: number;
@@ -159,6 +172,8 @@ export interface MessageItem {
   voice_item?: VoiceItem;
   file_item?: FileItem;
   video_item?: VideoItem;
+  tool_call_start_item?: ToolCallStartItem;
+  tool_call_result_item?: ToolCallResultItem;
 }
 
 /** Unified message (proto: WeixinMessage). Replaces the old split Message + MessageContent + FullMessage. */
@@ -177,6 +192,7 @@ export interface WeixinMessage {
   message_state?: number;
   item_list?: MessageItem[];
   context_token?: string;
+  run_id?: string;
 }
 
 /** GetUpdates request: bytes fields are base64 strings in JSON. */

package/src/channel.ts

@@ -167,7 +167,13 @@ export const weixinPlugin: ChannelPlugin<ResolvedWeixinAccount> = {
     schema: {
       type: "object",
       additionalProperties: false,
-      properties: {},
+      properties: {
+        replyProgressMessages: {
+          type: "boolean",
+          default: true,
+          description: "Send structured tool-call progress messages.",
+        },
+      },
     },
   },
   capabilities: {

package/src/config/config-schema.ts

@@ -17,6 +17,7 @@ const weixinAccountSchema = z.object({
 /** Top-level weixin config schema (token is stored in credentials file, not config). */
 export const WeixinConfigSchema = weixinAccountSchema.extend({
   accounts: z.record(z.string(), weixinAccountSchema).optional(),
+  replyProgressMessages: z.boolean().default(true),
   /** ISO 8601; bumped on each successful login to refresh gateway config from disk. */
   channelConfigUpdatedAt: z.string().optional(),
 });

package/src/config/reply-progress.ts

@@ -0,0 +1,10 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+
+type WeixinChannelConfig = {
+  replyProgressMessages?: boolean;
+};
+
+export function resolveReplyProgressMessagesEnabled(cfg: OpenClawConfig): boolean {
+  const section = cfg.channels?.["openclaw-weixin"] as WeixinChannelConfig | undefined;
+  return section?.replyProgressMessages !== false;
+}

package/src/messaging/error-notice.ts

@@ -12,6 +12,7 @@ export async function sendWeixinErrorNotice(params: {
   message: string;
   baseUrl: string;
   token?: string;
+  runId?: string;
   errLog: (m: string) => void;
 }): Promise<void> {
   if (!params.contextToken) {
@@ -22,6 +23,7 @@ export async function sendWeixinErrorNotice(params: {
       baseUrl: params.baseUrl,
       token: params.token,
       contextToken: params.contextToken,
+      ...(params.runId ? { runId: params.runId } : {}),
     }});
     logger.debug(`sendWeixinErrorNotice: sent to=${params.to}`);
   } catch (err) {

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}`,