@tencent-weixin/openclaw-weixin 2.4.3 → 2.4.5

package/openclaw.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "openclaw-weixin",
-  "version": "2.4.3",
+  "version": "2.4.5",
   "channels": [
     "openclaw-weixin"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tencent-weixin/openclaw-weixin",
-  "version": "2.4.3",
+  "version": "2.4.5",
   "description": "OpenClaw Weixin channel",
   "license": "MIT",
   "author": "Tencent",
@@ -10,6 +10,7 @@
     "!src/**/*.test.ts",
     "!src/**/node_modules/",
     "index.ts",
+    "npm-shrinkwrap.json",
     "openclaw.plugin.json",
     "dist/",
     "README.md",
@@ -20,7 +21,8 @@
   "scripts": {
     "test": "vitest run --coverage",
     "typecheck": "tsc --noEmit",
-    "build": "tsc",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc",
     "prepublishOnly": "npm run typecheck && npm run build"
   },
   "engines": {
@@ -31,11 +33,11 @@
     "zod": "^4.3.6"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.3.22"
+    "openclaw": ">=2026.5.12"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^3.1.0",
-    "openclaw": "2026.3.23",
+    "openclaw": "2026.5.12",
     "silk-wasm": "^3.7.1",
     "typescript": "^5.8.0",
     "vitest": "^3.1.0"
@@ -59,7 +61,7 @@
     "install": {
       "npmSpec": "@tencent-weixin/openclaw-weixin",
       "defaultChoice": "npm",
-      "minHostVersion": ">=2026.3.22"
+      "minHostVersion": ">=2026.5.12"
     }
   },
   "ilink_appid": "bot"

package/src/api/api.ts

@@ -16,6 +16,7 @@ import type {
   NotifyStopResp,
   NotifyStartResp,
   SendMessageReq,
+  SendMessageResp,
   SendTypingReq,
   GetConfigResp,
 } from "./types.js";
@@ -252,6 +253,40 @@ function buildHeaders(opts: { token?: string }): Record<string, string> {
   return headers;
 }
 
+/**
+ * Classify a fetch-level error into a category for logging / diagnostics.
+ * This does NOT cover HTTP-level errors (4xx/5xx) — those are thrown separately.
+ */
+export function classifyFetchError(err: unknown): {
+  type: "dns" | "tcp" | "tls" | "timeout" | "unknown";
+  description: string;
+  code?: string;
+} {
+  if (err instanceof Error && err.name === "AbortError") {
+    return { type: "timeout", description: "request timeout" };
+  }
+
+  const cause = (err as NodeJS.ErrnoException)?.cause;
+  const causeCode = (cause as any)?.code ?? "";
+  const causeStr = String(cause ?? err ?? "") + " " + String(causeCode);
+  const matchedCode = causeCode || (typeof cause === "string" ? cause : "");
+
+  if (/ENOTFOUND|EAI_AGAIN|getaddrinfo/i.test(causeStr)) {
+    return { type: "dns", description: "DNS resolution failed, check DNS configuration", ...(matchedCode ? { code: matchedCode } : {}) };
+  }
+  if (/ECONNREFUSED/i.test(causeStr)) {
+    return { type: "tcp", description: "TCP connection refused", ...(matchedCode ? { code: matchedCode } : {}) };
+  }
+  if (/UND_ERR_CONNECT_TIMEOUT|ETIMEDOUT|ENETUNREACH|EHOSTUNREACH/i.test(causeStr)) {
+    return { type: "tcp", description: "TCP connection timeout or unreachable", ...(matchedCode ? { code: matchedCode } : {}) };
+  }
+  if (/UND_ERR_SOCKET|SSL|TLS|CERT|UNABLE_TO_VERIFY|DEPTH_ZERO/i.test(causeStr)) {
+    return { type: "tls", description: "TLS handshake error", ...(matchedCode ? { code: matchedCode } : {}) };
+  }
+
+  return { type: "unknown", description: "network request failed" };
+}
+
 /**
  * GET fetch wrapper: send a GET request to a Weixin API endpoint.
  * When `timeoutMs` is set, the request is aborted after that many milliseconds.
@@ -291,15 +326,50 @@ export async function apiGetFetch(params: {
     return rawText;
   } catch (err) {
     if (t !== undefined) clearTimeout(t);
+    const classified = classifyFetchError(err);
+    logger.error(
+      `${params.label}: GET fetch failed url=${redactUrl(url.toString())} timeoutMs=${timeoutMs ?? "none"} type=${classified.type} description=${classified.description}${classified.code ? ` code=${classified.code}` : ""} error=${String(err)}`,
+    );
     throw err;
   }
 }
 
+/**
+ * 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 +378,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 +391,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();
@@ -336,7 +411,13 @@ export async function apiPostFetch(params: {
     return rawText;
   } catch (err) {
     if (t !== undefined) clearTimeout(t);
+    const classified = classifyFetchError(err);
+    logger.error(
+      `${params.label}: POST fetch failed url=${redactUrl(url.toString())} timeoutMs=${params.timeoutMs ?? "none"} type=${classified.type} description=${classified.description}${classified.code ? ` code=${classified.code}` : ""} error=${String(err)}`,
+    );
     throw err;
+  } finally {
+    cleanup();
   }
 }
 
@@ -351,6 +432,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 +451,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;
@@ -411,7 +503,7 @@ export async function getUploadUrl(
 export async function sendMessage(
   params: WeixinApiOptions & { body: SendMessageReq },
 ): Promise<void> {
-  await apiPostFetch({
+  const rawText = await apiPostFetch({
     baseUrl: params.baseUrl,
     endpoint: "ilink/bot/sendmessage",
     body: JSON.stringify({ ...params.body, base_info: buildBaseInfo() }),
@@ -419,6 +511,12 @@ export async function sendMessage(
     timeoutMs: params.timeoutMs ?? DEFAULT_API_TIMEOUT_MS,
     label: "sendMessage",
   });
+  const resp: SendMessageResp = JSON.parse(rawText);
+  if (resp.ret && resp.ret !== 0) {
+    throw new Error(
+      `sendMessage ret=${resp.ret} errmsg=${resp.errmsg ?? "(none)"}`,
+    );
+  }
 }
 
 /** Fetch bot config (includes typing_ticket) for a given user. */

package/src/api/session-guard.ts

@@ -2,8 +2,8 @@ import { logger } from "../util/logger.js";
 
 const SESSION_PAUSE_DURATION_MS = 60 * 60 * 1000;
 
-/** Error code returned by the server when the bot session has expired. */
-export const SESSION_EXPIRED_ERRCODE = -14;
+/** Error code returned by the server when the bot token is stale / expired. */
+export const STALE_TOKEN_ERRCODE = -14;
 
 const pauseUntilMap = new Map<string, number>();
 
@@ -44,7 +44,7 @@ export function assertSessionActive(accountId: string): void {
   if (isSessionPaused(accountId)) {
     const remainingMin = Math.ceil(getRemainingPauseMs(accountId) / 60_000);
     throw new Error(
-      `session paused for accountId=${accountId}, ${remainingMin} min remaining (errcode ${SESSION_EXPIRED_ERRCODE})`,
+      `session paused for accountId=${accountId}, ${remainingMin} min remaining (errcode ${STALE_TOKEN_ERRCODE})`,
     );
   }
 }

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. */
@@ -208,7 +224,8 @@ export interface SendMessageReq {
 }
 
 export interface SendMessageResp {
-  // empty
+  ret?: number;
+  errmsg?: string;
 }
 
 /** Typing status: 1 = typing (default), 2 = cancel typing. */

package/src/cdn/cdn-upload.ts

@@ -70,10 +70,16 @@ export async function uploadBufferToCdn(params: {
     } catch (err) {
       lastError = err;
       if (err instanceof Error && err.message.includes("client error")) throw err;
+      const cause =
+        (err as NodeJS.ErrnoException).cause ?? (err as NodeJS.ErrnoException).code ?? "";
       if (attempt < UPLOAD_MAX_RETRIES) {
-        logger.error(`${label}: attempt ${attempt} failed, retrying... err=${String(err)}`);
+        logger.error(
+          `${label}: attempt ${attempt} failed, retrying... url=${redactUrl(cdnUrl)} error=${String(err)}${cause ? ` cause=${cause}` : ""}`,
+        );
       } else {
-        logger.error(`${label}: all ${UPLOAD_MAX_RETRIES} attempts failed err=${String(err)}`);
+        logger.error(
+          `${label}: all ${UPLOAD_MAX_RETRIES} attempts failed url=${redactUrl(cdnUrl)} error=${String(err)}${cause ? ` cause=${cause}` : ""}`,
+        );
       }
     }
   }

package/src/cdn/upload.ts

@@ -7,6 +7,7 @@ import type { WeixinApiOptions } from "../api/api.js";
 import { aesEcbPaddedSize } from "./aes-ecb.js";
 import { uploadBufferToCdn } from "./cdn-upload.js";
 import { logger } from "../util/logger.js";
+import { redactUrl } from "../util/redact.js";
 import { getExtensionFromContentTypeOrUrl } from "../media/mime.js";
 import { tempFileName } from "../util/random.js";
 import { UploadMediaType } from "../api/types.js";
@@ -28,10 +29,20 @@ export type UploadedFileInfo = {
  * Returns the local file path; extension is inferred from Content-Type / URL.
  */
 export async function downloadRemoteImageToTemp(url: string, destDir: string): Promise<string> {
-  logger.debug(`downloadRemoteImageToTemp: fetching url=${url}`);
-  const res = await fetch(url);
+  logger.debug(`downloadRemoteImageToTemp: fetching url=${redactUrl(url)}`);
+  let res: Response;
+  try {
+    res = await fetch(url);
+  } catch (err) {
+    const cause =
+      (err as NodeJS.ErrnoException).cause ?? (err as NodeJS.ErrnoException).code ?? "";
+    logger.error(
+      `downloadRemoteImageToTemp: fetch network error url=${redactUrl(url)} error=${String(err)}${cause ? ` cause=${cause}` : ""}`,
+    );
+    throw err;
+  }
   if (!res.ok) {
-    const msg = `remote media download failed: ${res.status} ${res.statusText} url=${url}`;
+    const msg = `remote media download failed: ${res.status} ${res.statusText} url=${redactUrl(url)}`;
     logger.error(`downloadRemoteImageToTemp: ${msg}`);
     throw new Error(msg);
   }

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) {