@soimy/dingtalk 3.6.7 → 3.6.8

package/dist/index.js

@@ -2681,7 +2681,7 @@ function normalizePendingState(parsed) {
     updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : Date.now(),
     pendingCards: records2.filter(
       (entry) => Boolean(
-        entry && typeof entry.accountId === "string" && typeof entry.cardInstanceId === "string" && (entry.outTrackId === void 0 || typeof entry.outTrackId === "string") && typeof entry.conversationId === "string" && (entry.lastContent === void 0 || typeof entry.lastContent === "string") && (entry.lastBlockListJson === void 0 || typeof entry.lastBlockListJson === "string") && (entry.streamLifecycleOpened === void 0 || typeof entry.streamLifecycleOpened === "boolean")
+        entry && typeof entry.accountId === "string" && typeof entry.cardInstanceId === "string" && (entry.outTrackId === void 0 || typeof entry.outTrackId === "string") && (entry.processQueryKey === void 0 || typeof entry.processQueryKey === "string") && typeof entry.conversationId === "string" && (entry.lastContent === void 0 || typeof entry.lastContent === "string") && (entry.lastBlockListJson === void 0 || typeof entry.lastBlockListJson === "string") && (entry.streamLifecycleOpened === void 0 || typeof entry.streamLifecycleOpened === "boolean") && (entry.recoveryAction === void 0 || entry.recoveryAction === "finalize" || entry.recoveryAction === "recall")
       )
     )
   };
@@ -2738,6 +2738,7 @@ function upsertPendingCard(card, storePath, log) {
     accountId: card.accountId,
     cardInstanceId: card.cardInstanceId,
     outTrackId: card.outTrackId,
+    processQueryKey: card.processQueryKey,
     conversationId: card.conversationId,
     contextConversationId: card.contextConversationId,
     createdAt: card.createdAt,
@@ -2800,6 +2801,28 @@ function removePendingCardById(cardInstanceId, storePath, log) {
   state.updatedAt = Date.now();
   writePendingCardState(state, storePath, log);
 }
+function retainPendingCardForRecovery(card, recoveryAction, log) {
+  if (!card.accountId || !card.storePath) {
+    return;
+  }
+  const state = readPendingCardState(card.storePath, log);
+  const index = state.pendingCards.findIndex((item) => item.cardInstanceId === card.cardInstanceId);
+  if (index < 0) {
+    return;
+  }
+  const existing = state.pendingCards[index];
+  state.pendingCards[index] = {
+    ...existing,
+    state: AICardStatus.FAILED,
+    lastUpdated: Date.now(),
+    lastContent: card.lastStreamedContent ?? existing.lastContent,
+    lastBlockListJson: card.lastBlockListJson ?? existing.lastBlockListJson,
+    streamLifecycleOpened: card.streamLifecycleOpened,
+    recoveryAction
+  };
+  state.updatedAt = Date.now();
+  writePendingCardState(state, card.storePath, log);
+}
 function listPendingCardsByAccount(accountId, storePath, log) {
   const state = readPendingCardState(storePath, log);
   return state.pendingCards.filter((item) => item.accountId === accountId);
@@ -2827,6 +2850,37 @@ async function ensureFreshToken(card, log) {
     }
   }
 }
