@soimy/dingtalk 3.6.6 → 3.6.8

package/src/inbound-handler.ts

@@ -13,6 +13,10 @@ import {
   isCardInTerminalState,
   recallAICardMessage,
 } from "./card-service";
+import {
+  invalidateAskUserQuestionsForScope,
+  syncInvalidatedAskUserQuestionCards,
+} from "./card/ask-user-question";
 import {
   getDingTalkQuestionContext,
   withDingTalkQuestionContext,
@@ -30,6 +34,7 @@ import {
 } from "./config";
 import { buildLearningContextBlock, isLearningEnabled } from "./feedback-learning-service";
 import axios from "./http-client";
+import { dispatchInboundViaSessionQueue } from "./gateway/inbound-session-queue-dispatcher";
 import { setCurrentLogger } from "./logger-context";
 import { prepareMediaInput, resolveOutboundMediaType } from "./media-utils";
 import {
@@ -56,6 +61,10 @@ import {
   clearProactiveRiskObservationsForTest,
   getProactiveRiskObservationForAny,
 } from "./proactive-risk-registry";
+import {
+  isReplySessionConflictError,
+  withReplySessionConflictRetry,
+} from "./gateway/reply-session-conflict";
 import { createReplyStrategy } from "./reply-strategy";
 import type { DeliverPayload } from "./reply-strategy-types";
 import { getDingTalkRuntime } from "./runtime";
@@ -81,7 +90,13 @@ import {
   upsertObservedUserTarget,
 } from "./targeting/target-directory-store";
 import { AICardStatus } from "./types";
-import type { DingTalkConfig, HandleDingTalkMessageParams, Logger, MediaFile } from "./types";
+import type {
+  DingTalkConfig,
+  HandleDingTalkMessageParams,
+  Logger,
+  MediaFile,
+  ResolvedDingTalkRoute,
+} from "./types";
 import {
   formatDingTalkErrorPayloadLog,
   getErrorMessage,
@@ -561,8 +576,9 @@ export async function downloadMedia(
 
 export async function handleDingTalkMessage(params: HandleDingTalkMessageParams): Promise<void> {
   // Keep context creation inside this public inbound entry. Ask-user synthetic
-  // reinjections call handleDingTalkMessage directly, so moving this wrapper to
-  // gateway callbacks would lose per-message isolation for reinjected answers.
+  // reinjections call handleDingTalkMessage directly.  The normal inbound queue
+  // is therefore entered later, after this handler has completed authorization
+  // and trusted route/session resolution; ask-user stays outside that queue.
   return withDingTalkQuestionContext(
     {
       cfg: params.cfg,
@@ -584,6 +600,8 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
     sessionWebhook,
     log,
     dingtalkConfig,
+    inboundOrigin = "stream",
+    routeOverride,
     subAgentOptions,
     preDownloadedMedia,
   } = params;
@@ -810,38 +828,42 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
     ? null
     : resolveMessageTarget({ extractedContent, cfg, isGroup });
 
-  let route: { agentId: string; sessionKey: string; mainSessionKey: string };
-  if (subAgentOptions) {
-    // Recursive sub-agent dispatch (content or targeted command): route to the
-    // agent's own session. A missing host helper throws here and is caught by
-    // dispatchSubAgents in the parent call.
-    route = {
-      agentId: subAgentOptions.agentId,
-      sessionKey: buildAgentSessionKey({
-        rt,
-        cfg,
-        accountId,
-        agentId: subAgentOptions.agentId,
-        peerKind: sessionPeer.kind,
-        peerId: sessionPeer.peerId,
-      }),
-      mainSessionKey: "",
-    };
-  } else {
-    // Default route. For subagent-content / subagent-command targets the
-    // dispatch below re-enters this function with subAgentOptions set, so this
-    // route is only consumed when the target is "default".
-    route = rt.channel.routing.resolveAgentRoute({
-      cfg,
-      channel: "dingtalk",
-      accountId,
-      peer: { kind: sessionPeer.kind, id: sessionPeer.peerId },
+  const invalidateQuestionRoutes = (routes: readonly ResolvedDingTalkRoute[]): void => {
+    if (inboundOrigin === "ask-user") {
+      return;
+    }
+    const scopeKeys = new Set(
+      routes.map((resolvedRoute) => `${accountId}:${resolvedRoute.sessionKey}:${senderId}`),
+    );
+    const invalidatedRecords = [];
+    for (const questionScopeKey of scopeKeys) {
+      try {
+        invalidatedRecords.push(
+          ...invalidateAskUserQuestionsForScope({
+            storePath: accountStorePath,
+            accountId,
+            questionScopeKey,
+            reason: "superseded_by_message",
+            log,
+          }),
+        );
+      } catch (err) {
+        log?.warn?.(
+          `[DingTalk][AskUser] Failed to invalidate pending cards before inbound dispatch scope=${questionScopeKey}: ${String(err)}`,
+        );
+      }
+    }
+    if (invalidatedRecords.length === 0) {
+      return;
+    }
+    void syncInvalidatedAskUserQuestionCards({
+      records: invalidatedRecords,
+      config: dingtalkConfig,
+      log,
+    }).catch((err) => {
+      log?.warn?.(`[DingTalk][AskUser] Card invalidation sync failed: ${String(err)}`);
     });
-  }
-  const questionContext = getDingTalkQuestionContext();
-  if (questionContext) {
-    questionContext.questionScopeKey = `${accountId}:${route.sessionKey}:${senderId}`;
-  }
+  };
 
   // @Sub-Agent routing: dispatch @mention-targeted messages to their agent(s).
   // Both content (`@agent <message>`) and commands (`@agent /new`) re-enter
@@ -858,9 +880,13 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
         dingtalkConfig,
         sessionWebhook,
         extractedContent,
+        sessionPeer,
+        onRoutesResolved: (targets) =>
+          invalidateQuestionRoutes(targets.map((target) => target.route)),
         handleMessage: handleDingTalkMessage,
         downloadMedia,
         log,
+        inboundQueueEligible: params.inboundQueueEligible,
       });
       return;
     }
@@ -889,15 +915,60 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
         dingtalkConfig,
         sessionWebhook,
         extractedContent,
+        sessionPeer,
+        onRoutesResolved: (targets) =>
+          invalidateQuestionRoutes(targets.map((target) => target.route)),
         handleMessage: handleDingTalkMessage,
         downloadMedia,
         log,
+        inboundQueueEligible: params.inboundQueueEligible,
       });
       return;
     }
     // Only invalid agent names and no match: fall through to the default route.
   }
 
+  let route: ResolvedDingTalkRoute;
+  if (routeOverride) {
+    route = routeOverride;
+  } else if (subAgentOptions) {
+    route = {
+      agentId: subAgentOptions.agentId,
+      sessionKey: buildAgentSessionKey({
+        rt,
+        cfg,
+        accountId,
+        agentId: subAgentOptions.agentId,
+        peerKind: sessionPeer.kind,
+        peerId: sessionPeer.peerId,
+      }),
+      mainSessionKey: "",
+    };
+  } else {
+    route = rt.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: "dingtalk",
+      accountId,
+      peer: { kind: sessionPeer.kind, id: sessionPeer.peerId },
+    });
+  }
+  const questionContext = getDingTalkQuestionContext();
+  if (questionContext) {
+    questionContext.resolvedRoute = route;
+    questionContext.questionScopeKey = `${accountId}:${route.sessionKey}:${senderId}`;
+    questionContext.storePath = accountStorePath;
+    questionContext.continuationSubAgentOptions = subAgentOptions
+      ? {
+          agentId: subAgentOptions.agentId,
+          responsePrefix: subAgentOptions.responsePrefix,
+          matchedName: subAgentOptions.matchedName,
+        }
+      : undefined;
+  }
+  if (!subAgentOptions) {
+    invalidateQuestionRoutes([route]);
+  }
+
   // Route resolved before media download for session context and routing metadata.
   const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
     agentId: route.agentId,
