@qwen-code/qwen-code 0.19.8 → 0.19.9-preview.0

package/chunks/{dist-Z34QPAQW.js → dist-WH4TZSH3.js}

@@ -4,26 +4,26 @@ import {
   require_follow_redirects,
   require_form_data,
   require_proxy_from_env
-} from "./chunk-QXPI7FEC.js";
-import "./chunk-7RYW5LQV.js";
+} from "./chunk-S3TWXGKA.js";
+import "./chunk-T2NCM2ET.js";
 import {
   ChannelBase,
   isTerminalTaskLifecycleType,
   sanitizeLogText,
   sanitizeSenderName
-} from "./chunk-IBY3Q3HG.js";
-import "./chunk-VRDMOSQS.js";
-import "./chunk-K5PGHDBN.js";
-import "./chunk-UWCTAVOD.js";
+} from "./chunk-AU4R7ACM.js";
+import "./chunk-UDXSXLER.js";
+import "./chunk-H6XPXXMH.js";
+import "./chunk-CR3C7WXL.js";
 import {
   wrapper_default
-} from "./chunk-H6BD2ELD.js";
-import "./chunk-5IFG2VC4.js";
-import "./chunk-QN5NZ3UQ.js";
-import "./chunk-BR4QREVK.js";
+} from "./chunk-TYAMGABM.js";
+import "./chunk-FCMNKVXT.js";
+import "./chunk-DMTGGOSA.js";
+import "./chunk-YQ3U5MUC.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __export,
   __name,
