@soimy/dingtalk 3.0.2 → 3.1.1

package/README.md

@@ -439,6 +439,30 @@ openclaw gateway restart
 1. 检查 clientId 和 clientSecret 是否正确
 2. 确认网络可以访问钉钉 API
 
+### 错误 payload 日志规范（`[ErrorPayload]`）
+
+为便于快速定位 4xx/5xx 参数问题，插件会在 API 错误分支输出统一格式日志：
+
+- 通用前缀：`[DingTalk][ErrorPayload][<scope>]`
+- AI Card 前缀：`[DingTalk][AICard][ErrorPayload][<scope>]`
+- 内容格式：`code=<...> message=<...> payload=<...>`（同时保留脱敏后的完整 payload）
+
+常见 scope 示例：
+
+- `send.proactiveMessage` / `send.proactiveMedia` / `send.message`
+- `outbound.sendText` / `outbound.sendMedia`
+- `inbound.downloadMedia` / `inbound.cardFinalize`
+- `card.create` / `card.stream` / `card.stream.retryAfterRefresh`
+- `retry.beforeDecision`
+
+排查建议：
+
+```bash
+openclaw logs | grep "\[ErrorPayload\]"
+```
+
+如果你看到 `code=invalidParameter`，通常优先检查请求 payload 的必填字段（例如 `robotCode`、`userIds`、`msgKey`、`msgParam`）是否完整且格式正确。
+
 ## 开发指南
 
 ### 首次设置

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soimy/dingtalk",
-  "version": "3.0.2",
+  "version": "3.1.1",
   "description": "DingTalk (钉钉) channel plugin for OpenClaw",
   "keywords": [
     "bot",

package/src/card-service.ts

@@ -3,6 +3,7 @@ import axios from "axios";
 import { getAccessToken } from "./auth";
 import { stripTargetPrefix } from "./config";
 import { resolveOriginalPeerId } from "./peer-id-registry";
+import { formatDingTalkErrorPayloadLog } from "./utils";
 import type {
   AICardInstance,
   AICardStreamingRequest,
@@ -207,8 +208,12 @@ export async function createAICard(
   } catch (err: any) {
     log?.error?.(`[DingTalk][AICard] Create failed: ${err.message}`);
     if (err.response) {
+      const status = err.response.status;
+      const statusText = err.response.statusText;
+      const statusLabel = status ? ` status=${status}${statusText ? ` ${statusText}` : ""}` : "";
+      log?.error?.(`[DingTalk][AICard] Create error response${statusLabel}`);
       log?.error?.(
-        `[DingTalk][AICard] Error response: status=${err.response.status} data=${JSON.stringify(err.response.data)}`,
+        formatDingTalkErrorPayloadLog("card.create", err.response.data, "[DingTalk][AICard]"),
       );
     }
     return null;
@@ -322,14 +327,28 @@ export async function streamAICard(
         return;
       } catch (retryErr: any) {
         log?.error?.(`[DingTalk][AICard] Retry after token refresh failed: ${retryErr.message}`);
+        if (retryErr.response?.data !== undefined) {
+          log?.error?.(
+            formatDingTalkErrorPayloadLog(
+              "card.stream.retryAfterRefresh",
+              retryErr.response.data,
+              "[DingTalk][AICard]",
+            ),
+          );
+        }
       }
     }
 
     card.state = AICardStatus.FAILED;
     card.lastUpdated = Date.now();
     log?.error?.(
-      `[DingTalk][AICard] Streaming update failed: ${err.message}, resp=${JSON.stringify(err.response?.data)}`,
+      `[DingTalk][AICard] Streaming update failed: ${err.message}`,
     );
+    if (err.response?.data !== undefined) {
+      log?.error?.(
+        formatDingTalkErrorPayloadLog("card.stream", err.response.data, "[DingTalk][AICard]"),
+      );
+    }
     throw err;
   }
 }

package/src/channel.ts

@@ -28,7 +28,7 @@ import type {
   ResolvedAccount,
 } from "./types";
 import { ConnectionState } from "./types";
-import { cleanupOrphanedTempFiles, getCurrentTimestamp } from "./utils";
+import { cleanupOrphanedTempFiles, formatDingTalkErrorPayloadLog, getCurrentTimestamp } from "./utils";
 
 const processingDedupKeys = new Set<string>();
 const inboundCountersByAccount = new Map<