+async function sendTemplateMismatchNotification(card, text, log) {
+  const config = card.config;
+  if (!config) {
+    return;
+  }
+  try {
+    const token = await getAccessToken(config, log);
+    const { targetId, isExplicitUser } = stripTargetPrefix(card.conversationId);
+    const resolvedTarget = resolveOriginalPeerId(targetId);
+    const isGroup = !isExplicitUser && resolvedTarget.startsWith("cid");
+    const url = isGroup ? "https://api.dingtalk.com/v1.0/robot/groupMessages/send" : "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend";
+    const payload = {
+      robotCode: resolveRobotCode(config),
+      msgKey: "sampleMarkdown",
+      msgParam: JSON.stringify({ title: "OpenClaw \u63D0\u9192", text })
+    };
+    if (isGroup) {
+      payload.openConversationId = resolvedTarget;
+    } else {
+      payload.userIds = [resolvedTarget];
+    }
+    await http_client_default({
+      url,
+      method: "POST",
+      data: payload,
+      headers: { "x-acs-dingtalk-access-token": token, "Content-Type": "application/json" }
+    });
+  } catch (sendErr) {
+    log?.warn?.(`[DingTalk][AICard] Failed to send error notification to user: ${sendErr.message}`);
+  }
+}
 async function sendProactiveCardText(config, conversationId, content, log) {
   try {
     const card = await createAICard(config, conversationId, log, { persistPending: false });
@@ -2867,7 +2921,7 @@ async function finalizePendingCardsByAccount(config, accountId, reason, storePat
     return 0;
   }
   const pendingCards = listPendingCardsByAccount(accountId, storePath, log).filter(
-    (item) => !isCardInTerminalState(item.state)
+    (item) => item.recoveryAction === "recall" && mode === "recover" || item.recoveryAction !== "recall" && (!isCardInTerminalState(item.state) || item.recoveryAction === "finalize")
   );
   if (pendingCards.length === 0) {
     return 0;
@@ -2892,6 +2946,7 @@ async function finalizePendingCardsByAccount(config, accountId, reason, storePat
       accountId: entry.accountId,
       storePath,
       outTrackId: entry.outTrackId,
+      processQueryKey: entry.processQueryKey,
       createdAt: entry.createdAt || Date.now(),
       lastUpdated: entry.lastUpdated || Date.now(),
       state: normalizeRecoveredState(entry.state),
@@ -2901,6 +2956,12 @@ async function finalizePendingCardsByAccount(config, accountId, reason, storePat
       streamLifecycleOpened: entry.streamLifecycleOpened
     };
     try {
+      if (entry.recoveryAction === "recall") {
+        if (await recallAICardMessage(card, log)) {
+          finalizedCount += 1;
+        }
+        continue;
+      }
       await finalizeStoppedAICard(card, {
         reason,
         previousContent: entry.lastContent,
@@ -3177,6 +3238,9 @@ async function commitAICardBlocks(card, options, log) {
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     log?.error?.(`[DingTalk][AICard] Finalize via instances API failed: ${message}`);
+    card.state = AICardStatus.FAILED;
+    card.lastUpdated = Date.now();
+    retainPendingCardForRecovery(card, "finalize", log);
     throw err;
   }
   if (card.conversationId && options.content.trim() && card.accountId && card.processQueryKey) {
@@ -3196,6 +3260,35 @@ async function commitAICardBlocks(card, options, log) {
   removePendingCard(card, log);
   log?.info?.(`[DingTalk][AICard] Card finalized: outTrackId=${card.outTrackId || card.cardInstanceId} state=FINISHED`);
 }
+async function streamAICard(card, content, finished = false, log, options = {}) {
+  if (isCardInTerminalState(card.state)) {
+    log?.debug?.(
+      `[DingTalk][AICard] Skip stream update because card already terminal: outTrackId=${card.cardInstanceId} state=${card.state}`
+    );
+    return;
+  }
+  const template = DINGTALK_CARD_TEMPLATE;
+  try {
+    await putAICardStreamingField(card, template.contentKey, content, finished, log);
+    card.lastStreamedContent = content;
+    if (finished) {
+      card.state = AICardStatus.FINISHED;
+      removePendingCard(card, log);
+    } else if (card.state === AICardStatus.PROCESSING) {
+      card.state = AICardStatus.INPUTING;
+      upsertPendingCard(card, card.storePath, log);
+    }
+  } catch (err) {
+    card.state = AICardStatus.FAILED;
+    card.lastUpdated = Date.now();
+    retainPendingCardForRecovery(card, options.recoveryAction ?? "finalize", log);
+    if (err.response?.status === 500 && err.response?.data?.code === "unknownError") {
+      const errorMsg = "\u26A0\uFE0F **[DingTalk] AI Card \u4E32\u6D41\u66F4\u65B0\u5931\u8D25 (500 unknownError)**\n\n\u8FD9\u901A\u5E38\u8868\u793A\u5F53\u524D\u5185\u7F6E\u6A21\u677F\u5951\u7EA6\u4E0E\u9489\u9489\u4FA7\u6A21\u677F\u5B57\u6BB5\u4E0D\u4E00\u81F4\uFF0C\u5F53\u524D\u53CA\u540E\u7EED\u6D88\u606F\u5C06\u81EA\u52A8\u56DE\u9000\u4E3A Markdown \u53D1\u9001\u3002";
+      await sendTemplateMismatchNotification(card, errorMsg, log);
+    }
+    throw err;
+  }
+}
 function getCardRecallTarget(card) {
   const { targetId, isExplicitUser } = stripTargetPrefix(card.conversationId);
   const resolvedTarget = resolveOriginalPeerId(targetId);
@@ -4944,6 +5037,130 @@ async function handleInboundCommandDispatch(params) {
   return false;
 }
 
+// src/gateway/inbound-session-queue.ts
+var SESSION_QUEUE_TTL_MS = 5 * 60 * 1e3;
+var SESSION_QUEUE_CLEANUP_INTERVAL_MS = 60 * 1e3;
+var MAX_INBOUND_SESSION_QUEUE_DEPTH = 8;
+var MAX_INBOUND_SESSION_QUEUE_WAIT_MS = 15 * 60 * 1e3;
+var sessionQueues = /* @__PURE__ */ new Map();
+var sessionLastActivity = /* @__PURE__ */ new Map();
+var sessionQueueDepths = /* @__PURE__ */ new Map();
+var cleanupTimer = null;
+var InboundSessionQueueWaitTimeoutError = class extends Error {
+  constructor(queueKey) {
+    super(`Inbound session queue wait timed out for ${queueKey}`);
+    this.name = "InboundSessionQueueWaitTimeoutError";
+  }
+};
+function ensureCleanupTimer() {
+  if (cleanupTimer) {
+    return;
+  }
+  cleanupTimer = setInterval(() => {
+    const now2 = Date.now();
+    for (const [key, lastSeen] of sessionLastActivity) {
+      if (now2 - lastSeen > SESSION_QUEUE_TTL_MS && !sessionQueues.has(key)) {
+        sessionLastActivity.delete(key);
+      }
+    }
+  }, SESSION_QUEUE_CLEANUP_INTERVAL_MS);
+  if (typeof cleanupTimer?.unref === "function") {
+    cleanupTimer.unref();
+  }
+}
+function isInboundSessionQueueBusy(queueKey) {
+  return sessionQueues.has(queueKey);
+}
+function getInboundSessionQueueDepth(queueKey) {
+  return sessionQueueDepths.get(queueKey) ?? 0;
+}
+function chainInboundSessionTask(queueKey, task, options = {}) {
+  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;
+  let resolveWaitingCaller;
+  let rejectWaitingCaller;
+  const maxQueueWaitMs = Math.max(0, options.maxQueueWaitMs ?? 0);
+  const caller = maxQueueWaitMs > 0 && hadPriorTask ? new Promise((resolve3, reject) => {
+    resolveWaitingCaller = resolve3;
+    rejectWaitingCaller = reject;
+    timeout = setTimeout(() => {
+      timedOut = true;
+      reject(new InboundSessionQueueWaitTimeoutError(queueKey));
+    }, maxQueueWaitMs);
+    if (typeof timeout.unref === "function") {
+      timeout.unref();
+    }
+  }) : void 0;
+  if (caller) {
+    void caller.catch(() => void 0);
+  }
+  const current = previousTail.then(() => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = void 0;
+    }
+    if (timedOut) {
+      throw new InboundSessionQueueWaitTimeoutError(queueKey);
+    }
+    return task();
+  });
+  const tail = current.then(
+    () => void 0,
+    () => {
+    }
+  );
+  sessionQueues.set(queueKey, tail);
+  const cleanup = () => {
+    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);
+      }
+      resolveWaitingCaller?.(value);
+    },
+    (error) => {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      rejectWaitingCaller?.(error);
+    }
+  );
+  return caller;
+}
+var QUEUE_BUSY_ACK_PHRASES = [
+  "\u4E0A\u4E00\u6761\u8FD8\u6CA1\u7ED3\u675F\uFF0C\u8FD9\u6761\u6211\u5DF2\u7ECF\u8BB0\u4E0B\uFF0C\u7A0D\u540E\u6309\u987A\u5E8F\u7EE7\u7EED\u5904\u7406\u3002",
+  "\u5F53\u524D\u8FD8\u5728\u5FD9\uFF0C\u4F60\u7684\u65B0\u6D88\u606F\u5DF2\u7ECF\u6392\u961F\uFF0C\u4E0A\u4E00\u6761\u5B8C\u6210\u540E\u6211\u9A6C\u4E0A\u7EE7\u7EED\u3002",
+  "\u6211\u8FD9\u8FB9\u8FD8\u5728\u5904\u7406\u4E0A\u4E00\u6761\uFF0C\u8FD9\u6761\u5DF2\u52A0\u5165\u961F\u5217\uFF0C\u5B8C\u6210\u540E\u7EE7\u7EED\u5904\u7406\u3002"
+];
+function pickQueueBusyAckPhrase(seed) {
+  const list = QUEUE_BUSY_ACK_PHRASES;
+  const index = seed === void 0 ? Math.floor(Math.random() * list.length) : seed % list.length;
+  return list[index];
+}
+
+// src/send-service.ts
+import * as path6 from "node:path";
+
 // src/media-utils.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import * as os4 from "node:os";
@@ -6217,96 +6434,6 @@ function extractMessageContent(data) {
   };
 }
 
-// src/messaging/attachment-text-extractor.ts
-import fs4 from "node:fs/promises";
-import path6 from "node:path";
-var MAX_EXTRACTED_TEXT_CHARS = 6e3;
-var MAX_ATTACHMENT_EXTRACT_BYTES = 2 * 1024 * 1024;
-async function isFileTooLarge(filePath) {
-  const stat = await fs4.stat(filePath);
-  return stat.size > MAX_ATTACHMENT_EXTRACT_BYTES;
-}
-function isTextLikeMimeType(mimeType) {
-  if (!mimeType) {
-    return false;
-  }
-  return mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/xml" || mimeType === "application/javascript";
-}
-function normalizeWhitespace(text) {
-  return text.replace(/\r\n/g, "\n").split("\0").join("").replace(/[ \t]{2,}/g, " ").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
-}
-function limitExtractedText(text) {
-  const normalized = normalizeWhitespace(text);
-  if (!normalized) {
-    return null;
-  }
-  const truncated = normalized.length > MAX_EXTRACTED_TEXT_CHARS;
-  const limited = truncated ? `${normalized.slice(0, MAX_EXTRACTED_TEXT_CHARS)}
-
-[\u5185\u5BB9\u5DF2\u622A\u65AD]` : normalized;
-  return {
-    text: limited,
-    truncated,
-    sourceType: "text"
-  };
-}
-function stripHtml(html) {
-  return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&amp;/gi, "&").replace(/&#39;/gi, "'").replace(/&quot;/gi, '"');
-}
-async function extractTextLikeFile(filePath) {
-  const raw = await fs4.readFile(filePath, "utf8");
-  return limitExtractedText(raw);
-}
-async function extractPdf(filePath) {
-  const pdfParseModule = await import("pdf-parse");
-  const fileBuffer = await fs4.readFile(filePath);
-  const parser = new pdfParseModule.PDFParse({ data: new Uint8Array(fileBuffer) });
-  try {
-    const result = await parser.getText();
-    const limited = limitExtractedText(result.text || "");
-    return limited ? { ...limited, sourceType: "pdf" } : null;
-  } finally {
-    await parser.destroy();
-  }
-}
-async function extractDocx(filePath) {
-  const mammothModule = await import("mammoth");
-  const result = await mammothModule.extractRawText({ path: filePath });
-  const limited = limitExtractedText(result.value || "");
-  return limited ? { ...limited, sourceType: "docx" } : null;
-}
-async function extractHtml(filePath) {
-  const raw = await fs4.readFile(filePath, "utf8");
-  const limited = limitExtractedText(stripHtml(raw));
-  return limited ? { ...limited, sourceType: "html" } : null;
-}
-async function extractAttachmentText(input) {
-  const mimeType = input.mimeType?.toLowerCase();
-  const fileName = (input.fileName || path6.basename(input.path)).toLowerCase();
-  if (mimeType?.startsWith("image/") || mimeType?.startsWith("audio/") || mimeType?.startsWith("video/")) {
-    return null;
-  }
-  if (await isFileTooLarge(input.path)) {
-    return null;
-  }
-  if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || fileName.endsWith(".docx")) {
-    return extractDocx(input.path);
-  }
-  if (mimeType === "application/pdf" || fileName.endsWith(".pdf")) {
-    return extractPdf(input.path);
-  }
-  if (mimeType === "text/html" || mimeType === "application/xhtml+xml" || fileName.endsWith(".html") || fileName.endsWith(".htm")) {
-    return extractHtml(input.path);
-  }
-  if (isTextLikeMimeType(mimeType) || fileName.endsWith(".txt") || fileName.endsWith(".md") || fileName.endsWith(".markdown") || fileName.endsWith(".csv") || fileName.endsWith(".json") || fileName.endsWith(".xml") || fileName.endsWith(".log")) {
-    return extractTextLikeFile(input.path);
-  }
-  return null;
-}
-
-// src/send-service.ts
-import * as path7 from "node:path";
-
 // src/proactive-risk-registry.ts
 var DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var store = /* @__PURE__ */ new Map();
@@ -6694,9 +6821,9 @@ async function sendProactiveMedia(config, target, mediaPath, mediaType, options
       const durationMs = uploadedDurationMs ?? await getVoiceDurationMs(mediaPath, mediaType, log, { preReadBuffer: buffer });
       msgParam = JSON.stringify({ mediaId, duration: String(durationMs) });
     } else {
-      const filename = path7.basename(mediaPath);
+      const filename = path6.basename(mediaPath);
       const defaultExt = mediaType === "video" ? "mp4" : "file";
-      const ext = path7.extname(mediaPath).slice(1) || defaultExt;
+      const ext = path6.extname(mediaPath).slice(1) || defaultExt;
       msgKey = "sampleFile";
       msgParam = JSON.stringify({ mediaId, fileName: filename, fileType: ext });
     }
@@ -6799,7 +6926,7 @@ async function sendMedia(config, target, mediaInput, options = {}) {
   let preparedMedia;
   try {
     preparedMedia = await prepareMediaInput(mediaInput, log, config.mediaUrlAllowlist);
-    const mediaPath = preparedMedia.cleanup ? preparedMedia.path : path7.resolve(process.cwd(), preparedMedia.path);
+    const mediaPath = preparedMedia.cleanup ? preparedMedia.path : path6.resolve(process.cwd(), preparedMedia.path);
     const mediaType = resolveOutboundMediaType({
       mediaType: options.mediaType,
       mediaPath,
@@ -6855,7 +6982,7 @@ async function sendBySession(config, sessionWebhook, text, options = {}) {
         mediaLocalRoots: options.mediaLocalRoots
       });
       if (uploadResult) {
-        const imageMarkdown = `![${path7.basename(options.mediaPath)}](${uploadResult.mediaId})`;
+        const imageMarkdown = `![${path6.basename(options.mediaPath)}](${uploadResult.mediaId})`;
         text = text ? `${text}
 
 ${imageMarkdown}` : imageMarkdown;
@@ -7038,6 +7165,284 @@ async function sendMessage(config, conversationId, text, options = {}) {
   }
 }
 
+// src/gateway/inbound-session-queue-dispatcher.ts
+var QUEUE_FULL_ACK = "\u5F53\u524D\u6D88\u606F\u8F83\u591A\uFF0C\u5DF2\u8FBE\u5230\u672C\u4F1A\u8BDD\u6392\u961F\u4E0A\u9650\uFF1B\u8BF7\u7B49\u5F85\u4E0A\u4E00\u8F6E\u5B8C\u6210\u540E\u518D\u53D1\u9001\u3002";
+var QUEUE_WAIT_TIMEOUT_ACK = "\u4E0A\u4E00\u8F6E\u5904\u7406\u65F6\u95F4\u8F83\u957F\uFF0C\u8FD9\u6761\u6D88\u606F\u672A\u6267\u884C\uFF1B\u8BF7\u7A0D\u540E\u91CD\u65B0\u53D1\u9001\u3002";
+var QUEUE_HANDLER_FAILURE_ACK = "\u672C\u6B21\u5904\u7406\u5F02\u5E38\uFF0C\u672A\u80FD\u5B8C\u6210\uFF1B\u8BF7\u7A0D\u540E\u91CD\u65B0\u53D1\u9001\u3002";
+var MIN_QUEUE_ACK_CARD_VISIBLE_MS = 750;
+var queuedAckVisibleAt = /* @__PURE__ */ new WeakMap();
+function shouldPrepareQueueAckCard(input) {
+  return input.dingtalkConfig.messageType === "card";
+}
+async function keepQueueAckCardVisible(card) {
+  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((resolve3) => setTimeout(resolve3, remainingMs));
+  }
+}
+async function settleUnusedQueueAckCard(input, card) {
+  if (isCardInTerminalState(card.state)) {
+    return;
+  }
+  try {
+    if (await recallAICardMessage(card, input.log)) {
+      return;
+    }
+  } catch (err) {
+    input.log?.warn?.(
+      `[DingTalk] Failed to recall unused queue acknowledgement card: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  await sendQueueTerminalAck(input, "\u5DF2\u7ED3\u675F\u6392\u961F\u786E\u8BA4\uFF0C\u8BF7\u4EE5\u672C\u6B21\u5B9E\u9645\u56DE\u590D\u4E3A\u51C6\u3002", card);
+}
+async function settleFailedQueueAckCard(input, card) {
+  if (isCardInTerminalState(card.state)) {
+    return;
+  }
+  await sendQueueTerminalAck(input, QUEUE_HANDLER_FAILURE_ACK, card);
+}
+async function dispatchInboundViaSessionQueue(input, handler) {
+  const queueKey = input.sessionKey;
+  if (!queueKey) {
+    return handler(void 0);
+  }
+  const wasBusy = isInboundSessionQueueBusy(queueKey);
+  if (getInboundSessionQueueDepth(queueKey) >= MAX_INBOUND_SESSION_QUEUE_DEPTH) {
+    await sendQueueTerminalAck(input, QUEUE_FULL_ACK);
+    return void 0;
+  }
+  let queuedAckState = "queued";
+  const preCreatedCardPromise = wasBusy && shouldPrepareQueueAckCard(input) ? tryPrepareQueueAckCard(
+    input,
+    () => queuedAckState === "timed-out" ? { content: QUEUE_WAIT_TIMEOUT_ACK, finished: true } : { content: pickQueueBusyAckPhrase(), finished: false }
+  ) : void 0;
+  try {
+    return await chainInboundSessionTask(
+      queueKey,
+      async () => {
+        const preCreatedCard = preCreatedCardPromise ? await preCreatedCardPromise : void 0;
+        if (!preCreatedCard) {
+          return handler(void 0);
+        }
+        await keepQueueAckCardVisible(preCreatedCard);
+        let handlerFailed = false;
+        try {
+          return await handler(preCreatedCard);
+        } catch (err) {
+          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 : void 0
+      }
+    );
+  } catch (err) {
+    if (err instanceof InboundSessionQueueWaitTimeoutError) {
+      queuedAckState = "timed-out";
+      await sendQueueTerminalAck(
+        input,
+        QUEUE_WAIT_TIMEOUT_ACK,
+        preCreatedCardPromise ? await preCreatedCardPromise : void 0
+      );
+      return void 0;
+    }
+    throw err;
+  }
+}
+async function tryPrepareQueueAckCard(input, ack) {
+  const { dingtalkConfig, data, log, to, storePath, quoteContent } = input;
+  if (!data) {
+    return void 0;
+  }
+  if (!to) {
+    return void 0;
+  }
+  let card = null;
+  let ackFinished = false;
+  try {
+    card = await createAICard(dingtalkConfig, to, log, {
+      accountId: input.accountId,
+      storePath,
+      quoteContent
+    });
+    if (!card) {
+      return void 0;
+    }
+    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;
+    }
+    void attachNativeAckReaction(
+      dingtalkConfig,
+      { msgId: data.msgId, conversationId: data.conversationId },
+      log
+    ).catch((err) => {
+      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) {
+    if (card && !ackFinished) {
+      try {
+        await recallAICardMessage(card, log);
+      } catch (recallErr) {
+        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 void 0;
+  }
+}
+async function sendQueueTerminalAck(input, content, preCreatedCard) {
+  const { dingtalkConfig, data, log, to, storePath } = input;
+  try {
+    if (preCreatedCard) {
+      try {
+        await streamAICard(preCreatedCard, content, true, log);
+        return;
+      } catch (err) {
+        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) {
+    log?.warn?.(
+      `[DingTalk] Queue terminal acknowledgement delivery failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
+// src/messaging/attachment-text-extractor.ts
+import fs4 from "node:fs/promises";
+import path7 from "node:path";
+var MAX_EXTRACTED_TEXT_CHARS = 6e3;
+var MAX_ATTACHMENT_EXTRACT_BYTES = 2 * 1024 * 1024;
+async function isFileTooLarge(filePath) {
+  const stat = await fs4.stat(filePath);
+  return stat.size > MAX_ATTACHMENT_EXTRACT_BYTES;
+}
+function isTextLikeMimeType(mimeType) {
+  if (!mimeType) {
+    return false;
+  }
+  return mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/xml" || mimeType === "application/javascript";
+}
+function normalizeWhitespace(text) {
+  return text.replace(/\r\n/g, "\n").split("\0").join("").replace(/[ \t]{2,}/g, " ").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function limitExtractedText(text) {
+  const normalized = normalizeWhitespace(text);
+  if (!normalized) {
+    return null;
+  }
+  const truncated = normalized.length > MAX_EXTRACTED_TEXT_CHARS;
+  const limited = truncated ? `${normalized.slice(0, MAX_EXTRACTED_TEXT_CHARS)}
+
+[\u5185\u5BB9\u5DF2\u622A\u65AD]` : normalized;
+  return {
+    text: limited,
+    truncated,
+    sourceType: "text"
+  };
+}
+function stripHtml(html) {
+  return html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&amp;/gi, "&").replace(/&#39;/gi, "'").replace(/&quot;/gi, '"');
+}
+async function extractTextLikeFile(filePath) {
+  const raw = await fs4.readFile(filePath, "utf8");
+  return limitExtractedText(raw);
+}
+async function extractPdf(filePath) {
+  const pdfParseModule = await import("pdf-parse");
+  const fileBuffer = await fs4.readFile(filePath);
+  const parser = new pdfParseModule.PDFParse({ data: new Uint8Array(fileBuffer) });
+  try {
+    const result = await parser.getText();
+    const limited = limitExtractedText(result.text || "");
+    return limited ? { ...limited, sourceType: "pdf" } : null;
+  } finally {
+    await parser.destroy();
+  }
+}
+async function extractDocx(filePath) {
+  const mammothModule = await import("mammoth");
+  const result = await mammothModule.extractRawText({ path: filePath });
+  const limited = limitExtractedText(result.value || "");
+  return limited ? { ...limited, sourceType: "docx" } : null;
+}
+async function extractHtml(filePath) {
+  const raw = await fs4.readFile(filePath, "utf8");
+  const limited = limitExtractedText(stripHtml(raw));
+  return limited ? { ...limited, sourceType: "html" } : null;
+}
+async function extractAttachmentText(input) {
+  const mimeType = input.mimeType?.toLowerCase();
+  const fileName = (input.fileName || path7.basename(input.path)).toLowerCase();
+  if (mimeType?.startsWith("image/") || mimeType?.startsWith("audio/") || mimeType?.startsWith("video/")) {
+    return null;
+  }
+  if (await isFileTooLarge(input.path)) {
+    return null;
+  }
+  if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" || fileName.endsWith(".docx")) {
+    return extractDocx(input.path);
+  }
+  if (mimeType === "application/pdf" || fileName.endsWith(".pdf")) {
+    return extractPdf(input.path);
+  }
+  if (mimeType === "text/html" || mimeType === "application/xhtml+xml" || fileName.endsWith(".html") || fileName.endsWith(".htm")) {
+    return extractHtml(input.path);
+  }
+  if (isTextLikeMimeType(mimeType) || fileName.endsWith(".txt") || fileName.endsWith(".md") || fileName.endsWith(".markdown") || fileName.endsWith(".csv") || fileName.endsWith(".json") || fileName.endsWith(".xml") || fileName.endsWith(".log")) {
+    return extractTextLikeFile(input.path);
+  }
+  return null;
+}
+
 // src/messaging/btw-deliver.ts
 var MAX_QUESTION_LENGTH = 80;
 var LEADING_MENTIONS_RE = /^(?:@\S+\s+)*/u;
@@ -7622,6 +8027,47 @@ async function resolveQuotedFile(config, params, log) {
   }
 }
 
+// src/gateway/reply-session-conflict.ts
+var REPLY_SESSION_CONFLICT_PATTERN = /reply session initialization conflicted/i;
+function readErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    const msg = error.message;
+    return typeof msg === "string" ? msg : "";
+  }
+  return "";
+}
+function isReplySessionConflictError(error) {
+  return REPLY_SESSION_CONFLICT_PATTERN.test(readErrorMessage(error));
+}
+var sleep = (ms) => new Promise((resolve3) => {
+  setTimeout(resolve3, ms);
+});
+async function withReplySessionConflictRetry(fn, options = {}) {
+  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);
+    }
+  }
+}
+
 // src/card/reasoning-answer-split.ts
 var THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/gi;
 function isWrappedReasoningLine(line) {
@@ -9793,7 +10239,8 @@ async function dispatchSubAgents(params) {
     onRoutesResolved,
     handleMessage,
     downloadMedia: download,
-    log
+    log,
+    inboundQueueEligible
   } = params;
   let helperMissingWarningSent = false;
   const sendHelperMissingWarning = async () => {
@@ -9885,7 +10332,14 @@ async function dispatchSubAgents(params) {
           matchedName: agentMatch.matchedName,
           commandText
         },
-        preDownloadedMedia
+        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);
@@ -10840,7 +11294,8 @@ async function handleDingTalkMessageInner(params) {
         onRoutesResolved: (targets) => invalidateQuestionRoutes(targets.map((target) => target.route)),
         handleMessage: handleDingTalkMessage,
         downloadMedia,
-        log
+        log,
+        inboundQueueEligible: params.inboundQueueEligible
       });
       return;
     }
