@soimy/dingtalk 3.3.0 → 3.4.1

package/src/ack-reaction/dynamic-ack-reaction-controller.ts

@@ -0,0 +1,271 @@
+import { attachNativeAckReaction, recallNativeAckReactionWithRetry } from "../ack-reaction-service";
+import type { DingTalkConfig } from "../types";
+import { getErrorMessage } from "../utils";
+import {
+  createDynamicAckReactionCorrelator,
+  describeEvent,
+  type DynamicAckReactionLogger,
+  type RuntimeAgentEvent,
+  type RuntimeEventsSurface,
+} from "./dynamic-ack-reaction-events";
+import { resolveToolProgressReaction } from "./dynamic-ack-reaction-progress";
+
+type DynamicAckReactionControllerParams = {
+  enabled: boolean;
+  initialReaction: string;
+  initialAttached: boolean;
+  initialAttachedAt: number;
+  dingtalkConfig: DingTalkConfig;
+  msgId: string;
+  conversationId: string;
+  sessionKey: string;
+  log?: DynamicAckReactionLogger;
+  runtimeEvents?: RuntimeEventsSurface;
+  onReactionDisposed?: () => void;
+};
+
+const TOOL_REACTION_SILENCE_MS = 55_000;
+const TOOL_REACTION_HEARTBEAT_INTERVAL_MS = 60_000;
+const DYNAMIC_REACTION_MIN_SWITCH_INTERVAL_MS = 5_000;
+const OPTIMISTIC_RUN_ID_CAPTURE_WINDOW_MS = 5_000;
+const TOOL_HEARTBEAT_REACTION = "⏳";
+
+export function createDynamicAckReactionController(params: DynamicAckReactionControllerParams) {
+  let dynamicReactionStartedAt = 0;
+  let lastDynamicReactionAt = 0;
+  let currentAckReaction = params.initialReaction;
+  let ackReactionAttached = params.initialAttached;
+  let ackReactionAttachedAt = params.initialAttachedAt;
+  let progressHeartbeatInFlight = false;
+  let progressHeartbeatTimer: NodeJS.Timeout | undefined;
+  let dynamicReactionUpdatePromise: Promise<void> = Promise.resolve();
+  let lastDynamicReactionSwitchAt = 0;
+  let disposed = false;
+  const createdAt = Date.now();
+  const isCorrelatedEvent = createDynamicAckReactionCorrelator({
+    sessionKey: params.sessionKey,
+    enabled: params.enabled,
+    createdAt,
+    optimisticCaptureWindowMs: OPTIMISTIC_RUN_ID_CAPTURE_WINDOW_MS,
+    log: params.log,
+  });
+
+  const updateDynamicAckReaction = async (nextReaction: string) => {
+    const normalizedReaction = typeof nextReaction === "string" ? nextReaction.trim() : "";
+    if (disposed || !normalizedReaction || !params.enabled || !ackReactionAttached) {
+      params.log?.debug?.(
+        `[DingTalk] Dynamic ack reaction update skipped reaction=${normalizedReaction || "-"} ` +
+        `enabled=${params.enabled} ackReactionAttached=${ackReactionAttached} disposed=${disposed}`,
+      );
+      return;
+    }
+    if (normalizedReaction === currentAckReaction) {
+      params.log?.debug?.(
+        `[DingTalk] Dynamic ack reaction update skipped because reaction is unchanged: ${normalizedReaction}`,
+      );
+      if (dynamicReactionStartedAt === 0) {
+        dynamicReactionStartedAt = Date.now();
+      }
+      lastDynamicReactionAt = Date.now();
+      return;
+    }
+    if (
+      lastDynamicReactionSwitchAt > 0
+      && Date.now() - lastDynamicReactionSwitchAt < DYNAMIC_REACTION_MIN_SWITCH_INTERVAL_MS
+    ) {
+      params.log?.debug?.(
+        `[DingTalk] Dynamic ack reaction update throttled previous=${currentAckReaction} next=${normalizedReaction} ` +
+        `minIntervalMs=${DYNAMIC_REACTION_MIN_SWITCH_INTERVAL_MS}`,
+      );
+      return;
+    }
+
+    const previousReaction = currentAckReaction;
+    ackReactionAttached = false;
+    await recallNativeAckReactionWithRetry(
+      params.dingtalkConfig,
+      {
+        msgId: params.msgId,
+        conversationId: params.conversationId,
+        reactionName: previousReaction,
+      },
+      params.log,
+    );
+
+    const attached = await attachNativeAckReaction(
+      params.dingtalkConfig,
+      {
+        msgId: params.msgId,
+        conversationId: params.conversationId,
+        reactionName: normalizedReaction,
+      },
+      params.log,
+    );
+    if (!attached) {
+      if (disposed) {
+        return;
+      }
+      params.log?.debug?.(
+        `[DingTalk] Dynamic ack reaction attach did not succeed for reaction=${normalizedReaction}; restoring previous reaction=${previousReaction}`,
+      );
+      const restored = await attachNativeAckReaction(
+        params.dingtalkConfig,
+        {
+          msgId: params.msgId,
+          conversationId: params.conversationId,
+          reactionName: previousReaction,
+        },
+        params.log,
+      );
+      ackReactionAttached = restored;
+      if (restored) {
+        currentAckReaction = previousReaction;
+        ackReactionAttachedAt = Date.now();
+        if (dynamicReactionStartedAt === 0) {
+          dynamicReactionStartedAt = ackReactionAttachedAt;
+        }
+        lastDynamicReactionAt = ackReactionAttachedAt;
+      }
+      return;
+    }
+
+    params.log?.debug?.(`[DingTalk] Dynamic ack reaction switched to ${normalizedReaction}`);
+    ackReactionAttached = true;
+    currentAckReaction = normalizedReaction;
+    ackReactionAttachedAt = Date.now();
+    lastDynamicReactionSwitchAt = ackReactionAttachedAt;
+    if (dynamicReactionStartedAt === 0) {
+      dynamicReactionStartedAt = ackReactionAttachedAt;
+    }
+    lastDynamicReactionAt = ackReactionAttachedAt;
+  };
+
+  const queueDynamicAckReactionUpdate = (nextReaction: string) => {
+    if (disposed) {
+      return dynamicReactionUpdatePromise;
+    }
+    params.log?.debug?.(
+      `[DingTalk] Queue dynamic ack reaction update ${currentAckReaction || "-"} -> ${nextReaction || "-"}`,
+    );
+    dynamicReactionUpdatePromise = dynamicReactionUpdatePromise
+      .then(() => updateDynamicAckReaction(nextReaction))
+      .catch((err: unknown) => {
+        params.log?.warn?.(`[DingTalk] Dynamic ack reaction update failed: ${getErrorMessage(err)}`);
+      });
+    return dynamicReactionUpdatePromise;
+  };
+
+  const handleAgentEvent = async (event: unknown) => {
+    const agentEvent = event as RuntimeAgentEvent | undefined;
+    if (!params.enabled || disposed) {
+      return;
+    }
+    params.log?.debug?.(`[DingTalk] Dynamic reaction observed agent event ${describeEvent(agentEvent)}`);
+    if (agentEvent?.stream === "lifecycle" && agentEvent.data?.phase === "start") {
+      void isCorrelatedEvent(agentEvent);
+      return;
+    }
+    if (agentEvent?.stream !== "tool" || agentEvent.data?.phase !== "start") {
+      return;
+    }
+    if (!isCorrelatedEvent(agentEvent)) {
+      params.log?.debug?.(
+        `[DingTalk] Dynamic reaction ignored uncorrelated tool event ${describeEvent(agentEvent)}`,
+      );
+      return;
+    }
+    const toolCallId = typeof agentEvent.data?.toolCallId === "string" ? agentEvent.data.toolCallId : "-";
+    params.log?.debug?.(
+      `[DingTalk] Tool event received for dynamic ack reaction: name=${agentEvent.data?.name || "-"} toolCallId=${toolCallId}`,
+    );
+    await queueDynamicAckReactionUpdate(
+      resolveToolProgressReaction(agentEvent.data?.name, agentEvent.data?.args),
+    );
+  };
+
+  const unsubscribeAgentEvents = params.enabled && params.runtimeEvents?.onAgentEvent
+    ? params.runtimeEvents.onAgentEvent((event: unknown) => {
+        void handleAgentEvent(event).catch((err: unknown) => {
+          params.log?.warn?.(`[DingTalk] Dynamic ack reaction event handling failed: ${getErrorMessage(err)}`);
+        });
+      })
+    : () => {};
+
+  if (params.enabled && !params.runtimeEvents?.onAgentEvent) {
+    params.log?.debug?.("[DingTalk] onAgentEvent not available, dynamic reaction tracking disabled");
+  }
+
+  if (params.enabled) {
+    progressHeartbeatTimer = setInterval(() => {
+      if (
+        disposed
+        || !ackReactionAttached
+        || progressHeartbeatInFlight
+        || dynamicReactionStartedAt === 0
+        || lastDynamicReactionAt === 0
+      ) {
+        return;
+      }
+      if (Date.now() - lastDynamicReactionAt < TOOL_REACTION_SILENCE_MS) {
+        return;
+      }
+      params.log?.debug?.(
+        `[DingTalk] Dynamic ack reaction heartbeat triggered currentReaction=${currentAckReaction} ` +
+        `lastDynamicReactionAt=${lastDynamicReactionAt}`,
+      );
+      progressHeartbeatInFlight = true;
+      void queueDynamicAckReactionUpdate(TOOL_HEARTBEAT_REACTION).finally(() => {
+        progressHeartbeatInFlight = false;
+      });
+    }, TOOL_REACTION_HEARTBEAT_INTERVAL_MS);
+  }
+
+  const stop = (): void => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    unsubscribeAgentEvents();
+    if (progressHeartbeatTimer) {
+      clearInterval(progressHeartbeatTimer);
+      progressHeartbeatTimer = undefined;
+    }
+  };
+
+  return {
+    async awaitDrain(): Promise<void> {
+      await dynamicReactionUpdatePromise.catch(() => undefined);
+    },
+    async dispose(minVisibleMs: number): Promise<void> {
+      stop();
+      await this.awaitDrain();
+      if (!ackReactionAttached) {
+        params.onReactionDisposed?.();
+        return;
+      }
+      try {
+        const shouldRespectMinVisible = params.enabled && dynamicReactionStartedAt > 0;
+        const elapsedMs = ackReactionAttachedAt > 0 ? Date.now() - ackReactionAttachedAt : 0;
+        const remainingVisibleMs = shouldRespectMinVisible ? minVisibleMs - elapsedMs : 0;
+        if (remainingVisibleMs > 0) {
+          await new Promise(resolve => setTimeout(resolve, remainingVisibleMs));
+        }
+        await recallNativeAckReactionWithRetry(
+          params.dingtalkConfig,
+          {
+            msgId: params.msgId,
+            conversationId: params.conversationId,
+            reactionName: currentAckReaction,
+          },
+          params.log,
+        );
+      } catch (err: unknown) {
+        params.log?.warn?.(`[DingTalk] Dynamic ack reaction dispose recall failed: ${getErrorMessage(err)}`);
+      } finally {
+        ackReactionAttached = false;
+        params.onReactionDisposed?.();
+      }
+    },
+    stop,
+  };
+}