@@ -936,7 +1007,45 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
   const quotedRef = buildInboundQuotedRef(data, extractedContent);
   const replyQuotedRef = createReplyQuotedRef(data.msgId);
   const content = extractedContent;
-  const isBtwBypass = isBtwRequestText(stripLeadingMentions(content.text).trim());
+  // Decide control-message bypasses once from the user-authored text.  Reusing
+  // the result below keeps /stop out of the FIFO queue without calling the SDK
+  // classifier a second time after attachment/OCR enrichment.
+  const controlText = stripLeadingMentions(content.text).trim();
+  const isBtwBypass = isBtwRequestText(controlText);
+  const isAbortBypass = isAbortRequestText(controlText);
+
+  // Queue only after all access checks and the trusted route.sessionKey above.
+  // Gateway-level queueing uses only raw conversationId, which can both
+  // acknowledge an unauthorized sender and block /stop or /btw behind a long
+  // run.  A queued continuation re-enters with the guard set and reuses the
+  // visible queue ACK card for the actual answer.
+  if (
+    params.inboundQueueEligible &&
+    !params.inboundQueueHandled &&
+    inboundOrigin !== "ask-user" &&
+    !isBtwBypass &&
+    !isAbortBypass
+  ) {
+    await dispatchInboundViaSessionQueue(
+      {
+        accountId,
+        data,
+        dingtalkConfig,
+        sessionKey: route.sessionKey,
+        to,
+        storePath: accountStorePath,
+        quoteContent: rawInboundText.slice(0, 200),
+        log,
+      },
+      (preCreatedCard) =>
+        handleDingTalkMessage({
+          ...params,
+          preCreatedCard,
+          inboundQueueHandled: true,
+        }),
+    );
+    return;
+  }
   const taskInfoConversationId = groupId || to;
   const agentDisplayName = getAgentDisplayName({
     subAgentOptions,
@@ -978,7 +1087,6 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
   let cardFlightKey: string | undefined;
   if (questionContext) {
     questionContext.onQuestionCardSent = async ({ questionId, outTrackId }) => {
-      questionCardTookOver = true;
       if (cardFlightKey) {
         cardCreationInFlight.delete(cardFlightKey);
         cardFlightKey = undefined;
@@ -999,27 +1107,38 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
         log?.warn?.(
           `[DingTalk][AskUser] Question card sent, but targeted stop failed question=${questionId} outTrackId=${outTrackId} targetSessionKey=${route.sessionKey}: ${err instanceof Error ? err.message : String(err)}`,
         );
+        return false;
       }
+      questionCardTookOver = true;
       if (!currentAICard) {
-        return;
+        return true;
       }
       if (isCardInTerminalState(currentAICard.state)) {
-        return;
+        return true;
+      }
+      let recalled = false;
+      try {
+        recalled = await recallAICardMessage(currentAICard, log);
+      } catch (err) {
+        log?.warn?.(
+          `[DingTalk][AskUser] Question card took over, but AI card recall errored question=${questionId} outTrackId=${outTrackId}: ${err instanceof Error ? err.message : String(err)}`,
+        );
+        return true;
       }
-      const recalled = await recallAICardMessage(currentAICard, log);
       if (!recalled) {
         log?.warn?.(
           `[DingTalk][AskUser] Question card sent, but AI card recall failed; normal replies remain suppressed question=${questionId} outTrackId=${outTrackId}`,
         );
-        return;
+        return true;
       }
       log?.info?.(
         `[DingTalk][AskUser] Recalled empty AI card after question card sent question=${questionId} outTrackId=${outTrackId}`,
       );
+      return true;
     };
   }
 
-  if (useCardMode && !isBtwBypass) {
+  if (useCardMode && !isBtwBypass && !params.preCreatedCard) {
     const key = `${accountId}:${to}`;
     if (cardCreationInFlight.has(key)) {
       useCardMode = false;
@@ -1042,13 +1161,18 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
       // Use rawInboundText ( preserved before sub-agent rewriting) to avoid
       // showing internal routing context like "[你被 @ 为...]" in the card UI.
       const inboundQuoteText = rawInboundText.slice(0, 200);
-      const aiCard = await createAICard(dingtalkConfig, to, log, {
-        accountId,
-        storePath: accountStorePath,
-        contextConversationId: groupId,
-        quoteContent: inboundQuoteText,
-        statusLine: initialStatusLine,
-      });
+      // Reuse the pre-created card (shown while this message was queued behind
+      // an active run) instead of creating a new one: the real reply streams
+      // INTO the same card (in-place update).
+      const aiCard =
+        params.preCreatedCard ??
+        (await createAICard(dingtalkConfig, to, log, {
+          accountId,
+          storePath: accountStorePath,
+          contextConversationId: groupId,
+          quoteContent: inboundQuoteText,
+          statusLine: initialStatusLine,
+        }));
       if (aiCard) {
         currentAICard = aiCard;
         if (aiCard.outTrackId) {
@@ -1757,12 +1881,11 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
     // tryFastAbortFromMessage (inside the SDK) kill any in-flight generation immediately,
     // rather than waiting for it to finish before the stop message is processed.
     //
-    // Strip leading @mention tokens before the abort check so that messages like
-    // "@Agent /stop" are correctly recognised as abort requests in both DM and group
-    // chats. In groups DingTalk usually strips @BotName at the protocol level, but
-    // in DMs with multi-agent routing the @mention prefix survives all the way here.
-    const textForAbortCheck = stripLeadingMentions(inboundText).trim();
-    if (isAbortRequestText(textForAbortCheck)) {
+    // The early control-text decision strips leading @mentions, so messages like
+    // "@Agent /stop" are correctly recognised in both DM and group chats.  It is
+    // intentionally reused here instead of reclassifying attachment/OCR-enriched
+    // input, which would make queue admission and the actual abort path disagree.
+    if (isAbortBypass) {
       log?.info?.(
         `[DingTalk] Abort request detected, bypassing session lock for session=${route.sessionKey}`,
       );
@@ -2225,9 +2348,12 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
         taskMeta,
       });
 
-      try {
-        let deliveredFinalCount = 0;
-        const dispatchResult = await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+      let deliveredFinalCount = 0;
+      // Extracted as a thunk so reply-session init conflicts (raised by the
+      // core when an active run still occupies this session) can be retried
+      // with backoff instead of dropping the inbound message.
+      const runDispatch = () =>
+        rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
           ctx,
           cfg,
           dispatcherOptions: {
@@ -2274,6 +2400,12 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
           replyOptions: strategy.getReplyOptions(),
         });
 
+      try {
+        const dispatchResult = await withReplySessionConflictRetry(runDispatch, {
+          log,
+          sessionKey: route.sessionKey,
+        });
+
         const bufferedFinal =
           dispatchResult && typeof dispatchResult === "object" && "queuedFinal" in dispatchResult
             ? (dispatchResult as { queuedFinal?: unknown }).queuedFinal
@@ -2321,6 +2453,71 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
       } catch (dispatchErr: unknown) {
         const error =
           dispatchErr instanceof Error ? dispatchErr : new Error(getErrorMessage(dispatchErr));
+        if (isReplySessionConflictError(error)) {
+          // Fallback (兜底): the active run for this session did not drain within
+          // the retry budget, so dispatching the inbound message still conflicts.
+          // Rather than silently dropping it (outcome=error, no reply — the
+          // "钉钉确认消息无响应" regression), send an immediate acknowledgement so
+          // the user knows the message was received while the prior turn is still
+          // busy; they can re-send once it finishes.
+          log?.warn?.(
+            `[DingTalk] Reply session still conflicted after retries for session=${route.sessionKey}; ` +
+              `sending "processing" acknowledgement instead of dropping the message.`,
+          );
+          const ackText = "收到，上一轮还在处理中，请稍候再试。";
+          // A card may already be visible (including the card created while a
+          // gateway-queued message waited). Put the busy acknowledgement into
+          // that same delivery strategy and finalize it normally. Calling
+          // `strategy.abort()` after a separate acknowledgement would overwrite
+          // the visible card with "❌ 处理失败", which contradicts the actual
+          // recoverable-busy state.
+          if (replyMode === "card") {
+            try {
+              await strategy.deliver({
+                text: ackText,
+                mediaUrls: [],
+                kind: "final",
+                isReasoning: false,
+              });
+              await strategy.finalize();
+              return;
+            } catch (cardAckErr: unknown) {
+              log?.warn?.(
+                `[DingTalk] Processing acknowledgement card finalize failed: ${getErrorMessage(cardAckErr)}`,
+              );
+              // The card was already the reply surface for this inbound
+              // message. If its busy acknowledgement cannot be committed,
+              // do not emit a second text acknowledgement and then abort the
+              // card: abort renders "❌ 处理失败", which contradicts the
+              // recoverable busy state and leaves two visible outcomes.
+              // Keep the existing card untouched and let the next inbound
+              // message / normal card lifecycle recover it instead.
+              return;
+            }
+          }
+          try {
+            if (sessionWebhook) {
+              await sendBySession(dingtalkConfig, sessionWebhook, ackText, {
+                log,
+                accountId,
+                storePath: accountStorePath,
+              });
+            } else {
+              await sendMessage(dingtalkConfig, to, ackText, {
+                log,
+                accountId,
+                storePath: accountStorePath,
+                conversationId: groupId,
+              });
+            }
+          } catch (ackErr: unknown) {
+            log?.warn?.(
+              `[DingTalk] Processing acknowledgement delivery failed: ${getErrorMessage(ackErr)}`,
+            );
+          }
+          await strategy.abort(error);
+          return;
+        }
         await strategy.abort(error);
         throw dispatchErr;
       }

package/src/onboarding.ts

@@ -20,6 +20,10 @@ import type { DingTalkConfig, DingTalkChannelConfig } from "./types.js";
 
 const channel = "dingtalk" as const;
 
+type DingTalkSetupInput = ChannelSetupInput & {
+  password?: string;
+};
+
 function isConfigured(account: DingTalkConfig): boolean {
   return Boolean(account.clientId && hasConfiguredSecretInput(account.clientSecret));
 }
@@ -349,7 +353,7 @@ function applyAccountConfig(params: {
 function applyGenericSetupInput(params: {
   cfg: OpenClawConfig;
   accountId: string;
-  input: ChannelSetupInput;
+  input: DingTalkSetupInput;
 }): OpenClawConfig {
   return applyAccountConfig({
     cfg: params.cfg,
@@ -547,7 +551,7 @@ export const dingtalkSetupAdapter: ChannelSetupAdapter = {
     applyGenericSetupInput({
       cfg,
       accountId,
-      input,
+      input: input as DingTalkSetupInput,
     }),
 };
 

package/src/targeting/agent-routing.ts

@@ -20,9 +20,11 @@ import type {
   HandleDingTalkMessageParams,
   Logger,
   MessageContent,
+  ResolvedDingTalkRoute,
 } from "../types";
 import { getErrorMessage } from "../utils";
 import { resolveAtAgents } from "./agent-name-matcher";
+import type { ResolvedDingTalkSessionPeer } from "../session-routing";
 
 export class HostRoutingHelperUnavailableError extends Error {
   constructor(
@@ -84,6 +86,11 @@ export type MessageTarget =
     }
   | { kind: "subagent-command"; agent: AgentNameMatch; commandText: string };
 
+export interface ResolvedSubAgentTarget {
+  agent: AgentNameMatch;
+  route: ResolvedDingTalkRoute;
+}
+
 /**
  * Resolve how an inbound message should be routed.
  *
@@ -198,6 +205,8 @@ export async function dispatchSubAgents(params: {
   dingtalkConfig: DingTalkConfig;
   sessionWebhook: string;
   extractedContent: MessageContent;
+  sessionPeer: ResolvedDingTalkSessionPeer;
+  onRoutesResolved?: (targets: readonly ResolvedSubAgentTarget[]) => void;
   handleMessage: (params: HandleDingTalkMessageParams) => Promise<void>;
   downloadMedia: (
     config: DingTalkConfig,
@@ -205,6 +214,15 @@ export async function dispatchSubAgents(params: {
     log?: Logger,
   ) => Promise<{ path: string; mimeType: string } | null>;
   log?: Logger;
+  /**
+   * Whether the recursive sub-agent handler invocations should participate in
+   * the handler-owned inbound session queue. Propagated from the parent
+   * handler's `inboundQueueEligible` so `@子Agent` messages reuse the same
+   * serialization path and avoid reply-session conflicts on the sub-agent's
+   * own `target.route.sessionKey`. Default false preserves the legacy
+   * direct-dispatch behavior for synthetic callers that did not opt in.
+   */
+  inboundQueueEligible?: boolean;
 }): Promise<void> {
   const {
     matchedAgents,
@@ -215,11 +233,65 @@ export async function dispatchSubAgents(params: {
     dingtalkConfig,
     sessionWebhook,
     extractedContent,
+    sessionPeer,
+    onRoutesResolved,
     handleMessage,
     downloadMedia: download,
     log,
+    inboundQueueEligible,
   } = params;
 
+  let helperMissingWarningSent = false;
+  const sendHelperMissingWarning = async (): Promise<void> => {
+    if (helperMissingWarningSent) {
+      return;
+    }
+    helperMissingWarningSent = true;
+    try {
+      const isGroup = data.conversationType !== "1";
+      const sendOptions = isGroup ? { atUserId: data.senderId, log } : { log };
+      await sendBySession(
+        dingtalkConfig,
+        sessionWebhook,
+        "⚠️ 当前宿主版本不支持 DingTalk 子助手路由所需的 session helper，请升级 OpenClaw 后重试。",
+        sendOptions,
+      );
+    } catch (notifyError: unknown) {
+      log?.debug?.(
+        `[DingTalk] Failed to send sub-agent helper-missing notice: ${getErrorMessage(notifyError)}`,
+      );
+    }
+  };
+
+  let resolvedTargets: ResolvedSubAgentTarget[];
+  try {
+    const rt = getDingTalkRuntime();
+    resolvedTargets = matchedAgents.map((agent) => ({
+      agent,
+      route: {
+        agentId: agent.agentId,
+        sessionKey: buildAgentSessionKey({
+          rt,
+          cfg,
+          accountId,
+          agentId: agent.agentId,
+          peerKind: sessionPeer.kind,
+          peerId: sessionPeer.peerId,
+        }),
+        mainSessionKey: "",
+      },
+    }));
+  } catch (error) {
+    const message = getErrorMessage(error);
+    log?.error?.(`[DingTalk] Failed to resolve sub-agent routes: ${message}`);
+    if (error instanceof HostRoutingHelperUnavailableError) {
+      await sendHelperMissingWarning();
+      return;
+    }
+    throw error;
+  }
+  onRoutesResolved?.(resolvedTargets);
+
   // Pre-download media once to avoid duplication across sub-agents
   let preDownloadedMedia:
     | {
@@ -255,9 +327,8 @@ export async function dispatchSubAgents(params: {
       };
     }
   }
-  let helperMissingWarningSent = false;
-
-  for (const agentMatch of matchedAgents) {
+  for (const target of resolvedTargets) {
+    const agentMatch = target.agent;
     try {
       await handleMessage({
         cfg,
@@ -266,6 +337,7 @@ export async function dispatchSubAgents(params: {
         sessionWebhook,
         log,
         dingtalkConfig,
+        routeOverride: target.route,
         subAgentOptions: {
           agentId: agentMatch.agentId,
           responsePrefix: commandText
@@ -275,26 +347,19 @@ export async function dispatchSubAgents(params: {
           commandText,
         },
         preDownloadedMedia,
+        // Propagate queue eligibility so each recursive sub-agent handler
+        // enters the handler-owned queue on its own `target.route.sessionKey`
+        // instead of bypassing it (which previously left @子Agent messages
+        // exposed to reply-session conflicts when the sub-agent session was
+        // already busy). Synthetic callers without this flag keep the legacy
+        // direct-dispatch behavior.
+        inboundQueueEligible,
       });
     } catch (error) {
       const message = getErrorMessage(error);
       log?.error?.(`[DingTalk] Sub-agent ${agentMatch.agentId} failed: ${message}`);
-      if (error instanceof HostRoutingHelperUnavailableError && !helperMissingWarningSent) {
-        helperMissingWarningSent = true;
-        try {
-          const isGroup = data.conversationType !== "1";
-          const sendOptions = isGroup ? { atUserId: data.senderId, log } : { log };
-          await sendBySession(
-            dingtalkConfig,
-            sessionWebhook,
-            "⚠️ 当前宿主版本不支持 DingTalk 子助手路由所需的 session helper，请升级 OpenClaw 后重试。",
-            sendOptions,
-          );
-        } catch (notifyError: unknown) {
-          log?.debug?.(
-            `[DingTalk] Failed to send sub-agent helper-missing notice: ${getErrorMessage(notifyError)}`,
-          );
-        }
+      if (error instanceof HostRoutingHelperUnavailableError) {
+        await sendHelperMissingWarning();
       }
     }
   }