@@ -4305,57 +4305,6 @@ var DWClient = class extends EventEmitter2 {
 // packages/channels/dingtalk/dist/markdown.js
 init_esbuild_shims();
 var CHUNK_LIMIT = 3800;
-function isTableSeparator(line) {
-  const trimmed = line.trim();
-  if (!trimmed.includes("-"))
-    return false;
-  const cells = trimmed.replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
-  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
-}
-__name(isTableSeparator, "isTableSeparator");
-function isTableRow(line) {
-  const trimmed = line.trim();
-  return trimmed.includes("|") && !trimmed.startsWith("```");
-}
-__name(isTableRow, "isTableRow");
-function parseTableRow(line) {
-  return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
-}
-__name(parseTableRow, "parseTableRow");
-function renderTable(lines) {
-  const rows = lines.map(parseTableRow).filter((cells) => cells.length > 0);
-  return rows.map((cells) => cells.join(" | ")).join("  \n");
-}
-__name(renderTable, "renderTable");
-function convertTables(text) {
-  const lines = text.split("\n");
-  const output = [];
-  let i = 0;
-  let inCode = false;
-  while (i < lines.length) {
-    const line = lines[i] || "";
-    if (line.trim().startsWith("```")) {
-      inCode = !inCode;
-      output.push(line);
-      i++;
-      continue;
-    }
-    if (!inCode && i + 1 < lines.length && isTableRow(line) && isTableSeparator(lines[i + 1] || "")) {
-      const tableLines = [line];
-      i += 2;
-      while (i < lines.length && isTableRow(lines[i] || "")) {
-        tableLines.push(lines[i] || "");
-        i++;
-      }
-      output.push(renderTable(tableLines));
-      continue;
-    }
-    output.push(line);
-    i++;
-  }
-  return output.join("\n");
-}
-__name(convertTables, "convertTables");
 function splitChunks(text) {
   if (!text || text.length <= CHUNK_LIMIT) {
     return [text];
@@ -4432,7 +4381,7 @@ function extractTitle(text) {
 }
 __name(extractTitle, "extractTitle");
 function normalizeDingTalkMarkdown(text) {
-  return splitChunks(convertTables(text));
+  return splitChunks(text);
 }
 __name(normalizeDingTalkMarkdown, "normalizeDingTalkMarkdown");
 
@@ -4482,6 +4431,311 @@ async function downloadMedia(downloadCode, robotCode, accessToken) {
 }
 __name(downloadMedia, "downloadMedia");
 
+// packages/channels/dingtalk/dist/DingtalkConnectionManager.js
+init_esbuild_shims();
+var SOCKET_OPEN = 1;
+var CONNECT_TIMEOUT_MS = 1e4;
+var READY_POLL_MS = 100;
+var HEARTBEAT_INTERVAL_MS = 2e4;
+var MAX_HEARTBEAT_MISSES = 2;
+var HEALTH_INTERVAL_MS = 6e4;
+var MAX_HEALTH_FAILURES = 2;
+var INITIAL_RECONNECT_DELAY_MS = 1e3;
+var MAX_RECONNECT_DELAY_MS = 3e4;
+var DingtalkConnectionManager = class {
+  static {
+    __name(this, "DingtalkConnectionManager");
+  }
+  options;
+  running = false;
+  generation = 0;
+  hasStarted = false;
+  startingGeneration;
+  activeClient;
+  readyTimer;
+  resolveReadyDelay;
+  heartbeatTimer;
+  heartbeatMisses = 0;
+  activitySinceHeartbeat = false;
+  healthTimer;
+  healthFailures = 0;
+  reconnectTask;
+  reconnectGeneration;
+  socketCleanup;
+  retryTimer;
+  resolveRetryDelay;
+  cancelConnectionAttempts = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.options = options;
+    this.activeClient = options.initialClient;
+  }
+  async start() {
+    if (this.running) {
+      return;
+    }
+    const client = this.hasStarted ? this.options.createClient() : this.activeClient;
+    this.hasStarted = true;
+    this.activeClient = client;
+    this.running = true;
+    const generation = ++this.generation;
+    this.startingGeneration = generation;
+    try {
+      await this.connectClient(client, generation);
+      this.options.onClientChanged(client);
+      this.startMonitoring(client);
+    } catch (error) {
+      if (this.running && generation === this.generation) {
+        this.safeDisconnect(client, "startup client");
+        this.running = false;
+        this.generation++;
+        this.stopMonitoring();
+        this.cancelReadyDelay();
+        this.cancelRetryDelay();
+      }
+      throw error;
+    } finally {
+      if (this.startingGeneration === generation) {
+        this.startingGeneration = void 0;
+      }
+    }
+  }
+  noteActivity(client) {
+    if (!this.running || client !== this.activeClient) {
+      return;
+    }
+    this.activitySinceHeartbeat = true;
+    this.heartbeatMisses = 0;
+  }
+  requestReconnect(client, reason) {
+    const generation = this.generation;
+    if (!this.running || client !== this.activeClient || this.startingGeneration === generation || this.reconnectTask && this.reconnectGeneration === generation) {
+      return;
+    }
+    const task = this.reconnect(reason, generation);
+    this.reconnectTask = task;
+    this.reconnectGeneration = generation;
+    void task.catch((error) => {
+      this.options.log(`reconnect failed: ${String(error)}`);
+    }).finally(() => {
+      if (this.reconnectTask === task) {
+        this.reconnectTask = void 0;
+        this.reconnectGeneration = void 0;
+      }
+    });
+  }
+  stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    this.generation++;
+    this.startingGeneration = void 0;
+    this.reconnectTask = void 0;
+    this.reconnectGeneration = void 0;
+    this.stopMonitoring();
+    this.cancelReadyDelay();
+    this.cancelRetryDelay();
+    for (const cancel of this.cancelConnectionAttempts) {
+      cancel();
+    }
+    this.cancelConnectionAttempts.clear();
+    this.safeDisconnect(this.activeClient, "active client");
+  }
+  startMonitoring(client) {
+    this.stopMonitoring();
+    this.activitySinceHeartbeat = true;
+    this.heartbeatMisses = 0;
+    this.healthFailures = 0;
+    const socket = this.options.getSocket(client);
+    if (socket) {
+      const onPong = /* @__PURE__ */ __name(() => this.noteActivity(client), "onPong");
+      const onClose = /* @__PURE__ */ __name(() => this.requestReconnect(client, "socket closed"), "onClose");
+      const onError = /* @__PURE__ */ __name(() => this.requestReconnect(client, "socket error"), "onError");
+      socket.on("pong", onPong);
+      socket.on("close", onClose);
+      socket.on("error", onError);
+      this.socketCleanup = () => {
+        socket.off("pong", onPong);
+        socket.off("close", onClose);
+        socket.off("error", onError);
+      };
+    }
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.running || client !== this.activeClient) {
+        return;
+      }
+      if (this.activitySinceHeartbeat) {
+        this.activitySinceHeartbeat = false;
+        this.heartbeatMisses = 0;
+      } else {
+        this.heartbeatMisses++;
+      }
+      if (this.heartbeatMisses >= MAX_HEARTBEAT_MISSES) {
+        this.requestReconnect(client, "heartbeat timeout");
+        return;
+      }
+      const socket2 = this.options.getSocket(client);
+      if (!socket2 || socket2.readyState !== SOCKET_OPEN) {
+        this.requestReconnect(client, "socket is not open");
+        return;
+      }
+      try {
+        socket2.ping();
+      } catch (error) {
+        this.requestReconnect(client, `socket ping failed: ${String(error)}`);
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+    this.healthTimer = setInterval(() => {
+      if (!this.running || client !== this.activeClient) {
+        return;
+      }
+      if (client.connected && this.options.getSocket(client)?.readyState === SOCKET_OPEN) {
+        this.healthFailures = 0;
+        return;
+      }
+      this.healthFailures++;
+      if (this.healthFailures >= MAX_HEALTH_FAILURES) {
+        this.requestReconnect(client, "unhealthy connection state");
+      }
+    }, HEALTH_INTERVAL_MS);
+  }
+  stopMonitoring() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = void 0;
+    }
+    if (this.healthTimer) {
+      clearInterval(this.healthTimer);
+      this.healthTimer = void 0;
+    }
+    this.socketCleanup?.();
+    this.socketCleanup = void 0;
+  }
+  async reconnect(reason, generation) {
+    const previousClient = this.activeClient;
+    let retryDelay = INITIAL_RECONNECT_DELAY_MS;
+    while (this.running && generation === this.generation) {
+      let replacement;
+      try {
+        replacement = this.options.createClient();
+        await this.connectClient(replacement, generation);
+        if (!this.running || generation !== this.generation) {
+          this.safeDisconnect(replacement, "stale replacement client");
+          return;
+        }
+        this.activeClient = replacement;
+        this.stopMonitoring();
+        this.options.onClientChanged(replacement);
+        this.startMonitoring(replacement);
+        this.safeDisconnect(previousClient, "replaced client");
+        return;
+      } catch (error) {
+        if (replacement) {
+          this.safeDisconnect(replacement, "failed replacement client");
+        }
+        if (!this.running || generation !== this.generation) {
+          return;
+        }
+        this.options.log(`${reason}: ${String(error)}`);
+        await this.waitForRetry(retryDelay);
+        retryDelay = Math.min(retryDelay * 2, MAX_RECONNECT_DELAY_MS);
+      }
+    }
+  }
+  async connectClient(client, generation) {
+    const deadline = Date.now() + CONNECT_TIMEOUT_MS;
+    let abortAttempt = false;
+    let timeout;
+    let rejectAttempt;
+    const attemptEnded = new Promise((_resolve, reject) => {
+      rejectAttempt = reject;
+      timeout = setTimeout(() => {
+        abortAttempt = true;
+        reject(new Error("Timed out connecting to DingTalk Stream."));
+      }, CONNECT_TIMEOUT_MS);
+    });
+    const cancel = /* @__PURE__ */ __name(() => {
+      abortAttempt = true;
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = void 0;
+      }
+      rejectAttempt(new Error("DingTalk connection manager stopped."));
+    }, "cancel");
+    this.cancelConnectionAttempts.add(cancel);
+    const connect = client.connect();
+    try {
+      await Promise.race([connect, attemptEnded]);
+    } catch (error) {
+      if (abortAttempt) {
+        void connect.then(() => this.safeDisconnect(client, "late connection client"), () => void 0);
+      }
+      throw error;
+    } finally {
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      this.cancelConnectionAttempts.delete(cancel);
+    }
+    await this.waitUntilReady(client, generation, deadline);
+  }
+  safeDisconnect(client, context) {
+    try {
+      client.disconnect();
+    } catch (error) {
+      this.options.log(`failed to disconnect ${context}: ${String(error)}`);
+    }
+  }
+  waitForRetry(delay) {
+    return new Promise((resolve) => {
+      this.resolveRetryDelay = resolve;
+      this.retryTimer = setTimeout(() => {
+        this.retryTimer = void 0;
+        this.resolveRetryDelay = void 0;
+        resolve();
+      }, delay);
+    });
+  }
+  async waitUntilReady(client, generation, deadline) {
+    while (this.running && generation === this.generation) {
+      if (client.connected && this.options.getSocket(client)?.readyState === SOCKET_OPEN) {
+        return;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error("Timed out connecting to DingTalk Stream.");
+      }
+      await this.waitForReadyPoll();
+    }
+    throw new Error("DingTalk connection manager stopped.");
+  }
+  waitForReadyPoll() {
+    return new Promise((resolve) => {
+      this.resolveReadyDelay = resolve;
+      this.readyTimer = setTimeout(() => {
+        this.readyTimer = void 0;
+        this.resolveReadyDelay = void 0;
+        resolve();
+      }, READY_POLL_MS);
+    });
+  }
+  cancelReadyDelay() {
+    if (this.readyTimer) {
+      clearTimeout(this.readyTimer);
+      this.readyTimer = void 0;
+    }
+    this.resolveReadyDelay?.();
+    this.resolveReadyDelay = void 0;
+  }
+  cancelRetryDelay() {
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = void 0;
+    }
+    this.resolveRetryDelay?.();
+    this.resolveRetryDelay = void 0;
+  }
+};
+
 // packages/channels/dingtalk/dist/DingtalkAdapter.js
 var DEDUP_TTL_MS = 5 * 60 * 1e3;
 var ACK_REACTION_NAME = "\u{1F440}";