@@ -10870,7 +11325,8 @@ async function handleDingTalkMessageInner(params) {
         onRoutesResolved: (targets) => invalidateQuestionRoutes(targets.map((target) => target.route)),
         handleMessage: handleDingTalkMessage,
         downloadMedia,
-        log
+        log,
+        inboundQueueEligible: params.inboundQueueEligible
       });
       return;
     }
@@ -10948,7 +11404,29 @@ async function handleDingTalkMessageInner(params) {
   const quotedRef = buildInboundQuotedRef(data, extractedContent);
   const replyQuotedRef = createReplyQuotedRef(data.msgId);
   const content = extractedContent;
-  const isBtwBypass = isBtwRequestText(stripLeadingMentions(content.text).trim());
+  const controlText = stripLeadingMentions(content.text).trim();
+  const isBtwBypass = isBtwRequestText(controlText);
+  const isAbortBypass = isAbortRequestText(controlText);
+  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,
@@ -11029,7 +11507,7 @@ async function handleDingTalkMessageInner(params) {
       return true;
     };
   }
-  if (useCardMode && !isBtwBypass) {
+  if (useCardMode && !isBtwBypass && !params.preCreatedCard) {
     const key = `${accountId}:${to}`;
     if (cardCreationInFlight.has(key)) {
       useCardMode = false;
@@ -11047,7 +11525,7 @@ async function handleDingTalkMessageInner(params) {
         `[DingTalk][AICard] conversationType=${data.conversationType}, conversationId=${to}`
       );
       const inboundQuoteText = rawInboundText.slice(0, 200);
-      const aiCard = await createAICard(dingtalkConfig, to, log, {
+      const aiCard = params.preCreatedCard ?? await createAICard(dingtalkConfig, to, log, {
         accountId,
         storePath: accountStorePath,
         contextConversationId: groupId,
@@ -11711,8 +12189,7 @@ ${attachmentExtractedText}` : inboundBody;
       }
     });
     log?.info?.(`[DingTalk] Inbound: from=${senderName} text="${content.text.slice(0, 50)}..."`);
-    const textForAbortCheck = stripLeadingMentions(inboundText).trim();
-    if (isAbortRequestText(textForAbortCheck)) {
+    if (isAbortBypass) {
       log?.info?.(
         `[DingTalk] Abort request detected, bypassing session lock for session=${route.sessionKey}`
       );
@@ -11973,53 +12450,57 @@ ${attachmentExtractedText}` : inboundBody;
         inboundText: rawInboundText,
         taskMeta
       });
-      try {
-        let deliveredFinalCount = 0;
-        const dispatchResult = await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-          ctx,
-          cfg,
-          dispatcherOptions: {
-            responsePrefix: subAgentOptions?.responsePrefix || "",
-            deliver: async (payload, info) => {
-              if (isCurrentCardStopRequested()) {
-                log?.debug?.(
-                  "[DingTalk][CardStop] Ignoring reply delivery because stop was already requested"
+      let deliveredFinalCount = 0;
+      const runDispatch = () => rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx,
+        cfg,
+        dispatcherOptions: {
+          responsePrefix: subAgentOptions?.responsePrefix || "",
+          deliver: async (payload, info) => {
+            if (isCurrentCardStopRequested()) {
+              log?.debug?.(
+                "[DingTalk][CardStop] Ignoring reply delivery because stop was already requested"
+              );
+              return;
+            }
+            try {
+              if (info?.kind === "final") {
+                deliveredFinalCount += 1;
+              }
+              const inlineReplyPayload = parseInlineReplyPayloadText(payload.text);
+              const mediaUrls = extractMediaUrls(payload, inlineReplyPayload);
+              const richPayload = payload;
+              const replyKind = info?.kind || "block";
+              if (questionCardTookOver) {
+                log?.info?.(
+                  `[DingTalk][AskUser] Suppressed ${replyKind} reply after question card took over`
                 );
                 return;
               }
-              try {
-                if (info?.kind === "final") {
-                  deliveredFinalCount += 1;
-                }
-                const inlineReplyPayload = parseInlineReplyPayloadText(payload.text);
-                const mediaUrls = extractMediaUrls(payload, inlineReplyPayload);
-                const richPayload = payload;
-                const replyKind = info?.kind || "block";
-                if (questionCardTookOver) {
-                  log?.info?.(
-                    `[DingTalk][AskUser] Suppressed ${replyKind} reply after question card took over`
-                  );
-                  return;
-                }
-                await strategy.deliver({
-                  text: inlineReplyPayload.text,
-                  mediaUrls,
-                  audioAsVoice: extractSharedAudioAsVoice(payload, inlineReplyPayload),
-                  kind: replyKind,
-                  isError: payload.isError === true,
-                  isReasoning: richPayload.isReasoning === true
-                });
-              } catch (err) {
-                log?.error?.(`[DingTalk] Reply failed: ${getErrorMessage(err)}`);
-                const responseData = getErrorResponseData(err);
-                if (responseData !== void 0) {
-                  log?.error?.(formatDingTalkErrorPayloadLog("inbound.replyDeliver", responseData));
-                }
-                throw err;
+              await strategy.deliver({
+                text: inlineReplyPayload.text,
+                mediaUrls,
+                audioAsVoice: extractSharedAudioAsVoice(payload, inlineReplyPayload),
+                kind: replyKind,
+                isError: payload.isError === true,
+                isReasoning: richPayload.isReasoning === true
+              });
+            } catch (err) {
+              log?.error?.(`[DingTalk] Reply failed: ${getErrorMessage(err)}`);
+              const responseData = getErrorResponseData(err);
+              if (responseData !== void 0) {
+                log?.error?.(formatDingTalkErrorPayloadLog("inbound.replyDeliver", responseData));
               }
+              throw err;
             }
-          },
-          replyOptions: strategy.getReplyOptions()
+          }
+        },
+        replyOptions: strategy.getReplyOptions()
+      });
+      try {
+        const dispatchResult = await withReplySessionConflictRetry(runDispatch, {
+          log,
+          sessionKey: route.sessionKey
         });
         const bufferedFinal = dispatchResult && typeof dispatchResult === "object" && "queuedFinal" in dispatchResult ? dispatchResult.queuedFinal : void 0;
         const finalCount = dispatchResult && typeof dispatchResult === "object" && "counts" in dispatchResult ? dispatchResult.counts?.final : void 0;
@@ -12049,6 +12530,51 @@ ${attachmentExtractedText}` : inboundBody;
         }
       } catch (dispatchErr) {
         const error = dispatchErr instanceof Error ? dispatchErr : new Error(getErrorMessage(dispatchErr));
+        if (isReplySessionConflictError(error)) {
+          log?.warn?.(
+            `[DingTalk] Reply session still conflicted after retries for session=${route.sessionKey}; sending "processing" acknowledgement instead of dropping the message.`
+          );
+          const ackText = "\u6536\u5230\uFF0C\u4E0A\u4E00\u8F6E\u8FD8\u5728\u5904\u7406\u4E2D\uFF0C\u8BF7\u7A0D\u5019\u518D\u8BD5\u3002";
+          if (replyMode === "card") {
+            try {
+              await strategy.deliver({
+                text: ackText,
+                mediaUrls: [],
+                kind: "final",
+                isReasoning: false
+              });
+              await strategy.finalize();
+              return;
+            } catch (cardAckErr) {
+              log?.warn?.(
+                `[DingTalk] Processing acknowledgement card finalize failed: ${getErrorMessage(cardAckErr)}`
+              );
+              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) {
+            log?.warn?.(
+              `[DingTalk] Processing acknowledgement delivery failed: ${getErrorMessage(ackErr)}`
+            );
+          }
+          await strategy.abort(error);
+          return;
+        }
         await strategy.abort(error);
         throw dispatchErr;
       }
@@ -13130,13 +13656,12 @@ function registerDingTalkAskUserQuestionTool(api) {
     api.logger?.warn?.(`${TOOL_NAME}: registerTool unavailable, skipping tool registration`);
     return;
   }
-  registerTool.call(api, {
+  const createTool = (context) => ({
     name: TOOL_NAME,
     label: "Ask User Question",
     description: "Ask the user a blocking question or collect structured input via an interactive DingTalk form card when the current task cannot continue without the user's answer. Returns immediately after sending the card. The user's answer will arrive as a new message in the conversation. Do NOT poll or re-call this tool \u2014 just wait for the response message. Use questions only for simple confirmation, single-select, multi-select, or simple free-text prompts. For simple selection questions, provide options; for simple free-text input, set options to an empty array. When collecting multiple missing values, when the user asks for a form, or when you would otherwise list required parameters for the user to fill, call this tool with top-level fields instead of replying with a markdown checklist. Do not call this tool for normal explanations, why/how questions, capability introductions, or cases where you can answer directly.",
     parameters: AskUserQuestionSchema,
     async execute(_toolCallId, params) {
-      const context = getDingTalkQuestionContext();
       if (!context) {
         return jsonToolResult({
           status: "failed",
@@ -13285,6 +13810,18 @@ function registerDingTalkAskUserQuestionTool(api) {
       });
     }
   });
+  registerTool.call(
+    api,
+    (toolContext) => {
+      const context = getDingTalkQuestionContext();
+      const runtimeSessionKey = toolContext.sessionKey?.trim();
+      const contextSessionKey = context?.resolvedRoute?.sessionKey.trim();
+      return createTool(
+        context && (!runtimeSessionKey || contextSessionKey === runtimeSessionKey) ? context : void 0
+      );
+    },
+    { name: TOOL_NAME }
+  );
   api.logger?.debug?.(`${TOOL_NAME}: registered tool`);
 }
 
@@ -14346,7 +14883,6 @@ function instrumentConnectionStages(client) {
     }
   };
 }
-var INFLIGHT_TTL_MS = 5 * 60 * 1e3;
 var processingDedupKeys = /* @__PURE__ */ new Map();
 var inboundCountersByAccount = /* @__PURE__ */ new Map();
 var INBOUND_COUNTER_LOG_EVERY = 10;
@@ -14490,7 +15026,9 @@ function createDingTalkGateway() {
                 data,
                 sessionWebhook: data.sessionWebhook,
                 log: pluginLog,
-                dingtalkConfig: config
+                dingtalkConfig: config,
+                inboundOrigin: "stream",
+                inboundQueueEligible: true
               });
               stats.processed += 1;
               if (stats.received % INBOUND_COUNTER_LOG_EVERY === 0) {
@@ -14505,22 +15043,14 @@ function createDingTalkGateway() {
               logInboundCounters(pluginLog, account.accountId, "dedup-skipped");
               return;
             }
-            const inflightSince = processingDedupKeys.get(dedupKey);
-            if (inflightSince !== void 0) {
-              if (Date.now() - inflightSince > INFLIGHT_TTL_MS) {
-                pluginLog?.warn?.(
-                  `[${account.accountId}] Releasing stale in-flight lock for ${dedupKey} (held ${Date.now() - inflightSince}ms > TTL ${INFLIGHT_TTL_MS}ms)`
-                );
-                processingDedupKeys.delete(dedupKey);
-              } else {
-                pluginLog?.debug?.(
-                  `[${account.accountId}] Skipping in-flight duplicate message: ${dedupKey}`
-                );
-                stats.inflightSkipped += 1;
-                acknowledge();
-                logInboundCounters(pluginLog, account.accountId, "inflight-skipped");
-                return;
-              }
+            if (processingDedupKeys.has(dedupKey)) {
+              pluginLog?.debug?.(
+                `[${account.accountId}] Skipping in-flight duplicate message: ${dedupKey}`
+              );
+              stats.inflightSkipped += 1;
+              acknowledge();
+              logInboundCounters(pluginLog, account.accountId, "inflight-skipped");
+              return;
             }
             acknowledge();
             processingDedupKeys.set(dedupKey, Date.now());
@@ -14531,7 +15061,9 @@ function createDingTalkGateway() {
                 data,
                 sessionWebhook: data.sessionWebhook,
                 log: pluginLog,
-                dingtalkConfig: config
+                dingtalkConfig: config,
+                inboundOrigin: "stream",
+                inboundQueueEligible: true
               });
               stats.processed += 1;
               markMessageProcessed(dedupKey);
@@ -14755,19 +15287,6 @@ function createDingTalkGateway() {
               lastError: null
             });
           } else if (state === "FAILED" /* FAILED */ || state === "DISCONNECTED" /* DISCONNECTED */) {
-            const robotKey = resolveRobotCode(config) || account.accountId;
-            let cleared = 0;
-            for (const key of processingDedupKeys.keys()) {
-              if (key.startsWith(`${robotKey}:`)) {
-                processingDedupKeys.delete(key);
-                cleared++;
-              }
-            }
-            if (cleared > 0) {
-              pluginLog?.info?.(
-                `[${account.accountId}] Cleared ${cleared} stale in-flight lock(s) on disconnect`
-              );
-            }
             applyStatusPatch({
               running: false,
               connected: false,
@@ -14908,13 +15427,13 @@ async function beginDeviceRegistration() {
     }) : null;
     abortPromise?.catch(() => {
     });
-    const sleep = () => new Promise((resolve3) => setTimeout(resolve3, interval * 1e3));
+    const sleep2 = () => new Promise((resolve3) => setTimeout(resolve3, interval * 1e3));
     try {
       while (Date.now() < deadline) {
         if (signal?.aborted) {
           throw new RegistrationError("registration cancelled");
         }
-        await (abortPromise ? Promise.race([sleep(), abortPromise]) : sleep());
+        await (abortPromise ? Promise.race([sleep2(), abortPromise]) : sleep2());
         if (signal?.aborted) {
           throw new RegistrationError("registration cancelled");
         }