package/src/ack-reaction/dynamic-ack-reaction-events.ts

@@ -0,0 +1,123 @@
+import { getErrorMessage } from "../utils";
+
+export type DynamicAckReactionLogger = {
+  debug?: (msg: string) => void;
+  info?: (msg: string) => void;
+  warn?: (msg: string) => void;
+};
+
+export type RuntimeAgentEvent = {
+  stream?: string;
+  runId?: string;
+  sessionKey?: string;
+  data?: {
+    phase?: string;
+    name?: string;
+    args?: unknown;
+    runId?: string;
+    sessionKey?: string;
+    toolCallId?: string;
+    meta?: {
+      runId?: string;
+      sessionKey?: string;
+    } | null;
+  };
+};
+
+export type RuntimeEventsSurface = {
+  onAgentEvent?: (listener: (event: unknown) => void) => (() => void);
+};
+
+function firstTrimmedString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return undefined;
+}
+
+export function getEventRunId(event: RuntimeAgentEvent | undefined): string | undefined {
+  return firstTrimmedString(event?.runId, event?.data?.runId, event?.data?.meta?.runId);
+}
+
+export function getEventSessionKey(event: RuntimeAgentEvent | undefined): string | undefined {
+  return firstTrimmedString(event?.sessionKey, event?.data?.sessionKey, event?.data?.meta?.sessionKey);
+}
+
+export function describeEvent(event: RuntimeAgentEvent | undefined): string {
+  const stream = firstTrimmedString(event?.stream) || "-";
+  const phase = firstTrimmedString(event?.data?.phase) || "-";
+  const toolName = firstTrimmedString(event?.data?.name) || "-";
+  const toolCallId = firstTrimmedString(event?.data?.toolCallId) || "-";
+  return `stream=${stream} phase=${phase} runId=${getEventRunId(event) || "-"} ` +
+    `sessionKey=${getEventSessionKey(event) || "-"} toolCallId=${toolCallId} toolName=${toolName}`;
+}
+
+export function createDynamicAckReactionCorrelator(params: {
+  sessionKey: string;
+  enabled: boolean;
+  createdAt: number;
+  optimisticCaptureWindowMs: number;
+  log?: DynamicAckReactionLogger;
+}) {
+  let activeRunId: string | undefined;
+  let correlationUnavailableLogged = false;
+  let optimisticCaptureCount = 0;
+
+  return (event: RuntimeAgentEvent | undefined): boolean => {
+    const eventRunId = getEventRunId(event);
+    const eventSessionKey = getEventSessionKey(event);
+    const eventStream = firstTrimmedString(event?.stream) || "";
+    const eventPhase = firstTrimmedString(event?.data?.phase) || "";
+
+    if (activeRunId) {
+      const matched = eventRunId === activeRunId;
+      params.log?.debug?.(
+        `[DingTalk] Dynamic reaction correlation by runId matched=${matched} activeRunId=${activeRunId} ` +
+        `eventRunId=${eventRunId || "-"} eventSessionKey=${eventSessionKey || "-"}`,
+      );
+      return matched;
+    }
+
+    if (eventSessionKey === params.sessionKey) {
+      if (eventRunId) {
+        activeRunId = eventRunId;
+        params.log?.debug?.(
+          `[DingTalk] Dynamic reaction captured active runId=${activeRunId} from sessionKey=${params.sessionKey}`,
+        );
+      } else {
+        params.log?.debug?.(
+          `[DingTalk] Dynamic reaction correlated by sessionKey=${params.sessionKey} without runId`,
+        );
+      }
+      return true;
+    }
+
+    if (
+      optimisticCaptureCount === 0
+      && eventStream === "lifecycle"
+      && eventPhase === "start"
+      && eventRunId
+      && !eventSessionKey
+      && Date.now() - params.createdAt <= params.optimisticCaptureWindowMs
+    ) {
+      optimisticCaptureCount += 1;
+      activeRunId = eventRunId;
+      params.log?.debug?.(
+        `[DingTalk] Dynamic reaction optimistically captured active runId=${activeRunId} ` +
+        `from first lifecycle event without sessionKey windowMs=${params.optimisticCaptureWindowMs}`,
+      );
+      return true;
+    }
+
+    if (!correlationUnavailableLogged && params.enabled) {
+      correlationUnavailableLogged = true;
+      params.log?.debug?.(
+        `[DingTalk] Dynamic reaction ignored uncorrelated agent events; ` +
+        `reason=${getErrorMessage(eventRunId || eventSessionKey || "waiting for sessionKey/runId match")}`,
+      );
+    }
+    return false;
+  };
+}