@@ -4492,12 +4746,35 @@ var GROUP_MSG_API = "https://api.dingtalk.com/v1.0/robot/groupMessages/send";
 var GROUP_MSG_KEY = "sampleMarkdown";
 var TOKEN_API = "https://oapi.dingtalk.com/gettoken";
 var PROACTIVE_FETCH_TIMEOUT_MS = 15e3;
+var TEXT_MESSAGE_LIMIT = 3800;
+var mentionTarget = Symbol("mentionTarget");
+function splitTextChunks(text, firstChunkLimit) {
+  if (!text)
+    return [text];
+  const chunks = [];
+  let offset = 0;
+  let chunkLimit = firstChunkLimit;
+  while (offset < text.length) {
+    chunks.push(text.slice(offset, offset + chunkLimit));
+    offset += chunkLimit;
+    chunkLimit = TEXT_MESSAGE_LIMIT;
+  }
+  return chunks;
+}
+__name(splitTextChunks, "splitTextChunks");
 var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   static {
     __name(this, "DingtalkChannel");
   }
   client;
+  atSender;
+  connectionManager;
   seenMessages = /* @__PURE__ */ new Map();
+  mentionTargets = /* @__PURE__ */ new Map();
+  sessionMentionTargets = /* @__PURE__ */ new Map();
+  textReplySessions = /* @__PURE__ */ new Set();
+  bufferedMentionTargets = /* @__PURE__ */ new Set();
+  bufferedMentionTargetsBySession = /* @__PURE__ */ new Map();
   dedupTimer;
   /** Map conversationId → latest sessionWebhook URL for sending replies. */
   webhooks = /* @__PURE__ */ new Map();
