@soimy/dingtalk 3.6.7 → 3.6.8

package/src/gateway/inbound-session-queue-dispatcher.ts

@@ -0,0 +1,304 @@
+// Authorized inbound serializer: wraps the already-authorized, route-resolved
+// portion of `handleDingTalkMessage` with the promise-chain queue from
+// `inbound-session-queue.ts`.
+//
+// The gateway intentionally does not call this module.  At the gateway boundary
+// we only have raw accountId + conversationId, before DM/group policy, allowlist
+// checks, special-command bypasses, and trusted agent routing.  Queueing there
+// could acknowledge an unauthorized sender or block /stop and /btw.  The caller
+// supplies the resolved route.sessionKey only after those decisions, so a message
+// that arrives while the same real session is active is queued and reprocessed
+// once the active run finishes instead of racing into the core's
+//   "reply session initialization conflicted for <sessionKey>"
+// and being dropped silently at the gateway catch block (the
+// "钉钉'确认'消息无响应" regression.
+//
+// While a message is queued, a pre-created AI Card shows an immediate
+// "已排队" acknowledgement; the handler later reuses that same card
+// (`params.preCreatedCard`) to stream the real reply in place.
+//
+// Ported from DingTalk-Real-AI/dingtalk-openclaw-connector's session-queue
+// orchestrator, adapted to soimy's blocking gateway contract (we await each
+// task so the gateway's per-message dedup stays correct).
+
+import { attachNativeAckReaction } from "../ack-reaction-service";
+import {
+  createAICard,
+  isCardInTerminalState,
+  recallAICardMessage,
+  streamAICard,
+} from "../card-service";
+import {
+  chainInboundSessionTask,
+  getInboundSessionQueueDepth,
+  InboundSessionQueueWaitTimeoutError,
+  isInboundSessionQueueBusy,
+  MAX_INBOUND_SESSION_QUEUE_DEPTH,
+  MAX_INBOUND_SESSION_QUEUE_WAIT_MS,
+  pickQueueBusyAckPhrase,
+} from "./inbound-session-queue";
+import { sendMessage } from "../send-service";
+import type { AICardInstance, DingTalkConfig, DingTalkInboundMessage, Logger } from "../types";
+
+export interface InboundQueueDispatchInput {
+  accountId: string;
+  data: DingTalkInboundMessage;
+  dingtalkConfig: DingTalkConfig;
+  /** Trusted route.sessionKey, resolved after access control. */
+  sessionKey: string;
+  /** Resolved DingTalk reply target for this authorized route. */
+  to: string;
+  storePath?: string;
+  quoteContent?: string;
+  log?: Logger;
+}
+
+const QUEUE_FULL_ACK = "当前消息较多，已达到本会话排队上限；请等待上一轮完成后再发送。";
+const QUEUE_WAIT_TIMEOUT_ACK = "上一轮处理时间较长，这条消息未执行；请稍后重新发送。";
+const QUEUE_HANDLER_FAILURE_ACK = "本次处理异常，未能完成；请稍后重新发送。";
+const MIN_QUEUE_ACK_CARD_VISIBLE_MS = 750;
+
+const queuedAckVisibleAt = new WeakMap<AICardInstance, number>();
+
+function shouldPrepareQueueAckCard(input: InboundQueueDispatchInput): boolean {
+  return input.dingtalkConfig.messageType === "card";
+}
+
+async function keepQueueAckCardVisible(card: AICardInstance): Promise<void> {
+  const visibleAt = queuedAckVisibleAt.get(card);
+  if (!visibleAt) {
+    return;
+  }
+  const remainingMs = MIN_QUEUE_ACK_CARD_VISIBLE_MS - (Date.now() - visibleAt);
+  if (remainingMs > 0) {
+    await new Promise<void>((resolve) => setTimeout(resolve, remainingMs));
+  }
+}
+
+async function settleUnusedQueueAckCard(
+  input: InboundQueueDispatchInput,
+  card: AICardInstance,
+): Promise<void> {
+  if (isCardInTerminalState(card.state)) {
+    return;
+  }
+  try {
+    if (await recallAICardMessage(card, input.log)) {
+      return;
+    }
+  } catch (err: unknown) {
+    input.log?.warn?.(
+      `[DingTalk] Failed to recall unused queue acknowledgement card: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+  await sendQueueTerminalAck(input, "已结束排队确认，请以本次实际回复为准。", card);
+}
+
+/**
+ * A visible queue ACK promises that the message will be handled.  If the
+ * queued continuation fails before consuming that card, finish it with a
+ * retryable outcome instead of recalling the only user-visible feedback.
+ */
+async function settleFailedQueueAckCard(
+  input: InboundQueueDispatchInput,
+  card: AICardInstance,
+): Promise<void> {
+  if (isCardInTerminalState(card.state)) {
+    return;
+  }
+  await sendQueueTerminalAck(input, QUEUE_HANDLER_FAILURE_ACK, card);
+}
+
+/**
+ * Serialize an inbound message per conversation, then invoke `handler` (which
+ * should call `handleDingTalkMessage` with the provided `preCreatedCard`).
+ *
+ * The returned promise settles with the handler's own outcome, so the caller
+ * (gateway) can await it and keep its per-message dedup correct
+ * (`markMessageProcessed` only runs once the message truly completes).
+ */
+export async function dispatchInboundViaSessionQueue<T>(
+  input: InboundQueueDispatchInput,
+  handler: (preCreatedCard?: AICardInstance) => Promise<T>,
+): Promise<T> {
+  const queueKey = input.sessionKey;
+  if (!queueKey) {
+    // A trusted route must include a session key. Keep this defensive fallback
+    // for alternate callers rather than inventing a raw gateway-level key.
+    return handler(undefined);
+  }
+  const wasBusy = isInboundSessionQueueBusy(queueKey);
+  if (getInboundSessionQueueDepth(queueKey) >= MAX_INBOUND_SESSION_QUEUE_DEPTH) {
+    await sendQueueTerminalAck(input, QUEUE_FULL_ACK);
+    return undefined as T;
+  }
+  // Detect busyness BEFORE chaining: this call is "busy" only if a PRIOR task
+  // for this conversation is still running.
+  // Start preparing a busy ACK without awaiting it before we reserve a queue
+  // slot below. Otherwise a burst of inbound messages can all observe the
+  // same pre-await depth and each pass the cap check.
+  let queuedAckState: "queued" | "timed-out" = "queued";
+  const preCreatedCardPromise = wasBusy && shouldPrepareQueueAckCard(input)
+    ? tryPrepareQueueAckCard(input, () =>
+        queuedAckState === "timed-out"
+          ? { content: QUEUE_WAIT_TIMEOUT_ACK, finished: true }
+          : { content: pickQueueBusyAckPhrase(), finished: false },
+      )
+    : undefined;
+  // Chain onto the prior task for this conversation and AWAIT. Awaiting (rather
+  // than fire-and-forget) preserves the gateway's per-message dedup:
+  // `markMessageProcessed` runs only after this message truly completes, so a
+  // still-queued message is never marked processed.
+  try {
+    return await chainInboundSessionTask(
+      queueKey,
+      async () => {
+        const preCreatedCard = preCreatedCardPromise
+          ? await preCreatedCardPromise
+          : undefined;
+        if (!preCreatedCard) {
+          return handler(undefined);
+        }
+        await keepQueueAckCardVisible(preCreatedCard);
+        let handlerFailed = false;
+        try {
+          return await handler(preCreatedCard);
+        } catch (err: unknown) {
+          handlerFailed = true;
+          await settleFailedQueueAckCard(input, preCreatedCard);
+          throw err;
+        } finally {
+          if (!handlerFailed && !isCardInTerminalState(preCreatedCard.state)) {
+            await settleUnusedQueueAckCard(input, preCreatedCard);
+          }
+        }
+      },
+      {
+        maxQueueWaitMs: wasBusy ? MAX_INBOUND_SESSION_QUEUE_WAIT_MS : undefined,
+      },
+    );
+  } catch (err: unknown) {
+    if (err instanceof InboundSessionQueueWaitTimeoutError) {
+      queuedAckState = "timed-out";
+      await sendQueueTerminalAck(
+        input,
+        QUEUE_WAIT_TIMEOUT_ACK,
+        preCreatedCardPromise ? await preCreatedCardPromise : undefined,
+      );
+      return undefined as T;
+    }
+    throw err;
+  }
+}
+
+/**
+ * Pre-create an AI Card showing a "已排队" acknowledgement for a message that
+ * arrived while its conversation was busy. The handler later reuses this card
+ * to stream the real reply in place. Best-effort: any failure returns
+ * undefined and the handler falls back to creating a fresh card (or markdown).
+ */
+async function tryPrepareQueueAckCard(
+  input: InboundQueueDispatchInput,
+  ack: () => { content: string; finished: boolean },
+): Promise<AICardInstance | undefined> {
+  const { dingtalkConfig, data, log, to, storePath, quoteContent } = input;
+  if (!data) {
+    return undefined;
+  }
+  if (!to) {
+    return undefined;
+  }
+  let card: AICardInstance | null = null;
+  let ackFinished = false;
+  try {
+    card = await createAICard(dingtalkConfig, to, log, {
+      accountId: input.accountId,
+      storePath,
+      quoteContent,
+    });
+    if (!card) {
+      return undefined;
+    }
+    const { content, finished } = ack();
+    ackFinished = finished;
+    await streamAICard(card, content, finished, log, {
+      recoveryAction: finished ? "finalize" : "recall",
+    });
+    if (!finished) {
+      queuedAckVisibleAt.set(card, Date.now());
+    }
+    if (finished) {
+      return card;
+    }
+    // Best-effort thinking reaction; failures must not block the queue.
+    void attachNativeAckReaction(
+      dingtalkConfig,
+      { msgId: data.msgId, conversationId: data.conversationId },
+      log,
+    ).catch((err: unknown) => {
+      log?.debug?.(
+        `[DingTalk] Queue-busy ack reaction attach failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    });
+    log?.info?.(
+      `[DingTalk] Inbound message queued behind active run for session=${input.sessionKey}; pre-created ACK card outTrackId=${card.cardInstanceId}.`,
+    );
+    return card;
+  } catch (err: unknown) {
+    if (card && !ackFinished) {
+      try {
+        await recallAICardMessage(card, log);
+      } catch (recallErr: unknown) {
+        log?.warn?.(
+          `[DingTalk] Failed to recall queue ACK card after prepare failure: ${recallErr instanceof Error ? recallErr.message : String(recallErr)}`,
+        );
+      }
+    }
+    log?.warn?.(
+      `[DingTalk] Queue-busy ACK card prepare failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return undefined;
+  }
+}
+
+async function sendQueueTerminalAck(
+  input: InboundQueueDispatchInput,
+  content: string,
+  preCreatedCard?: AICardInstance,
+): Promise<void> {
+  const { dingtalkConfig, data, log, to, storePath } = input;
+  try {
+    if (preCreatedCard) {
+      try {
+        await streamAICard(preCreatedCard, content, true, log);
+        return;
+      } catch (err: unknown) {
+        log?.warn?.(
+          `[DingTalk] Queue acknowledgement card finalization failed; falling back to text: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    } else {
+      const card = await tryPrepareQueueAckCard(input, () => ({ content, finished: true }));
+      if (card) {
+        return;
+      }
+    }
+    if (!to) {
+      return;
+    }
+    const result = await sendMessage(dingtalkConfig, to, content, {
+      sessionWebhook: data.sessionWebhook,
+      log,
+      accountId: input.accountId,
+      storePath,
+      conversationId: data.conversationId,
+    });
+    if (!result.ok) {
+      log?.warn?.(`[DingTalk] Queue terminal acknowledgement failed: ${result.error || "unknown"}`);
+    }
+  } catch (err: unknown) {
+    log?.warn?.(
+      `[DingTalk] Queue terminal acknowledgement delivery failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}

package/src/gateway/inbound-session-queue.ts

@@ -0,0 +1,244 @@
+// Per-conversation promise-chain serializer for inbound DingTalk messages.
+//
+// Why this exists: the openclaw core rejects a dispatch whose target session
+// already has an active (processing / paused) run with
+//   "reply session initialization conflicted for <sessionKey>".
+// Without serialization, a message that arrives while another is still being
+// processed races into that conflict and is dropped silently at the gateway
+// catch block (the "钉钉'确认'消息无响应" regression — the bot shows nothing
+// for tens of minutes).
+//
+// How it works: every inbound message for a conversation is chained onto the
+// previous task for that conversation (`sessionQueues`), so a message that
+// arrives while another is still running is QUEUED and auto-runs once the
+// active run finishes — zero re-send required. While queued, a pre-created AI
+// Card shows an immediate "已排队" acknowledgement (see
+// `tryPrepareQueueBusyAckCard` in inbound-handler.ts) which the real reply
+// later updates in place.
+//
+// The chain tail stored in the map is rejection-safe: a failed task never
+// blocks the next queued message. `chainInboundSessionTask` returns the
+// caller-visible promise (which CAN reject) so the gateway's per-message dedup
+// (markMessageProcessed runs only after the awaited handler settles) stays
+// correct — we never mark a still-queued message as processed.
+//
+// Ported from the session-queue orchestrator in
+// DingTalk-Real-AI/dingtalk-openclaw-connector, adapted to soimy's blocking
+// gateway contract.
+
+const SESSION_QUEUE_TTL_MS = 5 * 60 * 1000;
+const SESSION_QUEUE_CLEANUP_INTERVAL_MS = 60 * 1000;
+// Bound one conversation independently so one hung core run cannot retain an
+// unbounded number of user messages in memory. The active task counts toward
+// this limit, so at most seven messages may wait behind a running task.
+export const MAX_INBOUND_SESSION_QUEUE_DEPTH = 8;
+export const MAX_INBOUND_SESSION_QUEUE_WAIT_MS = 15 * 60 * 1000;
+
+const sessionQueues = new Map<string, Promise<void>>();
+const sessionLastActivity = new Map<string, number>();
+const sessionQueueDepths = new Map<string, number>();
+let cleanupTimer: NodeJS.Timeout | null = null;
+
+export class InboundSessionQueueWaitTimeoutError extends Error {
+  constructor(queueKey: string) {
+    super(`Inbound session queue wait timed out for ${queueKey}`);
+    this.name = "InboundSessionQueueWaitTimeoutError";
+  }
+}
+
+function ensureCleanupTimer(): void {
+  if (cleanupTimer) {
+    return;
+  }
+  cleanupTimer = setInterval(() => {
+    const now = Date.now();
+    for (const [key, lastSeen] of sessionLastActivity) {
+      if (now - lastSeen > SESSION_QUEUE_TTL_MS && !sessionQueues.has(key)) {
+        sessionLastActivity.delete(key);
+      }
+    }
+  }, SESSION_QUEUE_CLEANUP_INTERVAL_MS);
+  if (typeof cleanupTimer?.unref === "function") {
+    // Do not keep the Node event loop alive solely for queue bookkeeping.
+    cleanupTimer.unref();
+  }
+}
+
+/**
+ * Build the serialization key for an inbound message. We group by
+ * (accountId, conversationId): a 1:1 DM maps to one conversationId per user,
+ * and a group maps to its conversationId, which is exactly the granularity at
+ * which reply-session conflicts occur. Returns null when the key inputs are
+ * missing (caller falls back to a direct, un-queued dispatch).
+ */
+export function deriveInboundQueueKey(parts: {
+  accountId: string;
+  conversationId?: string;
+}): string | null {
+  const accountId = (parts.accountId || "").trim();
+  const conversationId = (parts.conversationId || "").trim();
+  if (!accountId || !conversationId) {
+    return null;
+  }
+  return `${accountId}:${conversationId}`;
+}
+
+export function isInboundSessionQueueBusy(queueKey: string): boolean {
+  return sessionQueues.has(queueKey);
+}
+
+/** Number of active + queued tasks for one conversation. */
+export function getInboundSessionQueueDepth(queueKey: string): number {
+  return sessionQueueDepths.get(queueKey) ?? 0;
+}
+
+export interface InboundSessionTaskOptions {
+  /** Maximum time this task may wait before it starts. Does not abort a running task. */
+  maxQueueWaitMs?: number;
+}
+
+/**
+ * Chain `task` onto the previous task for `queueKey`. Returns a promise that
+ * settles with `task`'s own outcome (so the caller observes the real result /
+ * error), while the stored chain tail is rejection-safe so one failed message
+ * never blocks the next queued one.
+ */
+export function chainInboundSessionTask<T>(
+  queueKey: string,
+  task: () => Promise<T>,
+  options: InboundSessionTaskOptions = {},
+): Promise<T> {
+  const hadPriorTask = sessionQueues.has(queueKey);
+  const previousTail = sessionQueues.get(queueKey) ?? Promise.resolve();
+  sessionLastActivity.set(queueKey, Date.now());
+  sessionQueueDepths.set(queueKey, getInboundSessionQueueDepth(queueKey) + 1);
+  ensureCleanupTimer();
+
+  let timedOut = false;
+  let timeout: NodeJS.Timeout | undefined;
+  let resolveWaitingCaller: ((value: T) => void) | undefined;
+  let rejectWaitingCaller: ((error: Error) => void) | undefined;
+  const maxQueueWaitMs = Math.max(0, options.maxQueueWaitMs ?? 0);
+  const caller =
+    maxQueueWaitMs > 0 && hadPriorTask
+      ? new Promise<T>((resolve, reject) => {
+          resolveWaitingCaller = resolve;
+          rejectWaitingCaller = reject;
+          timeout = setTimeout(() => {
+            timedOut = true;
+            reject(new InboundSessionQueueWaitTimeoutError(queueKey));
+          }, maxQueueWaitMs);
+          if (typeof timeout.unref === "function") {
+            timeout.unref();
+          }
+        })
+      : undefined;
+
+  // A queue timeout can fire while the gateway is still between awaits. Mark
+  // this caller-visible rejection as observed immediately so Node/Vitest does
+  // not report a transient unhandled rejection; returning `caller` below
+  // preserves the same rejection for the gateway to handle normally.
+  if (caller) {
+    void caller.catch(() => undefined);
+  }
+
+  const current = previousTail.then(() => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = undefined;
+    }
+    if (timedOut) {
+      throw new InboundSessionQueueWaitTimeoutError(queueKey);
+    }
+    return task();
+  });
+  const tail: Promise<void> = current.then(
+    () => undefined,
+    () => {
+      // Swallow so the next link in the chain still runs even if this task
+      // rejected.
+    },
+  );
+  sessionQueues.set(queueKey, tail);
+
+  // Early cleanup, attached to `current` (not `tail`) so it runs in the SAME
+  // microtask batch as `current`'s settlement, BEFORE the caller's `await` of
+  // `current` resumes. This avoids a brief window where a queue that just
+  // settled (e.g. the prior task threw) is still reported busy to the very next
+  // inbound message — which would wrongly trigger a queue-busy ACK card.
+  //
+  // Uses `.then(onSettled, onSettled)` rather than `.finally(...)`: `.finally`
+  // would propagate `current`'s rejection to a new promise we never await,
+  // surfacing as an unhandled rejection. `.then(fn, fn)` returns a promise that
+  // resolves once cleanup finishes, so no rejection escapes.
+  const cleanup = (): void => {
+    const nextDepth = Math.max(0, getInboundSessionQueueDepth(queueKey) - 1);
+    if (nextDepth) {
+      sessionQueueDepths.set(queueKey, nextDepth);
+    } else {
+      sessionQueueDepths.delete(queueKey);
+    }
+    if (sessionQueues.get(queueKey) === tail) {
+      sessionQueues.delete(queueKey);
+      sessionLastActivity.delete(queueKey);
+    }
+  };
+  void current.then(cleanup, cleanup);
+  if (!caller) {
+    return current;
+  }
+  void current.then(
+    (value) => {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      // The timeout may already have rejected this promise; subsequent resolve
+      // is intentionally ignored by Promise semantics.
+      resolveWaitingCaller?.(value);
+    },
+    (error: Error) => {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      rejectWaitingCaller?.(error);
+    },
+  );
+  return caller;
+}
+
+/**
+ * Phrases shown on the pre-created AI Card when a message is queued behind an
+ * active run. Ported from DingTalk-Real-AI/dingtalk-openclaw-connector
+ * `QUEUE_BUSY_ACK_PHRASES`.
+ */
+export const QUEUE_BUSY_ACK_PHRASES = [
+  "上一条还没结束，这条我已经记下，稍后按顺序继续处理。",
+  "当前还在忙，你的新消息已经排队，上一条完成后我马上继续。",
+  "我这边还在处理上一条，这条已加入队列，完成后继续处理。",
+] as const;
+
+/**
+ * Pick a queue-busy acknowledgement phrase. Pass `seed` for deterministic
+ * selection in tests.
+ */
+export function pickQueueBusyAckPhrase(seed?: number): string {
+  const list = QUEUE_BUSY_ACK_PHRASES;
+  const index = seed === undefined ? Math.floor(Math.random() * list.length) : seed % list.length;
+  return list[index];
+}
+
+/** @internal Visible for tests. */
+export function inboundSessionQueueBusyKeysForTest(): string[] {
+  return [...sessionQueues.keys()];
+}
+
+/** @internal Reset all queue state. Tests must call this in afterEach. */
+export function resetInboundSessionQueueForTest(): void {
+  sessionQueues.clear();
+  sessionLastActivity.clear();
+  sessionQueueDepths.clear();
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+  }
+}

package/src/gateway/reply-session-conflict.ts

@@ -0,0 +1,82 @@
+// When a new inbound message arrives while the openclaw core still has an
+// active (processing / paused) run for the same session key, the core's reply
+// resolver rejects the dispatch with:
+//   "reply session initialization conflicted for <sessionKey>"
+//
+// Without handling, this error propagates to the gateway catch block and the
+// message is silently dropped — the user sees no reply at all (the
+// "钉钉'确认'消息无响应" regression).
+//
+// This module lets the DingTalk channel treat that conflict as a transient,
+// queue-like condition: retry the dispatch a few times with backoff so a run
+// that drains within seconds is picked up, instead of failing fast.
+
+const REPLY_SESSION_CONFLICT_PATTERN = /reply session initialization conflicted/i;
+
+function readErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    const msg = (error as Record<string, unknown>).message;
+    return typeof msg === "string" ? msg : "";
+  }
+  return "";
+}
+
+export function isReplySessionConflictError(error: unknown): boolean {
+  return REPLY_SESSION_CONFLICT_PATTERN.test(readErrorMessage(error));
+}
+
+export interface ReplySessionConflictRetryOptions {
+  /** How many times to retry after the first conflict (default 3). */
+  maxRetries?: number;
+  /** Base backoff in ms; actual delay grows linearly per attempt (default 1500). */
+  baseDelayMs?: number;
+  /** Optional structured logger used for diagnostic warnings. */
+  log?: {
+    warn?: (message: string) => void;
+    info?: (message: string) => void;
+  };
+  /** Session key included in log lines for correlation. */
+  sessionKey?: string;
+}
+
+const sleep = (ms: number): Promise<void> =>
+  new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+
+/**
+ * Run `fn`, retrying only when it fails with a reply-session initialization
+ * conflict. Any other error is re-thrown immediately. After `maxRetries`
+ * conflicts the last conflict error is re-thrown so the caller can apply its
+ * own fallback (e.g. an immediate "processing" acknowledgement).
+ */
+export async function withReplySessionConflictRetry<T>(
+  fn: () => Promise<T>,
+  options: ReplySessionConflictRetryOptions = {},
+): Promise<T> {
+  const maxRetries = options.maxRetries ?? 3;
+  const baseDelayMs = options.baseDelayMs ?? 1500;
+  const sessionLabel = options.sessionKey ?? "?";
+
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (!isReplySessionConflictError(error) || attempt >= maxRetries) {
+        throw error;
+      }
+      const delay = baseDelayMs * (attempt + 1);
+      options.log?.warn?.(
+        `[DingTalk] Reply session initialization conflicted for session=${sessionLabel}; ` +
+          `active run still draining. Retry ${attempt + 1}/${maxRetries} after ${delay}ms.`,
+      );
+      await sleep(delay);
+    }
+  }
+}