package/src/ack-reaction/dynamic-ack-reaction-progress.ts

@@ -0,0 +1,59 @@
+function readToolArgString(args: unknown, keys: string[]): string | undefined {
+  if (!args || typeof args !== "object") {
+    return undefined;
+  }
+  const record = args as Record<string, unknown>;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Tool names here come from the runtime `onAgentEvent` tool-start payload.
+ * The runtime does not expose a typed enum on this event surface yet,
+ * so this mapping is intentionally best-effort and keeps a safe default.
+ */
+export function resolveToolProgressReaction(toolName: unknown, args: unknown): string {
+  const normalizedToolName = typeof toolName === "string" ? toolName.trim().toLowerCase() : "";
+  switch (normalizedToolName) {
+    case "bash":
+    case "exec":
+    case "process": {
+      const command = readToolArgString(args, ["command", "cmd"]);
+      if (!command) {
+        return "🛠️";
+      }
+      if (/\bbrew\s+install\s+/i.test(command) || /\b(?:pnpm|npm|yarn)\s+(?:add|install)\s+/i.test(command)) {
+        return "📦";
+      }
+      if (/\bwhich\s+/i.test(command)) {
+        return "🔍";
+      }
+      return "🛠️";
+    }
+    case "read":
+    case "view":
+      return "📂";
+    case "write":
+    case "edit":
+    case "patch":
+      return "✍️";
+    case "web_search":
+    case "search":
+    case "browser.search":
+    case "browser_search":
+      return "🌐";
+    case "fetch":
+    case "open":
+    case "open_url":
+    case "browser.open":
+    case "browser_open":
+      return "🔗";
+    default:
+      return "🛠️";
+  }
+}

package/src/ack-reaction-classifier.ts

@@ -19,11 +19,24 @@ const KEYWORDS = {
 const POLITE_EXCLUSIONS = ["别客气", "别介意", "别见怪", "别担心", "别着急"] as const;
 
 const EMOJIS: EmojiMap = {
-  "夸奖": ["(๑•̀ㅂ•́)و✧", "(ﾉ≧∀≦)ﾉ", "٩(๑>◡<๑)۶", "(★▽★)", "(⌒▽⌒)☆", "(*≧ω≦)", "(ง •_•)ง", "ヾ(≧▽≦*)o"],
+  // DingTalk `emotion/reply` does not accept every visually valid kaomoji.
+  // Keep only the strings that survived repeated direct API retests against
+  // the live endpoint using a real message target. Removed as unstable/bad:
+  // `٩(๑>◡<๑)۶`.
+  "夸奖": ["(๑•̀ㅂ•́)و✧", "(ﾉ≧∀≦)ﾉ", "(★▽★)", "(⌒▽⌒)☆", "(*≧ω≦)", "(ง •_•)ง", "ヾ(≧▽≦*)o"],
   "责怪": ["(╬ Ò﹏Ó)", "(╯°□°）╯", "(▼皿▼#)", "(｡•́︿•̀｡)", "(╥﹏╥)", "ヽ(｀Д´)ﾉ", "(＃＞＜)", "(；′⌒`)"],
-  "命令": ["(¬_¬)", "(｀ε´)", "(＃｀Д´)", "(●｀∀´●)", "┌（┌ *｀д´）┐", "(｀д´)", "(•̀へ •́ ╮ )", "(￣ω￣;)"],
-  "叙事": ["(。・ω・。)", "(￣▽￣)", "(´• ω •`)", "(・・?)", "(。_。)", "(￣ω￣)", "(´▽`)", "(=_=)"],
-  "请求": ["(っ´∀｀)っ", "(๑•̀ω•́๑)✧", "(づ｡◕‿‿◕｡)づ", "(p≧w≦q)", "(♡˙︶˙♡)", "(⁄ ⁄•⁄ω⁄•⁄ ⁄)", "(´;ω;｀)", "(人•ᴗ•✿)"],
+  // Keep command kaomoji limited to strings that passed local
+  // DingTalk emotion/reply verification. Removed as unstable/bad after
+  // repeated direct API retests: `┌（┌ *｀д´）┐`, `(•̀へ •́ ╮ )`.
+  "命令": ["(¬_¬)", "(｀ε´)", "(＃｀Д´)", "(●｀∀´●)", "(｀д´)", "(￣ω￣;)"],
+  // Narrative kaomoji must also stay within the subset accepted by
+  // DingTalk emotion/reply. Removed as unstable/bad after repeated direct
+  // API retests: `(´• ω •`)`.
+  "叙事": ["(。・ω・。)", "(￣▽￣)", "(・・?)", "(。_。)", "(￣ω￣)", "(´▽`)", "(=_=)"],
+  // Request kaomoji must exclude strings that stayed unstable across
+  // repeated direct API retests. Removed as unstable/bad:
+  // `(づ｡◕‿‿◕｡)づ`, `(⁄ ⁄•⁄ω⁄•⁄ ⁄)`.
+  "请求": ["(っ´∀｀)っ", "(๑•̀ω•́๑)✧", "(p≧w≦q)", "(♡˙︶˙♡)", "(´;ω;｀)", "(人•ᴗ•✿)"],
   "未知": ["(•̀_•́)", "(；一_一)", "(???)"],
 };
 

package/src/ack-reaction-service.ts

@@ -1,13 +1,17 @@
 import axios from "axios";
 import { getAccessToken } from "./auth";
 import type { DingTalkConfig } from "./types";
-import { formatDingTalkErrorPayloadLog, getProxyBypassOption } from "./utils";
+import { formatDingTalkErrorPayloadLog, getErrorMessage, getProxyBypassOption } from "./utils";
 
 // DingTalk currently exposes a dedicated native "thinking" reaction flow rather than
 // a generic arbitrary-emoji reaction API for this plugin path.
 const DINGTALK_NATIVE_ACK_REACTION = "🤔思考中";
 const THINKING_EMOTION_ID = "2659900";
 const THINKING_EMOTION_BACKGROUND_ID = "im_bg_1";
+// DingTalk `emotion/reply` occasionally races with just-arrived inbound
+// messages or returns transient 5xx responses. Keep the first attempt
+// immediate, then retry twice with short backoff windows before giving up.
+const THINKING_REACTION_ATTACH_DELAYS_MS = [0, 400, 1200] as const;
 const THINKING_REACTION_RECALL_DELAYS_MS = [0, 1500, 5000] as const;
 
 type AckReactionLogger = {
@@ -23,6 +27,14 @@ type AckReactionTarget = {
   reactionName?: string;
 };
 
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" ? (value as Record<string, unknown>) : undefined;
+}
+
+function formatAckReactionTarget(data: AckReactionTarget): string {
+  return `msgId=${data.msgId || "-"} conversationId=${data.conversationId || "-"} reactionName=${data.reactionName || DINGTALK_NATIVE_ACK_REACTION}`;
+}
+
 function resolveAckReactionPayload(config: DingTalkConfig, data: AckReactionTarget): {
   robotCode: string;
   reactionName: string;
@@ -44,10 +56,10 @@ async function callEmotionApi(
   errorLogPrefix: string,
   errorPayloadKey: "inbound.ackReactionAttach" | "inbound.ackReactionRecall",
   log?: AckReactionLogger,
-): Promise<boolean> {
+): Promise<{ ok: boolean; error?: unknown }> {
   const payload = resolveAckReactionPayload(config, data);
   if (!payload) {
-    return false;
+    return { ok: false };
   }
 
   try {
@@ -77,14 +89,29 @@ async function callEmotionApi(
       },
     );
     log?.info?.(successLog);
-    return true;
-  } catch (err: any) {
-    log?.warn?.(`${errorLogPrefix}: ${err.message}`);
-    if (err?.response?.data !== undefined) {
-      log?.warn?.(formatDingTalkErrorPayloadLog(errorPayloadKey, err.response.data));
+    return { ok: true };
+  } catch (err: unknown) {
+    const response = asRecord(asRecord(err)?.response);
+    log?.warn?.(`${errorLogPrefix}: ${getErrorMessage(err)}`);
+    if (response?.data !== undefined) {
+      log?.warn?.(formatDingTalkErrorPayloadLog(errorPayloadKey, response.data));
     }
-    return false;
+    return { ok: false, error: err };
+  }
+}
+
+function isRetryableEmotionApiError(err: unknown): boolean {
+  const response = asRecord(asRecord(err)?.response);
+  const data = asRecord(response?.data);
+  const status = Number(response?.status ?? 0);
+  const errorCode = String(data?.code || "").trim().toLowerCase();
+  if (!response) {
+    return true;
+  }
+  if (status >= 500) {
+    return true;
   }
+  return errorCode === "system.err";
 }
 
 export async function attachNativeAckReaction(
@@ -92,15 +119,34 @@ export async function attachNativeAckReaction(
   data: AckReactionTarget,
   log?: AckReactionLogger,
 ): Promise<boolean> {
-  return callEmotionApi(
-    config,
-    data,
-    "reply",
-    "[DingTalk] Native ack reaction attach succeeded",
-    "[DingTalk] Native ack reaction attach failed",
-    "inbound.ackReactionAttach",
-    log,
-  );
+  for (let index = 0; index < THINKING_REACTION_ATTACH_DELAYS_MS.length; index += 1) {
+    const delayMs = THINKING_REACTION_ATTACH_DELAYS_MS[index];
+    if (delayMs > 0) {
+      await new Promise(resolve => setTimeout(resolve, delayMs));
+    }
+    const attempt = index + 1;
+    const attemptLabel = `${attempt}/${THINKING_REACTION_ATTACH_DELAYS_MS.length}`;
+    const result = await callEmotionApi(
+      config,
+      data,
+      "reply",
+      `[DingTalk] Native ack reaction attach succeeded (${formatAckReactionTarget(data)} attempt=${attemptLabel})`,
+      `[DingTalk] Native ack reaction attach failed (${formatAckReactionTarget(data)} attempt=${attemptLabel})`,
+      "inbound.ackReactionAttach",
+      log,
+    );
+    if (result.ok) {
+      return true;
+    }
+    const shouldRetry = isRetryableEmotionApiError(result.error);
+    if (!shouldRetry || attempt === THINKING_REACTION_ATTACH_DELAYS_MS.length) {
+      break;
+    }
+    log?.debug?.(
+      `[DingTalk] Retrying native ack reaction attach (${formatAckReactionTarget(data)} nextAttempt=${attempt + 1}/${THINKING_REACTION_ATTACH_DELAYS_MS.length})`,
+    );
+  }
+  return false;
 }
 
 async function recallNativeAckReaction(
@@ -108,7 +154,7 @@ async function recallNativeAckReaction(
   data: AckReactionTarget,
   log?: AckReactionLogger,
 ): Promise<boolean> {
-  return callEmotionApi(
+  const result = await callEmotionApi(
     config,
     data,
     "recall",
@@ -117,6 +163,7 @@ async function recallNativeAckReaction(
     "inbound.ackReactionRecall",
     log,
   );
+  return result.ok;
 }
 
 export async function recallNativeAckReactionWithRetry(

package/src/attachment-text-extractor.ts

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import type { AttachmentTextSource } from "./types";
 
 const MAX_EXTRACTED_TEXT_CHARS = 6000;
 const MAX_ATTACHMENT_EXTRACT_BYTES = 2 * 1024 * 1024;
@@ -13,7 +14,7 @@ export interface AttachmentTextExtractionInput {
 export interface AttachmentTextExtractionResult {
   text: string;
   truncated: boolean;
-  sourceType: "text" | "html" | "pdf" | "docx";
+  sourceType: AttachmentTextSource;
 }
 
 async function isFileTooLarge(filePath: string): Promise<boolean> {