@@ -187,6 +187,9 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           typeof result.error === "string" ? result.error : JSON.stringify(result.error),
         );
       } catch (err: any) {
+        if (err?.response?.data !== undefined) {
+          log?.error?.(formatDingTalkErrorPayloadLog("outbound.sendText", err.response.data));
+        }
         throw new Error(
           typeof err?.response?.data === "string"
             ? err.response.data
@@ -261,6 +264,9 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           typeof result.error === "string" ? result.error : JSON.stringify(result.error),
         );
       } catch (err: any) {
+        if (err?.response?.data !== undefined) {
+          log?.error?.(formatDingTalkErrorPayloadLog("outbound.sendMedia", err.response.data));
+        }
         throw new Error(
           typeof err?.response?.data === "string"
             ? err.response.data

package/src/config-schema.ts

@@ -75,6 +75,14 @@ const DingTalkAccountConfigSchema = z.object({
 
   /** Jitter factor for reconnection delay randomization (0-1, default: 0.3) */
   reconnectJitter: z.number().min(0).max(1).optional().default(0.3),
+
+  proactivePermissionHint: z
+    .object({
+      enabled: z.boolean().optional().default(true),
+      cooldownHours: z.number().int().min(1).max(24 * 30).optional().default(24),
+    })
+    .optional()
+    .default({ enabled: true, cooldownHours: 24 }),
 });
 
 /**

package/src/inbound-handler.ts

@@ -16,11 +16,60 @@ import { formatGroupMembers, noteGroupMember } from "./group-members-store";
 import { setCurrentLogger } from "./logger-context";
 import { extractMessageContent } from "./message-utils";
 import { registerPeerId } from "./peer-id-registry";
+import {
+  clearProactiveRiskObservationsForTest,
+  recordProactiveRiskObservation,
+} from "./proactive-risk-registry";
 import { getDingTalkRuntime } from "./runtime";
 import { sendBySession, sendMessage } from "./send-service";
 import type { DingTalkConfig, HandleDingTalkMessageParams, MediaFile } from "./types";
 import { AICardStatus } from "./types";
-import { maskSensitiveData } from "./utils";
+import { formatDingTalkErrorPayloadLog, maskSensitiveData } from "./utils";
+
+const DEFAULT_PROACTIVE_HINT_COOLDOWN_HOURS = 24;
+const proactiveHintLastSentAt = new Map<string, number>();
+
+export function resetProactivePermissionHintStateForTest(): void {
+  proactiveHintLastSentAt.clear();
+  clearProactiveRiskObservationsForTest();
+}
+
+function shouldSendProactivePermissionHint(params: {
+  isDirect: boolean;
+  accountId: string;
+  senderId: string;
+  senderStaffId?: string;
+  config: DingTalkConfig;
+  nowMs: number;
+}): boolean {
+  if (!params.isDirect) {
+    return false;
+  }
+
+  const hintConfig = params.config.proactivePermissionHint;
+  if (hintConfig?.enabled === false) {
+    return false;
+  }
+
+  const targetId = (params.senderStaffId || params.senderId || "").trim();
+  if (!targetId || !/^\d+$/.test(targetId)) {
+    return false;
+  }
+
+  const cooldownHours =
+    hintConfig?.cooldownHours && hintConfig.cooldownHours > 0
+      ? hintConfig.cooldownHours
+      : DEFAULT_PROACTIVE_HINT_COOLDOWN_HOURS;
+  const cooldownMs = cooldownHours * 60 * 60 * 1000;
+  const key = `${params.accountId}:${targetId}`;
+  const lastSentAt = proactiveHintLastSentAt.get(key) || 0;
+  if (params.nowMs - lastSentAt < cooldownMs) {
+    return false;
+  }
+
+  proactiveHintLastSentAt.set(key, params.nowMs);
+  return true;
+}
 
 /**
  * Download DingTalk media file via runtime media service (sandbox-compatible).
@@ -97,7 +146,9 @@ export async function downloadMedia(
         log.error(
           `[DingTalk] Failed to download media:${statusLabel}${code} message=${err.message}`,
         );
-        if (dataDetail) {
+        if (err.response?.data !== undefined) {
+          log.error(formatDingTalkErrorPayloadLog("inbound.downloadMedia", err.response.data));
+        } else if (dataDetail) {
           log.error(`[DingTalk] downloadMedia response data: ${dataDetail}`);
         }
       } else {
@@ -141,10 +192,45 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   if (groupId) {
     registerPeerId(groupId);
   }
+
+  if (
+    shouldSendProactivePermissionHint({
+      isDirect,
+      accountId,
+      senderId,
+      senderStaffId: data.senderStaffId,
+      config: dingtalkConfig,
+      nowMs: Date.now(),
+    })
+  ) {
+    try {
+      await sendBySession(
+        dingtalkConfig,
+        sessionWebhook,
+        `⚠️ 主动推送可能失败\n\n检测到当前用户标识为纯数字（\`${data.senderStaffId || senderId}\`）。企业内部机器人在定时/主动发送场景中，通常需要企业内部有效用户ID与完整授权。\n\n建议：\n1) 优先使用企业内部用户ID（如 managerXXXX）\n2) 确认应用已申请并获得主动发送相关权限\n3) 确认目标用户已加入机器人所属企业`,
+        { log },
+      );
+    } catch (err: any) {
+      log?.debug?.(`[DingTalk] Failed to send proactive permission hint: ${err.message}`);
+      if (err?.response?.data !== undefined) {
+        log?.debug?.(formatDingTalkErrorPayloadLog("inbound.proactivePermissionHint", err.response.data));
+      }
+    }
+  }
   if (senderId) {
     registerPeerId(senderId);
   }
 
+  if (isDirect && /^\d+$/.test((data.senderStaffId || senderId || "").trim())) {
+    recordProactiveRiskObservation({
+      accountId,
+      targetId: data.senderStaffId || senderId,
+      level: "high",
+      reason: "numeric-user-id",
+      source: "webhook-hint",
+    });
+  }
+
   // 2) Authorization guard (DM/group policy).
   let commandAuthorized = true;
   if (isDirect) {
@@ -168,6 +254,9 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
           );
         } catch (err: any) {
           log?.debug?.(`[DingTalk] Failed to send access denied message: ${err.message}`);
+          if (err?.response?.data !== undefined) {
+            log?.debug?.(formatDingTalkErrorPayloadLog("inbound.accessDeniedReply", err.response.data));
+          }
         }
 
         return;
@@ -202,6 +291,11 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
           );
         } catch (err: any) {
           log?.debug?.(`[DingTalk] Failed to send group access denied message: ${err.message}`);
+          if (err?.response?.data !== undefined) {
+            log?.debug?.(
+              formatDingTalkErrorPayloadLog("inbound.groupAccessDeniedReply", err.response.data),
+            );
+          }
         }
 
         return;
@@ -355,6 +449,9 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       }
     } catch (err: any) {
       log?.debug?.(`[DingTalk] Thinking message failed: ${err.message}`);
+      if (err?.response?.data !== undefined) {
+        log?.debug?.(formatDingTalkErrorPayloadLog("inbound.thinkingMessage", err.response.data));
+      }
     }
   }
 
@@ -370,6 +467,11 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
             return;
           }
 
+          if (useCardMode && currentAICard && info?.kind === "final") {
+            lastCardContent = textToSend;
+            return;
+          }
+
           // Tool outputs are rendered into card stream as a separate formatted block.
           if (useCardMode && currentAICard && info?.kind === "tool") {
             if (isCardInTerminalState(currentAICard.state)) {
@@ -398,6 +500,9 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
           });
         } catch (err: any) {
           log?.error?.(`[DingTalk] Reply failed: ${err.message}`);
+          if (err?.response?.data !== undefined) {
+            log?.error?.(formatDingTalkErrorPayloadLog("inbound.replyDeliver", err.response.data));
+          }
           throw err;
         }
       },
@@ -422,6 +527,9 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
           await streamAICard(currentAICard, thinkingText, false, log);
         } catch (err: any) {
           log?.debug?.(`[DingTalk] Thinking stream update failed: ${err.message}`);
+          if (err?.response?.data !== undefined) {
+            log?.debug?.(formatDingTalkErrorPayloadLog("inbound.thinkingStream", err.response.data));
+          }
         }
       },
     },
@@ -460,6 +568,9 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       }
     } catch (err: any) {
       log?.debug?.(`[DingTalk] AI Card finalization failed: ${err.message}`);
+      if (err?.response?.data !== undefined) {
+        log?.debug?.(formatDingTalkErrorPayloadLog("inbound.cardFinalize", err.response.data));
+      }
       try {
         if (currentAICard.state !== AICardStatus.FINISHED) {
           currentAICard.state = AICardStatus.FAILED;

package/src/media-utils.ts

@@ -11,6 +11,7 @@ import * as path from "path";
 import axios from "axios";
 import FormData from "form-data";
 import type { DingTalkConfig, Logger } from "./types";
+import { formatDingTalkErrorPayloadLog } from "./utils";
 
 export type DingTalkMediaType = "image" | "voice" | "video" | "file";
 
@@ -123,7 +124,11 @@ export async function uploadMedia(
     } else {
       log?.error?.(`[DingTalk] Failed to upload media: ${err.message}`);
       if (axios.isAxiosError(err) && err.response) {
-        log?.error?.(`[DingTalk] Upload response: ${JSON.stringify(err.response.data)}`);
+        const status = err.response.status;
+        const statusText = err.response.statusText;
+        const statusLabel = status ? ` status=${status}${statusText ? ` ${statusText}` : ""}` : "";
+        log?.error?.(`[DingTalk] Upload response${statusLabel}`);
+        log?.error?.(formatDingTalkErrorPayloadLog("media.upload", err.response.data));
       }
     }
     return null;

package/src/proactive-risk-registry.ts

@@ -0,0 +1,64 @@
+type ProactiveRiskLevel = "low" | "medium" | "high";
+
+export interface ProactiveRiskObservation {
+  accountId: string;
+  targetId: string;
+  level: ProactiveRiskLevel;
+  reason: string;
+  source: string;
+  observedAtMs?: number;
+}
+
+export interface ProactiveRiskSnapshot {
+  level: ProactiveRiskLevel;
+  reason: string;
+  source: string;
+  observedAtMs: number;
+}
+
+const DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const store = new Map<string, ProactiveRiskSnapshot>();
+
+function keyOf(accountId: string, targetId: string): string {
+  return `${accountId}:${targetId.trim()}`;
+}
+
+export function recordProactiveRiskObservation(observation: ProactiveRiskObservation): void {
+  const targetId = observation.targetId?.trim();
+  if (!observation.accountId || !targetId) {
+    return;
+  }
+
+  store.set(keyOf(observation.accountId, targetId), {
+    level: observation.level,
+    reason: observation.reason,
+    source: observation.source,
+    observedAtMs: observation.observedAtMs ?? Date.now(),
+  });
+}
+
+export function getProactiveRiskObservation(
+  accountId: string,
+  targetId: string,
+  nowMs = Date.now(),
+): ProactiveRiskSnapshot | null {
+  const target = targetId?.trim();
+  if (!accountId || !target) {
+    return null;
+  }
+
+  const key = keyOf(accountId, target);
+  const entry = store.get(key);
+  if (!entry) {
+    return null;
+  }
+  if (nowMs - entry.observedAtMs > DEFAULT_TTL_MS) {
+    store.delete(key);
+    return null;
+  }
+  return entry;
+}
+
+export function clearProactiveRiskObservationsForTest(): void {
+  store.clear();
+}

package/src/send-service.ts

@@ -13,6 +13,8 @@ import { getLogger } from "./logger-context";
 import { uploadMedia as uploadMediaUtil } from "./media-utils";
 import { detectMarkdownAndExtractTitle } from "./message-utils";
 import { resolveOriginalPeerId } from "./peer-id-registry";
+import { getProactiveRiskObservation } from "./proactive-risk-registry";
+import { formatDingTalkErrorPayloadLog } from "./utils";
 import type {
   AxiosResponse,
   DingTalkConfig,
@@ -43,13 +45,19 @@ export async function sendProactiveTextOrMarkdown(
   text: string,
   options: SendMessageOptions = {},
 ): Promise<AxiosResponse> {
-  const token = await getAccessToken(config, options.log);
   const log = options.log || getLogger();
+  const token = await getAccessToken(config, log);
 
   // Support group:/user: prefix and restore original case-sensitive conversationId.
   const { targetId, isExplicitUser } = stripTargetPrefix(target);
   const resolvedTarget = resolveOriginalPeerId(targetId);
   const isGroup = !isExplicitUser && resolvedTarget.startsWith("cid");
+  const proactiveRisk = options.accountId
+    ? getProactiveRiskObservation(options.accountId, resolvedTarget)
+    : null;
+  const proactiveRiskTag = proactiveRisk
+    ? ` proactiveRisk=${proactiveRisk.level}:${proactiveRisk.reason}`
+    : "";
 
   const url = isGroup
     ? "https://api.dingtalk.com/v1.0/robot/groupMessages/send"
@@ -58,7 +66,7 @@ export async function sendProactiveTextOrMarkdown(
   const { useMarkdown, title } = detectMarkdownAndExtractTitle(text, options, "OpenClaw 提醒");
 
   log?.debug?.(
-    `[DingTalk] Sending proactive message to ${isGroup ? "group" : "user"} ${resolvedTarget} with title "${title}"`,
+    `[DingTalk] Sending proactive message to ${isGroup ? "group" : "user"} ${resolvedTarget} with title "${title}"${proactiveRiskTag}`,
   );
 
   // DingTalk proactive API uses message templates (sampleMarkdown / sampleText).
@@ -79,13 +87,40 @@ export async function sendProactiveTextOrMarkdown(
     payload.userIds = [resolvedTarget];
   }
 
-  const result = await axios({
-    url,
-    method: "POST",
-    data: payload,
-    headers: { "x-acs-dingtalk-access-token": token, "Content-Type": "application/json" },
-  });
-  return result.data;
+  try {
+    const result = await axios({
+      url,
+      method: "POST",
+      data: payload,
+      headers: { "x-acs-dingtalk-access-token": token, "Content-Type": "application/json" },
+    });
+    return result.data;
+  } catch (err: unknown) {
+    const maybeAxiosError = err as {
+      response?: { status?: number; statusText?: string; data?: unknown };
+      message?: string;
+    };
+    if (maybeAxiosError?.response) {
+      const status = maybeAxiosError.response.status;
+      const statusText = maybeAxiosError.response.statusText;
+      const statusLabel = status ? ` status=${status}${statusText ? ` ${statusText}` : ""}` : "";
+      log?.error?.(
+        `[DingTalk] Failed to send proactive message:${statusLabel} message=${
+          maybeAxiosError.message || String(err)
+        }${proactiveRiskTag}`,
+      );
+      if (maybeAxiosError.response.data !== undefined) {
+        log?.error?.(
+          formatDingTalkErrorPayloadLog("send.proactiveMessage", maybeAxiosError.response.data),
+        );
+      }
+    } else if (err instanceof Error) {
+      log?.error?.(`[DingTalk] Failed to send proactive message: ${err.message}`);
+    } else {
+      log?.error?.(`[DingTalk] Failed to send proactive message: ${String(err)}`);
+    }
+    throw err;
+  }
 }
 
 export async function sendProactiveMedia(
@@ -160,8 +195,19 @@ export async function sendProactiveMedia(
     return { ok: true, data: result.data, messageId };
   } catch (err: any) {
     log?.error?.(`[DingTalk] Failed to send proactive media: ${err.message}`);
+    const normalizedTarget = resolveOriginalPeerId(stripTargetPrefix(target).targetId);
+    const proactiveRisk = options.accountId
+      ? getProactiveRiskObservation(options.accountId, normalizedTarget)
+      : null;
+    const proactiveRiskTag = proactiveRisk
+      ? ` proactiveRisk=${proactiveRisk.level}:${proactiveRisk.reason}`
+      : "";
     if (axios.isAxiosError(err) && err.response) {
-      log?.error?.(`[DingTalk] Response: ${JSON.stringify(err.response.data)}`);
+      const status = err.response.status;
+      const statusText = err.response.statusText;
+      const statusLabel = status ? ` status=${status}${statusText ? ` ${statusText}` : ""}` : "";
+      log?.error?.(`[DingTalk] Proactive media response${statusLabel}${proactiveRiskTag}`);
+      log?.error?.(formatDingTalkErrorPayloadLog("send.proactiveMedia", err.response.data));
     }
     return { ok: false, error: err.message };
   }
@@ -276,6 +322,9 @@ export async function sendMessage(
     return { ok: true, data: result };
   } catch (err: any) {
     options.log?.error?.(`[DingTalk] Send message failed: ${err.message}`);
+    if (err?.response?.data !== undefined) {
+      options.log?.error?.(formatDingTalkErrorPayloadLog("send.message", err.response.data));
+    }
     return { ok: false, error: err.message };
   }
 }

package/src/types.ts

@@ -52,6 +52,10 @@ export interface DingTalkConfig extends OpenClawConfig {
   initialReconnectDelay?: number;
   maxReconnectDelay?: number;
   reconnectJitter?: number;
+  proactivePermissionHint?: {
+    enabled?: boolean;
+    cooldownHours?: number;
+  };
 }
 
 /**
@@ -79,6 +83,10 @@ export interface DingTalkChannelConfig {
   initialReconnectDelay?: number;
   maxReconnectDelay?: number;
   reconnectJitter?: number;
+  proactivePermissionHint?: {
+    enabled?: boolean;
+    cooldownHours?: number;
+  };
 }
 
 /**
@@ -201,6 +209,7 @@ export interface SendMessageOptions {
   filePath?: string;
   mediaUrl?: string;
   mediaType?: "image" | "voice" | "video" | "file";
+  accountId?: string;
 }
 
 /**
@@ -551,6 +560,7 @@ export function resolveDingTalkAccount(
       initialReconnectDelay: dingtalk?.initialReconnectDelay,
       maxReconnectDelay: dingtalk?.maxReconnectDelay,
       reconnectJitter: dingtalk?.reconnectJitter,
+      proactivePermissionHint: dingtalk?.proactivePermissionHint,
     };
     return {
       ...config,

package/src/utils.ts

@@ -38,6 +38,55 @@ export function maskSensitiveData(data: unknown): any {
   return masked;
 }
 
+export function formatDingTalkErrorPayload(payload: unknown): string {
+  if (payload === null || payload === undefined) {
+    return "payload=unknown";
+  }
+
+  let code: string | undefined;
+  let message: string | undefined;
+  if (typeof payload === "object" && !Array.isArray(payload)) {
+    const obj = payload as Record<string, unknown>;
+    if (typeof obj.code === "string" || typeof obj.code === "number") {
+      code = String(obj.code);
+    }
+    if (typeof obj.message === "string") {
+      message = obj.message;
+    }
+  }
+
+  let serialized: string;
+  try {
+    serialized = JSON.stringify(maskSensitiveData(payload));
+  } catch {
+    if (typeof payload === "string") {
+      serialized = payload;
+    } else if (typeof payload === "number" || typeof payload === "boolean" || typeof payload === "bigint") {
+      serialized = `${payload}`;
+    } else {
+      serialized = "[unserializable-payload]";
+    }
+  }
+
+  const parts: string[] = [];
+  if (code) {
+    parts.push(`code=${code}`);
+  }
+  if (message) {
+    parts.push(`message=${message}`);
+  }
+  parts.push(`payload=${serialized}`);
+  return parts.join(" ");
+}
+
+export function formatDingTalkErrorPayloadLog(
+  scope: string,
+  payload: unknown,
+  prefix: "[DingTalk]" | "[DingTalk][AICard]" = "[DingTalk]",
+): string {
+  return `${prefix}[ErrorPayload][${scope}] ${formatDingTalkErrorPayload(payload)}`;
+}
+
 /**
  * Cleanup orphaned temp files from dingtalk media
  * Run at startup to clean up files from crashed processes
@@ -98,6 +147,10 @@ export async function retryWithBackoff<T>(
       const isRetryable =
         statusCode === 401 || statusCode === 429 || (statusCode && statusCode >= 500);
 
+      if (err.response?.data !== undefined) {
+        log?.debug?.(formatDingTalkErrorPayloadLog("retry.beforeDecision", err.response.data));
+      }
+
       if (!isRetryable || attempt === maxRetries) {
         throw err;
       }