@@ -4517,23 +4794,60 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   proactiveToken;
   constructor(name, config, bridge, options) {
     super(name, config, bridge, options);
+    this.atSender = config["atSender"] === true;
     if (!config.clientId || !config.clientSecret) {
       throw new Error(`Channel "${name}" requires clientId and clientSecret for DingTalk.`);
     }
-    this.client = new DWClient({
-      clientId: config.clientId,
-      clientSecret: config.clientSecret
+    const rawUseConnectionManager = config.useConnectionManager;
+    if (rawUseConnectionManager !== void 0 && typeof rawUseConnectionManager !== "boolean") {
+      throw new Error(`Channel "${name}" useConnectionManager must be a boolean.`);
+    }
+    const useConnectionManager = rawUseConnectionManager ?? true;
+    this.client = this.createClient(useConnectionManager);
+    if (useConnectionManager) {
+      this.connectionManager = new DingtalkConnectionManager({
+        initialClient: this.client,
+        createClient: /* @__PURE__ */ __name(() => this.createClient(true), "createClient"),
+        getSocket: /* @__PURE__ */ __name((client) => client.socket, "getSocket"),
+        onClientChanged: /* @__PURE__ */ __name((client) => {
+          this.client = client;
+        }, "onClientChanged"),
+        log: /* @__PURE__ */ __name((message) => {
+          process.stderr.write(`[DingTalk:${this.name}] ${sanitizeLogText(message, 200)}
+`);
+        }, "log")
+      });
+    }
+  }
+  createClient(useConnectionManager) {
+    const client = new DWClient({
+      clientId: this.config.clientId,
+      clientSecret: this.config.clientSecret,
+      keepAlive: !useConnectionManager
     });
-    this.installStructuredDownstreamHandler();
+    client.config.autoReconnect = !useConnectionManager;
+    this.installStructuredDownstreamHandler(client);
+    this.registerMessageHandler(client);
+    return client;
   }
-  installStructuredDownstreamHandler() {
-    const client = this.client;
+  installStructuredDownstreamHandler(streamClient) {
+    const client = streamClient;
     client.debug = false;
     client.onDownStream = (raw) => {
       this.onDownStream(raw, client);
     };
   }
+  registerMessageHandler(client) {
+    client.registerCallbackListener(TOPIC_ROBOT, (msg) => {
+      client.send(msg.headers.messageId, {
+        status: EventAck.SUCCESS,
+        message: "ok"
+      });
+      this.onMessage(msg);
+    });
+  }
   onDownStream(raw, client) {
+    this.connectionManager?.noteActivity(client);
     const decoded = this.decodeDownStream(raw);
     let msg;
     try {
@@ -4567,6 +4881,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     switch (type) {
       case "SYSTEM":
         this.callDownStreamHandler(client, "onSystem", normalizedMsg);
+        if (topic === "disconnect") {
+          this.connectionManager?.requestReconnect(client, "SYSTEM disconnect");
+        }
         break;
       case "EVENT":
         this.callDownStreamHandler(client, "onEvent", normalizedMsg);
@@ -4606,14 +4923,11 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     return { text: String(raw), bytes: Buffer2.byteLength(String(raw)) };
   }
   async connect() {
-    this.client.registerCallbackListener(TOPIC_ROBOT, (msg) => {
-      this.client.send(msg.headers.messageId, {
-        status: EventAck.SUCCESS,
-        message: "ok"
-      });
-      this.onMessage(msg);
-    });
-    await this.client.connect();
+    if (this.connectionManager) {
+      await this.connectionManager.start();
+    } else {
+      await this.client.connect();
+    }
     this.dedupTimer = setInterval(() => {
       const now = Date.now();
       for (const [id, ts] of this.seenMessages) {
@@ -4633,7 +4947,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   static isUnroutableGroupMessage(isGroup, conversationId) {
     return isGroup && !conversationId;
   }
-  async sendMessage(chatId, text) {
+  async sendReply(chatId, text) {
     const webhook = this.webhooks.get(chatId);
     if (!webhook) {
       process.stderr.write(`[DingTalk:${this.name}] No webhook for chatId ${chatId}, cannot send.
@@ -4663,6 +4977,45 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       }
     }
   }
+  async sendTextReply(chatId, text, atUserId) {
+    const webhook = this.webhooks.get(chatId);
+    if (!webhook)
+      return;
+    const mentionPrefix = atUserId ? `@${atUserId}
+
+` : "";
+    const chunks = splitTextChunks(text, TEXT_MESSAGE_LIMIT - mentionPrefix.length);
+    for (let i = 0; i < chunks.length; i++) {
+      const isMention = i === 0 && atUserId !== void 0;
+      const resp = await fetch(webhook, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          msgtype: "text",
+          text: {
+            content: isMention ? `${mentionPrefix}${chunks[i]}` : chunks[i]
+          },
+          ...isMention ? { at: { atUserIds: [atUserId] } } : {}
+        })
+      });
+      if (isMention && process.env["QWEN_CHANNEL_DEBUG_MENTIONS"] === "1") {
+        const payload = await resp.clone().json().catch(() => void 0);
+        const response = payload && typeof payload === "object" ? payload : {};
+        const value = response["errcode"] ?? response["code"];
+        const code = typeof value === "number" || typeof value === "string" ? String(value) : "unknown";
+        process.stderr.write(`[DingTalk:${this.name}] mention delivery status=${resp.status} code=${code}
+`);
+      }
+      if (!resp.ok) {
+        const detail = await resp.text().catch(() => "");
+        process.stderr.write(`[DingTalk:${this.name}] sendTextReply failed: HTTP ${resp.status} ${detail}
+`);
+      }
+    }
+  }
+  async sendMessage(chatId, text) {
+    await this.sendReply(chatId, text);
+  }
   supportsProactiveSend() {
     return true;
   }
@@ -4806,7 +5159,11 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     }
     this.activeReactionKeys.clear();
     this.sessionReactionKeys.clear();
-    this.client.disconnect();
+    if (this.connectionManager) {
+      this.connectionManager.stop();
+    } else {
+      this.client.disconnect();
+    }
     process.stderr.write(`[DingTalk:${this.name}] Disconnected.
 `);
   }
@@ -4882,6 +5239,16 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   }
   /** Recall reactions left behind when a session dies without terminal lifecycle events. */
   onSessionDied(sessionId) {
+    const bufferedTargets = this.bufferedMentionTargetsBySession.get(sessionId);
+    if (bufferedTargets) {
+      this.bufferedMentionTargetsBySession.delete(sessionId);
+      for (const messageId of bufferedTargets) {
+        this.bufferedMentionTargets.delete(messageId);
+        this.mentionTargets.delete(messageId);
+      }
+    }
+    this.sessionMentionTargets.delete(sessionId);
+    this.textReplySessions.delete(sessionId);
     const keys = this.sessionReactionKeys.get(sessionId);
     if (keys) {
       this.sessionReactionKeys.delete(sessionId);
@@ -4901,15 +5268,94 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
       return;
     }
     if (isTerminalTaskLifecycleType(event.type)) {
+      if (event.messageId)
+        this.mentionTargets.delete(event.messageId);
       this.stopReaction(event.chatId, event.messageId, event.sessionId);
     }
   }
+  onPromptBufferDropped(_chatId, sessionId, messageIds) {
+    for (const messageId of messageIds) {
+      this.bufferedMentionTargets.delete(messageId);
+      this.mentionTargets.delete(messageId);
+      this.untrackBufferedMentionTarget(sessionId, messageId);
+    }
+  }
+  onPromptBufferDrained(_chatId, sessionId, messageIds) {
+    for (const messageId of messageIds) {
+      this.bufferedMentionTargets.delete(messageId);
+      this.untrackBufferedMentionTarget(sessionId, messageId);
+    }
+    for (const messageId of messageIds.slice(0, -1)) {
+      this.mentionTargets.delete(messageId);
+    }
+  }
+  onPromptBuffered(_chatId, sessionId, messageId) {
+    if (messageId && this.mentionTargets.has(messageId)) {
+      this.bufferedMentionTargets.add(messageId);
+      let targets = this.bufferedMentionTargetsBySession.get(sessionId);
+      if (!targets) {
+        targets = /* @__PURE__ */ new Set();
+        this.bufferedMentionTargetsBySession.set(sessionId, targets);
+      }
+      targets.add(messageId);
+    }
+  }
   onPromptStart(chatId, sessionId, messageId) {
+    if (messageId) {
+      this.bufferedMentionTargets.delete(messageId);
+      this.untrackBufferedMentionTarget(sessionId, messageId);
+      const atUserId = this.mentionTargets.get(messageId);
+      this.mentionTargets.delete(messageId);
+      if (this.atSender && atUserId) {
+        this.sessionMentionTargets.set(sessionId, atUserId);
+        this.textReplySessions.add(sessionId);
+      }
+    }
     this.startReaction(chatId, messageId, sessionId);
   }
+  async handleInbound(envelope) {
+    if (!await this.preflightInbound(envelope))
+      return;
+    const messageId = envelope.messageId;
+    const atUserId = envelope[mentionTarget];
+    if (this.atSender && messageId && atUserId) {
+      this.mentionTargets.set(messageId, atUserId);
+    }
+    await this.processInbound(envelope);
+  }
+  async processInbound(envelope) {
+    const messageId = envelope.messageId;
+    try {
+      await super.processInbound(envelope);
+    } finally {
+      if (messageId && !this.bufferedMentionTargets.has(messageId)) {
+        this.mentionTargets.delete(messageId);
+      }
+    }
+  }
+  untrackBufferedMentionTarget(sessionId, messageId) {
+    const targets = this.bufferedMentionTargetsBySession.get(sessionId);
+    if (!targets)
+      return;
+    targets.delete(messageId);
+    if (targets.size === 0)
+      this.bufferedMentionTargetsBySession.delete(sessionId);
+  }
   onPromptEnd(chatId, sessionId, messageId) {
+    this.sessionMentionTargets.delete(sessionId);
+    this.textReplySessions.delete(sessionId);
     this.stopReaction(chatId, messageId, sessionId);
   }
+  async sendResponseMessage(chatId, text, sessionId) {
+    const atUserId = this.atSender ? this.sessionMentionTargets.get(sessionId) : void 0;
+    if (atUserId)
+      this.sessionMentionTargets.delete(sessionId);
+    if (this.textReplySessions.has(sessionId)) {
+      await this.sendTextReply(chatId, text, atUserId);
+      return;
+    }
+    await this.sendReply(chatId, text);
+  }
   /**
    * Extract quoted/referenced message context from a reply.
    * DingTalk provides this via text.repliedMsg (newer) or quoteMessage (legacy).
@@ -5081,6 +5527,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
   onMessage(downstream) {
     try {
       const data = typeof downstream.data === "string" ? JSON.parse(downstream.data) : downstream.data;
+      this.logDebugPayload("DingTalk", data);
       const dataMsgId = typeof data.msgId === "string" ? data.msgId : void 0;
       const headerMsgId = typeof downstream.headers.messageId === "string" ? downstream.headers.messageId : void 0;
       const msgId = dataMsgId || headerMsgId;
@@ -5135,6 +5582,9 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
         referencedText: quoted.referencedText
       };
       envelope.messageId = msgId;
+      if (this.atSender && isGroup && senderStaffId) {
+        envelope[mentionTarget] = senderStaffId;
+      }
       const processMessage = /* @__PURE__ */ __name(async () => {
         if (content.downloadCodes.length > 0 && content.mediaType) {
           await this.attachMedia(envelope, content.downloadCodes[0], content.mediaType, content.fileName);