@soimy/dingtalk 3.1.1 → 3.1.2

package/package.json

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

package/src/channel.ts

@@ -381,6 +381,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         initialDelay: config.initialReconnectDelay ?? 1000,
         maxDelay: config.maxReconnectDelay ?? 60000,
         jitter: config.reconnectJitter ?? 0.3,
+        maxReconnectCycles: config.maxReconnectCycles,
         onStateChange: (state: ConnectionState, error?: string) => {
           if (stopped) {
             return;

package/src/config-schema.ts

@@ -76,6 +76,9 @@ 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),
 
+  /** Maximum number of runtime reconnect cycles before giving up (default: 10) */
+  maxReconnectCycles: z.number().int().min(1).optional().default(10),
+
   proactivePermissionHint: z
     .object({
       enabled: z.boolean().optional().default(true),

package/src/connection-manager.ts

@@ -37,6 +37,8 @@ export class ConnectionManager {
   private static readonly HEALTH_CHECK_INTERVAL_MS = 5000;
   private static readonly HEALTH_CHECK_GRACE_MS = 3000;
   private static readonly HEALTH_CHECK_UNHEALTHY_THRESHOLD = 2;
+  private static readonly DEFAULT_MAX_RECONNECT_CYCLES = 10;
+  private runtimeReconnectCycles: number = 0;
   private runtimeCounters = {
     healthUnhealthyChecks: 0,
     healthTriggeredReconnects: 0,
@@ -160,6 +162,9 @@ export class ConnectionManager {
 
       this.log?.info?.(`[${this.accountId}] DingTalk Stream client connected successfully`);
 
+      // Reset runtime reconnect cycle counter on successful connection
+      this.runtimeReconnectCycles = 0;
+
       return { success: true, attempt: successfulAttempt };
     } catch (err: any) {
       this.log?.error?.(
@@ -427,17 +432,34 @@ export class ConnectionManager {
       this.log?.error?.(`[${this.accountId}] Reconnection failed: ${err.message}`);
       this.runtimeCounters.reconnectFailures += 1;
       this.logRuntimeCounters("reconnect-failed");
+
+      // Track runtime reconnect cycles to prevent infinite loops
+      this.runtimeReconnectCycles += 1;
+      const maxCycles = this.config.maxReconnectCycles ?? ConnectionManager.DEFAULT_MAX_RECONNECT_CYCLES;
+
+      if (this.runtimeReconnectCycles >= maxCycles) {
+        this.log?.error?.(
+          `[${this.accountId}] Max runtime reconnect cycles (${maxCycles}) reached. Giving up. ` +
+          `Please check network connectivity or restart the gateway.`,
+        );
+        this.state = ConnectionStateEnum.FAILED;
+        this.connectedAt = undefined;
+        this.consecutiveUnhealthyChecks = 0;
+        this.notifyStateChange(`Max runtime reconnect cycles (${maxCycles}) reached`);
+        return;
+      }
+
       this.state = ConnectionStateEnum.FAILED;
       this.connectedAt = undefined;
       this.consecutiveUnhealthyChecks = 0;
       this.notifyStateChange(err.message);
 
-      // Continue runtime recovery instead of getting stuck in FAILED.
-      const delay = this.calculateNextDelay(0);
+      // Continue runtime recovery with exponential backoff based on cycle count
+      const delay = this.calculateNextDelay(Math.min(this.runtimeReconnectCycles - 1, 6)); // Cap at ~64x initial delay
       this.attemptCount = 0;
       this.clearReconnectTimer();
       this.log?.warn?.(
-        `[${this.accountId}] Reconnection cycle failed; scheduling next reconnect in ${(delay / 1000).toFixed(2)}s`,
+        `[${this.accountId}] Reconnection cycle ${this.runtimeReconnectCycles}/${maxCycles} failed; scheduling next reconnect in ${(delay / 1000).toFixed(2)}s`,
       );
       this.reconnectTimer = setTimeout(() => {
         void this.reconnect();

package/src/inbound-handler.ts

@@ -18,7 +18,7 @@ import { extractMessageContent } from "./message-utils";
 import { registerPeerId } from "./peer-id-registry";
 import {
   clearProactiveRiskObservationsForTest,
-  recordProactiveRiskObservation,
+  getProactiveRiskObservationForAny,
 } from "./proactive-risk-registry";
 import { getDingTalkRuntime } from "./runtime";
 import { sendBySession, sendMessage } from "./send-service";
@@ -51,8 +51,17 @@ function shouldSendProactivePermissionHint(params: {
     return false;
   }
 
-  const targetId = (params.senderStaffId || params.senderId || "").trim();
-  if (!targetId || !/^\d+$/.test(targetId)) {
+  const targetId = (params.senderId || "").trim();
+  if (!targetId) {
+    return false;
+  }
+
+  const riskObservation = getProactiveRiskObservationForAny(
+    params.accountId,
+    [params.senderId, params.senderStaffId],
+    params.nowMs,
+  );
+  if (!riskObservation || riskObservation.source !== "proactive-api") {
     return false;
   }
 
@@ -71,6 +80,14 @@ function shouldSendProactivePermissionHint(params: {
   return true;
 }
 
+function isUnhandledStopReasonText(value: string): boolean {
+  const normalized = value.trim();
+  if (!normalized) {
+    return false;
+  }
+  return /^Unhandled stop reason:\s*[A-Za-z0-9_-]+/i.test(normalized);
+}
+
 /**
  * Download DingTalk media file via runtime media service (sandbox-compatible).
  * Files are stored in the global media inbound directory.
@@ -207,7 +224,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       await sendBySession(
         dingtalkConfig,
         sessionWebhook,
-        `⚠️ 主动推送可能失败\n\n检测到当前用户标识为纯数字（\`${data.senderStaffId || senderId}\`）。企业内部机器人在定时/主动发送场景中，通常需要企业内部有效用户ID与完整授权。\n\n建议：\n1) 优先使用企业内部用户ID（如 managerXXXX）\n2) 确认应用已申请并获得主动发送相关权限\n3) 确认目标用户已加入机器人所属企业`,
+        "⚠️ 主动推送可能失败\n\n检测到该用户最近一次主动发送调用返回了权限或目标不可达错误。当前会话回复仍可正常使用，但定时/主动发送可能失败。\n\n建议：\n1) 在钉钉开放平台确认应用已申请并获得主动发送相关权限\n2) 确认目标用户属于当前企业并在应用可见范围内\n3) 使用相同账号进行一次主动发送验证并检查错误码详情",
         { log },
       );
     } catch (err: any) {
@@ -221,16 +238,6 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     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) {
@@ -467,6 +474,11 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
             return;
           }
 
+          if (typeof textToSend === "string" && isUnhandledStopReasonText(textToSend)) {
+            log?.warn?.(`[DingTalk] Suppressed stop reason from outbound chat content: ${textToSend}`);
+            return;
+          }
+
           if (useCardMode && currentAICard && info?.kind === "final") {
             lastCardContent = textToSend;
             return;
@@ -552,12 +564,21 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       const hasQueuedFinalString = isNonEmptyString(queuedFinal);
 
       if (hasLastCardContent || hasQueuedFinalString) {
-        const finalContent =
+        const finalContentCandidate =
           hasLastCardContent && typeof lastCardContent === "string"
             ? lastCardContent
             : typeof queuedFinal === "string"
               ? queuedFinal
               : "";
+        if (isUnhandledStopReasonText(finalContentCandidate)) {
+          log?.warn?.(
+            `[DingTalk] Suppressed stop reason from AI Card final content: ${finalContentCandidate}`,
+          );
+          currentAICard.state = AICardStatus.FINISHED;
+          currentAICard.lastUpdated = Date.now();
+          return;
+        }
+        const finalContent = finalContentCandidate;
         await finishAICard(currentAICard, finalContent, log);
       } else {
         log?.debug?.(

package/src/onboarding.ts

@@ -106,6 +106,9 @@ function applyAccountConfig(params: {
     ...(input.messageType ? { messageType: input.messageType } : {}),
     ...(input.cardTemplateId ? { cardTemplateId: input.cardTemplateId } : {}),
     ...(input.cardTemplateKey ? { cardTemplateKey: input.cardTemplateKey } : {}),
+    ...(typeof input.maxReconnectCycles === "number"
+      ? { maxReconnectCycles: input.maxReconnectCycles }
+      : {}),
   };
 
   if (useDefault) {
@@ -304,6 +307,35 @@ export const dingtalkOnboardingAdapter: ChannelOnboardingAdapter = {
       initialValue: resolved.groupPolicy ?? "open",
     });
 
+    let maxReconnectCycles: number | undefined;
+    const wantsReconnectLimits = await prompter.confirm({
+      message: "Configure runtime reconnect cycle limit? (recommended)",
+      initialValue: typeof resolved.maxReconnectCycles === "number",
+    });
+    if (wantsReconnectLimits) {
+      const parsedCycles = Number(
+        String(
+          await prompter.text({
+            message: "Max runtime reconnect cycles",
+            placeholder: "10",
+            initialValue: String(resolved.maxReconnectCycles ?? 10),
+            validate: (value) => {
+              const raw = String(value ?? "").trim();
+              const num = Number(raw);
+              if (!raw) {
+                return "Required";
+              }
+              if (!Number.isInteger(num) || num < 1) {
+                return "Must be an integer >= 1";
+              }
+              return undefined;
+            },
+          }),
+        ).trim(),
+      );
+      maxReconnectCycles = Number.isInteger(parsedCycles) && parsedCycles > 0 ? parsedCycles : 10;
+    }
+
     const next = applyAccountConfig({
       cfg,
       accountId,
@@ -319,6 +351,7 @@ export const dingtalkOnboardingAdapter: ChannelOnboardingAdapter = {
         messageType,
         cardTemplateId,
         cardTemplateKey,
+        maxReconnectCycles,
       },
     });
 

package/src/proactive-risk-registry.ts

@@ -59,6 +59,31 @@ export function getProactiveRiskObservation(
   return entry;
 }
 
+export function getProactiveRiskObservationForAny(
+  accountId: string,
+  targetIds: Array<string | null | undefined>,
+  nowMs = Date.now(),
+): ProactiveRiskSnapshot | null {
+  for (const candidate of targetIds) {
+    if (!candidate) {
+      continue;
+    }
+    const observation = getProactiveRiskObservation(accountId, candidate, nowMs);
+    if (observation) {
+      return observation;
+    }
+  }
+  return null;
+}
+
+export function deleteProactiveRiskObservation(accountId: string, targetId: string): void {
+  const target = targetId?.trim();
+  if (!accountId || !target) {
+    return;
+  }
+  store.delete(keyOf(accountId, target));
+}
+
 export function clearProactiveRiskObservationsForTest(): void {
   store.clear();
 }

package/src/send-service.ts

@@ -13,7 +13,11 @@ 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 {
+  deleteProactiveRiskObservation,
+  getProactiveRiskObservation,
+  recordProactiveRiskObservation,
+} from "./proactive-risk-registry";
 import { formatDingTalkErrorPayloadLog } from "./utils";
 import type {
   AxiosResponse,
@@ -27,6 +31,38 @@ import { AICardStatus } from "./types";
 
 export { detectMediaTypeFromExtension } from "./media-utils";
 
+function extractErrorCodeFromResponseData(data: unknown): string | null {
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+
+  const payload = data as Record<string, unknown>;
+  const code = payload.code;
+  if (typeof code === "string" && code.trim()) {
+    return code.trim();
+  }
+
+  const subCode = payload.subCode;
+  if (typeof subCode === "string" && subCode.trim()) {
+    return subCode.trim();
+  }
+
+  return null;
+}
+
+function isProactivePermissionOrScopeError(code: string | null): boolean {
+  if (!code) {
+    return false;
+  }
+  return (
+    code.startsWith("Forbidden.AccessDenied") ||
+    code === "invalidParameter.userIds.invalid" ||
+    code === "invalidParameter.userIds.empty" ||
+    code === "invalidParameter.openConversationId.invalid" ||
+    code === "invalidParameter.robotCode.empty"
+  );
+}
+
 /**
  * Wrapper to upload media with shared getAccessToken binding.
  */
@@ -94,6 +130,9 @@ export async function sendProactiveTextOrMarkdown(
       data: payload,
       headers: { "x-acs-dingtalk-access-token": token, "Content-Type": "application/json" },
     });
+    if (options.accountId) {
+      deleteProactiveRiskObservation(options.accountId, resolvedTarget);
+    }
     return result.data;
   } catch (err: unknown) {
     const maybeAxiosError = err as {
@@ -101,6 +140,16 @@ export async function sendProactiveTextOrMarkdown(
       message?: string;
     };
     if (maybeAxiosError?.response) {
+      const errCode = extractErrorCodeFromResponseData(maybeAxiosError.response.data);
+      if (options.accountId && isProactivePermissionOrScopeError(errCode)) {
+        recordProactiveRiskObservation({
+          accountId: options.accountId,
+          targetId: resolvedTarget,
+          level: "high",
+          reason: errCode || "proactive-permission-error",
+          source: "proactive-api",
+        });
+      }
       const status = maybeAxiosError.response.status;
       const statusText = maybeAxiosError.response.statusText;
       const statusLabel = status ? ` status=${status}${statusText ? ` ${statusText}` : ""}` : "";
@@ -190,6 +239,9 @@ export async function sendProactiveMedia(
       data: payload,
       headers: { "x-acs-dingtalk-access-token": token, "Content-Type": "application/json" },
     });
+    if (options.accountId) {
+      deleteProactiveRiskObservation(options.accountId, resolvedTarget);
+    }
 
     const messageId = result.data?.processQueryKey || result.data?.messageId;
     return { ok: true, data: result.data, messageId };
@@ -203,6 +255,16 @@ export async function sendProactiveMedia(
       ? ` proactiveRisk=${proactiveRisk.level}:${proactiveRisk.reason}`
       : "";
     if (axios.isAxiosError(err) && err.response) {
+      const errCode = extractErrorCodeFromResponseData(err.response.data);
+      if (options.accountId && isProactivePermissionOrScopeError(errCode)) {
+        recordProactiveRiskObservation({
+          accountId: options.accountId,
+          targetId: normalizedTarget,
+          level: "high",
+          reason: errCode || "proactive-permission-error",
+          source: "proactive-api",
+        });
+      }
       const status = err.response.status;
       const statusText = err.response.statusText;
       const statusLabel = status ? ` status=${status}${statusText ? ` ${statusText}` : ""}` : "";

package/src/types.ts

@@ -52,6 +52,8 @@ export interface DingTalkConfig extends OpenClawConfig {
   initialReconnectDelay?: number;
   maxReconnectDelay?: number;
   reconnectJitter?: number;
+  /** Maximum number of runtime reconnect cycles before giving up (default: 10) */
+  maxReconnectCycles?: number;
   proactivePermissionHint?: {
     enabled?: boolean;
     cooldownHours?: number;
@@ -83,6 +85,8 @@ export interface DingTalkChannelConfig {
   initialReconnectDelay?: number;
   maxReconnectDelay?: number;
   reconnectJitter?: number;
+  /** Maximum number of runtime reconnect cycles before giving up (default: 10) */
+  maxReconnectCycles?: number;
   proactivePermissionHint?: {
     enabled?: boolean;
     cooldownHours?: number;
@@ -476,6 +480,8 @@ export interface ConnectionManagerConfig {
   initialDelay: number;
   maxDelay: number;
   jitter: number;
+  /** Maximum number of runtime reconnect cycles before giving up (default: 10) */
+  maxReconnectCycles?: number;
   /** Callback invoked when connection state changes */
   onStateChange?: (state: ConnectionState, error?: string) => void;
 }
@@ -560,6 +566,7 @@ export function resolveDingTalkAccount(
       initialReconnectDelay: dingtalk?.initialReconnectDelay,
       maxReconnectDelay: dingtalk?.maxReconnectDelay,
       reconnectJitter: dingtalk?.reconnectJitter,
+      maxReconnectCycles: dingtalk?.maxReconnectCycles,
       proactivePermissionHint: dingtalk?.proactivePermissionHint,
     };
     return {