@soimy/dingtalk 3.3.0 → 3.4.0

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