@soimy/dingtalk 3.6.7 → 3.6.9

package/src/inbound-handler.ts

@@ -34,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 {
@@ -60,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";
@@ -571,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,
@@ -880,6 +886,7 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
         handleMessage: handleDingTalkMessage,
         downloadMedia,
         log,
+        inboundQueueEligible: params.inboundQueueEligible,
       });
       return;
     }
@@ -914,6 +921,7 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
         handleMessage: handleDingTalkMessage,
         downloadMedia,
         log,
+        inboundQueueEligible: params.inboundQueueEligible,
       });
       return;
     }
@@ -999,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,
@@ -1092,7 +1138,7 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
     };
   }
 
-  if (useCardMode && !isBtwBypass) {
+  if (useCardMode && !isBtwBypass && !params.preCreatedCard) {
     const key = `${accountId}:${to}`;
     if (cardCreationInFlight.has(key)) {
       useCardMode = false;
@@ -1115,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) {
@@ -1830,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}`,
       );
@@ -2298,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: {
@@ -2347,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
@@ -2394,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

@@ -214,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,
@@ -229,6 +238,7 @@ export async function dispatchSubAgents(params: {
     handleMessage,
     downloadMedia: download,
     log,
+    inboundQueueEligible,
   } = params;
 
   let helperMissingWarningSent = false;
@@ -337,6 +347,13 @@ 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);

package/src/types.ts

@@ -484,6 +484,12 @@ export interface HandleDingTalkMessageParams {
   dingtalkConfig: DingTalkConfig;
   /** Distinguishes real Stream messages from Ask User callback reinjection. */
   inboundOrigin?: "stream" | "ask-user";
+  /**
+   * Explicitly enables handler-owned queueing for a real gateway Stream
+   * callback. Direct/synthetic callers must not be inferred from raw message
+   * shape, because they may already be inside another handler lifecycle.
+   */
+  inboundQueueEligible?: boolean;
   /** Reuses an already-resolved trusted route for recursive or synthetic handling. */
   routeOverride?: ResolvedDingTalkRoute;
   /**
@@ -501,6 +507,22 @@ export interface HandleDingTalkMessageParams {
     mediaPaths?: string[];
     mediaTypes?: string[];
   };
+  /**
+   * A pre-created AI Card to reuse instead of creating a new one. Set by the
+   * inbound session-queue dispatcher when a message was queued behind an active
+   * run: the card was already created and is showing a "已排队" acknowledgement,
+   * so the handler streams the real reply INTO this same card (in-place update)
+   * rather than spawning a second card. When unset, the handler creates a fresh
+   * card as usual.
+   */
+  preCreatedCard?: AICardInstance;
+  /**
+   * Internal recursion guard for the authorized inbound session queue. The
+   * first handler pass performs access control and trusted route resolution;
+   * the queued continuation re-enters with this set so it can consume the
+   * pre-created card without queueing itself again.
+   */
+  inboundQueueHandled?: boolean;
 }
 
 /**