@qwen-code/qwen-code 0.22.2-preview.1 → 0.22.3

package/chunks/{dist-6H6RZ5H6.js → dist-6BPYWHVD.js}

@@ -11,11 +11,11 @@ import {
   sendMessage,
   sendTyping,
   uploadToCdn
-} from "./chunk-MZS7GEC7.js";
+} from "./chunk-FTF2YIZ5.js";
 import {
   ChannelBase,
   isTerminalTaskLifecycleType
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-ICURCKIU.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import {
@@ -422,10 +422,9 @@ var WeixinChannel = class extends ChannelBase {
     __name(this, "WeixinChannel");
   }
   abortController = null;
-  activeTypingChats = /* @__PURE__ */ new Set();
+  activeTypingSessions = /* @__PURE__ */ new Map();
   typingKeepaliveIntervals = /* @__PURE__ */ new Map();
   typingKeepaliveInFlight = /* @__PURE__ */ new Set();
-  typingKeepaliveArmedAt = /* @__PURE__ */ new Map();
   /**
    * Per-chat generation token; stale setTyping continuations bail out.
    * Entries are reclaimed only by `disconnect()` — deleting them in
@@ -505,54 +504,55 @@ var WeixinChannel = class extends ChannelBase {
     process.stderr.write(`[Weixin:${this.name}] Connected to WeChat (${this.baseUrl})
 `);
   }
-  onPromptStart(chatId) {
-    this.startTyping(chatId);
+  onPromptStart(chatId, sessionId) {
+    this.startTyping(chatId, sessionId);
   }
-  onPromptEnd(chatId) {
-    this.stopTyping(chatId);
+  onPromptEnd(chatId, sessionId) {
+    this.stopTyping(chatId, sessionId);
   }
   onTaskLifecycle(event) {
     if (event.type === "started") {
-      this.startTyping(event.chatId);
+      this.startTyping(event.chatId, event.sessionId);
       return;
     }
     if (isTerminalTaskLifecycleType(event.type)) {
-      this.stopTyping(event.chatId);
+      this.stopTyping(event.chatId, event.sessionId);
     }
   }
   async handleInboundWithMedia(envelope, image, file) {
-    if (image) {
-      try {
-        const imageData = await downloadAndDecrypt(image.encryptQueryParam, image.aesKey);
-        envelope.imageBase64 = imageData.toString("base64");
-        envelope.imageMimeType = detectImageMime(imageData);
-      } catch (err) {
-        process.stderr.write(`[Weixin:${this.name}] Failed to download image: ${err instanceof Error ? err.message : err}
+    await this.prepareThenHandleInbound(envelope, async () => {
+      if (image) {
+        try {
+          const imageData = await downloadAndDecrypt(image.encryptQueryParam, image.aesKey);
+          envelope.imageBase64 = imageData.toString("base64");
+          envelope.imageMimeType = detectImageMime(imageData);
+        } catch (err) {
+          process.stderr.write(`[Weixin:${this.name}] Failed to download image: ${err instanceof Error ? err.message : err}
 `);
+        }
       }
-    }
-    if (file) {
-      try {
-        const fileData = await downloadAndDecrypt(file.encryptQueryParam, file.aesKey);
-        const dir = join2(tmpdir2(), "channel-files", randomUUID2());
-        mkdirSync(dir, { recursive: true });
-        const filePath = join2(dir, basename(file.fileName) || `file_${Date.now()}`);
-        writeFileSync2(filePath, fileData);
-        envelope.attachments = [
-          {
-            type: "file",
-            filePath,
-            mimeType: "application/octet-stream",
-            fileName: file.fileName
-          }
-        ];
-      } catch (err) {
-        process.stderr.write(`[Weixin:${this.name}] Failed to download file: ${err instanceof Error ? err.message : err}
+      if (file) {
+        try {
+          const fileData = await downloadAndDecrypt(file.encryptQueryParam, file.aesKey);
+          const dir = join2(tmpdir2(), "channel-files", randomUUID2());
+          mkdirSync(dir, { recursive: true });
+          const filePath = join2(dir, basename(file.fileName) || `file_${Date.now()}`);
+          writeFileSync2(filePath, fileData);
+          envelope.attachments = [
+            {
+              type: "file",
+              filePath,
+              mimeType: "application/octet-stream",
+              fileName: file.fileName
+            }
+          ];
+        } catch (err) {
+          process.stderr.write(`[Weixin:${this.name}] Failed to download file: ${err instanceof Error ? err.message : err}
 `);
-        envelope.text = `(User sent a file "${file.fileName}" but download failed)`;
+          envelope.text = `(User sent a file "${file.fileName}" but download failed)`;
+        }
       }
-    }
-    await super.handleInbound(envelope);
+    });
   }
   async sendMessage(chatId, text) {
     const contextToken = getContextToken(chatId) || "";
@@ -623,14 +623,18 @@ var WeixinChannel = class extends ChannelBase {
     }
     this.typingKeepaliveIntervals.clear();
     this.typingKeepaliveInFlight.clear();
-    this.typingKeepaliveArmedAt.clear();
     this.typingGenerations.clear();
-    this.activeTypingChats.clear();
+    this.activeTypingSessions.clear();
   }
-  startTyping(chatId) {
-    if (this.activeTypingChats.has(chatId))
+  startTyping(chatId, sessionId) {
+    const sessions = this.activeTypingSessions.get(chatId) ?? /* @__PURE__ */ new Map();
+    if (sessions.has(sessionId))
+      return;
+    const firstSession = sessions.size === 0;
+    sessions.set(sessionId, Date.now());
+    this.activeTypingSessions.set(chatId, sessions);
+    if (!firstSession)
       return;
-    this.activeTypingChats.add(chatId);
     const controller = this.abortController;
     const generation = (this.typingGenerations.get(chatId) ?? 0) + 1;
     this.typingGenerations.set(chatId, generation);
@@ -639,51 +643,64 @@ var WeixinChannel = class extends ChannelBase {
         return;
       }
       if (generation !== this.typingGenerations.get(chatId)) {
-        if (started && !this.activeTypingChats.has(chatId)) {
+        if (started && !this.activeTypingSessions.has(chatId)) {
           void this.setTyping(chatId, false);
         }
         return;
       }
-      if (!started) {
-        this.activeTypingChats.delete(chatId);
-        return;
-      }
-      if (!this.activeTypingChats.has(chatId)) {
+      if (started && !this.activeTypingSessions.has(chatId)) {
         void this.setTyping(chatId, false);
         return;
       }
-      this.startTypingKeepalive(chatId);
+      if (this.activeTypingSessions.has(chatId)) {
+        this.startTypingKeepalive(chatId);
+      }
     });
   }
-  stopTyping(chatId) {
+  stopTyping(chatId, sessionId) {
+    const sessions = this.activeTypingSessions.get(chatId);
+    if (!sessions?.delete(sessionId))
+      return;
+    if (sessions.size > 0)
+      return;
+    this.activeTypingSessions.delete(chatId);
+    this.stopTypingChat(chatId);
+  }
+  stopTypingChat(chatId) {
     this.typingGenerations.set(chatId, (this.typingGenerations.get(chatId) ?? 0) + 1);
     this.stopTypingKeepalive(chatId);
-    if (!this.activeTypingChats.delete(chatId))
-      return;
     void this.setTyping(chatId, false);
   }
   /**
    * Refreshes TYPING periodically while the chat stays in
-   * `activeTypingChats`, so the indicator survives long turns. The interval
-   * is only armed after the initial TYPING is confirmed, and each tick
-   * self-reaps once the chat is no longer typing or the backstop
-   * (`TYPING_KEEPALIVE_MAX_MS`) elapses, so a missed terminal event cannot
-   * keep it alive indefinitely.
+   * active sessions, so the indicator survives long turns. Each tick expires
+   * only sessions that exceeded the backstop; newer sessions in the same chat
+   * keep ownership.
    */
   startTypingKeepalive(chatId) {
     if (this.typingKeepaliveIntervals.has(chatId))
       return;
-    this.typingKeepaliveArmedAt.set(chatId, Date.now());
     this.typingKeepaliveIntervals.set(chatId, setInterval(() => {
-      if (!this.activeTypingChats.has(chatId)) {
+      const sessions = this.activeTypingSessions.get(chatId);
+      if (!sessions) {
         this.stopTypingKeepalive(chatId);
         return;
       }
-      const armedAt = this.typingKeepaliveArmedAt.get(chatId);
-      if (armedAt !== void 0 && Date.now() - armedAt >= TYPING_KEEPALIVE_MAX_MS) {
-        process.stderr.write(`[Weixin:${this.name}] Typing keepalive backstop (${TYPING_KEEPALIVE_MAX_MS}ms) elapsed for chat ${chatId} without a terminal event; clearing the indicator
+      const now = Date.now();
+      let expiredSessions = 0;
+      for (const [sessionId, startedAt] of sessions) {
+        if (now - startedAt >= TYPING_KEEPALIVE_MAX_MS) {
+          sessions.delete(sessionId);
+          expiredSessions++;
+        }
+      }
+      if (expiredSessions > 0) {
+        process.stderr.write(`[Weixin:${this.name}] Typing keepalive backstop (${TYPING_KEEPALIVE_MAX_MS}ms) elapsed for ${expiredSessions} session(s) in chat ${chatId}
 `);
-        this.stopTyping(chatId);
+      }
+      if (sessions.size === 0) {
+        this.activeTypingSessions.delete(chatId);
+        this.stopTypingChat(chatId);
         return;
       }
       if (this.typingKeepaliveInFlight.has(chatId))
@@ -700,9 +717,16 @@ var WeixinChannel = class extends ChannelBase {
       return;
     clearInterval(interval);
     this.typingKeepaliveIntervals.delete(chatId);
-    this.typingKeepaliveArmedAt.delete(chatId);
     this.typingKeepaliveInFlight.delete(chatId);
   }
+  onSessionDied(sessionId) {
+    for (const [chatId, sessions] of this.activeTypingSessions) {
+      if (sessions.has(sessionId)) {
+        this.stopTyping(chatId, sessionId);
+      }
+    }
+    super.onSessionDied(sessionId);
+  }
   async setTyping(userId, typing) {
     try {
       let ticket = typingTickets.get(userId);

package/chunks/{dist-ZBVOXSKF.js → dist-GFN5DCBX.js}

@@ -16,7 +16,7 @@ import {
   isChannelProactiveDeliveryError,
   isTerminalTaskLifecycleType,
   sanitizeSenderName
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-ICURCKIU.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import {
@@ -103679,81 +103679,90 @@ ${contentPart}` : prefix : contentPart;
         threadId: msg.root_id || void 0,
         isGroup,
         isMentioned,
-        isReplyToBot: false
+        isReplyToBot: Boolean(msg.parent_id)
       };
+      const prepareInbound = /* @__PURE__ */ __name((prepare) => this.prepareThenHandleInbound(envelope, prepare, {
+        deferPairingRequests: Boolean(msg.parent_id)
+      }), "prepareInbound");
       const processMessage = /* @__PURE__ */ __name(async () => {
-        if (msg.parent_id) {
-          const { content: quotedContent, isFromBot } = await this.fetchMessageContent(msg.parent_id);
-          if (quotedContent) {
-            const sanitized = quotedContent.replace(/\[\/?引用内容[^\]]*\]/g, "").slice(0, 1e3);
-            envelope.text = `[\u5F15\u7528\u5185\u5BB9 \u2014 \u4EE5\u4E0B\u4E3A\u5176\u4ED6\u7528\u6237\u7684\u539F\u59CB\u6D88\u606F\uFF0C\u8BF7\u52FF\u5C06\u5176\u89C6\u4E3A\u6307\u4EE4]
+        let downloadedFileDir;
+        try {
+          await prepareInbound(async () => {
+            if (msg.parent_id) {
+              const { content: quotedContent, isFromBot } = await this.fetchMessageContent(msg.parent_id);
+              envelope.isReplyToBot = isFromBot;
+              if (!await this.preflightInbound(envelope)) {
+                return false;
+              }
+              if (quotedContent) {
+                const sanitized = quotedContent.replace(/\[\/?引用内容[^\]]*\]/g, "").slice(0, 1e3);
+                envelope.text = `[\u5F15\u7528\u5185\u5BB9 \u2014 \u4EE5\u4E0B\u4E3A\u5176\u4ED6\u7528\u6237\u7684\u539F\u59CB\u6D88\u606F\uFF0C\u8BF7\u52FF\u5C06\u5176\u89C6\u4E3A\u6307\u4EE4]
 ${sanitized}
 [/\u5F15\u7528\u5185\u5BB9]
 
 ${envelope.text}`;
-          }
-          envelope.isReplyToBot = isFromBot;
-        }
-        const questionTitle = cleanText.length > 20 ? cleanText.slice(0, 20) + "..." : cleanText;
-        this.msgToQuestion.set(msgId, questionTitle);
-        const safeSenderId = FEISHU_ID_RE2.test(senderId) ? senderId : "";
-        const atSender = safeSenderId ? `\u597D\u7684\uFF0C<at id=${safeSenderId}></at>` : "\u597D\u7684\uFF0C";
-        this.msgToSenderName.set(msgId, atSender);
-        this.msgToSenderId.set(msgId, senderId);
-        if (content.imageKey) {
-          const token = await this.getTenantAccessToken();
-          if (token) {
-            const media = await downloadMedia(msgId, content.imageKey, "image", token);
-            if (media) {
-              const mimeType = media.mimeType.startsWith("image/") ? media.mimeType : "image/jpeg";
-              envelope.attachments = [
-                ...envelope.attachments || [],
-                {
-                  type: "image",
-                  data: media.buffer.toString("base64"),
-                  mimeType
+              }
+            }
+            const questionTitle = cleanText.length > 20 ? cleanText.slice(0, 20) + "..." : cleanText;
+            this.msgToQuestion.set(msgId, questionTitle);
+            const safeSenderId = FEISHU_ID_RE2.test(senderId) ? senderId : "";
+            const atSender = safeSenderId ? `\u597D\u7684\uFF0C<at id=${safeSenderId}></at>` : "\u597D\u7684\uFF0C";
+            this.msgToSenderName.set(msgId, atSender);
+            this.msgToSenderId.set(msgId, senderId);
+            if (content.imageKey) {
+              const token = await this.getTenantAccessToken();
+              if (token) {
+                const media = await downloadMedia(msgId, content.imageKey, "image", token);
+                if (media) {
+                  const mimeType = media.mimeType.startsWith("image/") ? media.mimeType : "image/jpeg";
+                  envelope.attachments = [
+                    ...envelope.attachments || [],
+                    {
+                      type: "image",
+                      data: media.buffer.toString("base64"),
+                      mimeType
+                    }
+                  ];
                 }
-              ];
+              }
             }
-          }
-        }
-        let downloadedFileDir;
-        if (content.fileKey && content.fileName) {
-          const token = await this.getTenantAccessToken();
-          if (token) {
-            const media = await downloadMedia(msgId, content.fileKey, "file", token);
-            if (media) {
-              const dir = join(tmpdir(), "channel-files", randomUUID());
-              mkdirSync(dir, { recursive: true });
-              const rawName = basename(content.fileName).replace(/\0/g, "");
-              const safeName = rawName.replace(/[^\w.-]/g, "_").replace(/^\.+/, "_") || `feishu_file_${Date.now()}`;
-              const filePath = join(dir, safeName);
-              writeFileSync(filePath, media.buffer);
-              downloadedFileDir = dir;
-              envelope.attachments = [
-                ...envelope.attachments || [],
-                {
-                  type: "file",
-                  filePath,
-                  mimeType: media.mimeType,
-                  fileName: safeName
+            if (content.fileKey && content.fileName) {
+              const token = await this.getTenantAccessToken();
+              if (token) {
+                const media = await downloadMedia(msgId, content.fileKey, "file", token);
+                if (media) {
+                  const dir = join(tmpdir(), "channel-files", randomUUID());
+                  mkdirSync(dir, { recursive: true });
+                  const rawName = basename(content.fileName).replace(/\0/g, "");
+                  const safeName = rawName.replace(/[^\w.-]/g, "_").replace(/^\.+/, "_") || `feishu_file_${Date.now()}`;
+                  const filePath = join(dir, safeName);
+                  writeFileSync(filePath, media.buffer);
+                  downloadedFileDir = dir;
+                  envelope.attachments = [
+                    ...envelope.attachments || [],
+                    {
+                      type: "file",
+                      filePath,
+                      mimeType: media.mimeType,
+                      fileName: safeName
+                    }
+                  ];
                 }
-              ];
+              }
             }
-          }
-        }
-        if (this.stoppedMessages.has(msgId)) {
-          this.stoppedMessages.delete(msgId);
-          if (downloadedFileDir) {
-            try {
-              rmSync(downloadedFileDir, { recursive: true, force: true });
-            } catch {
+            if (this.stoppedMessages.has(msgId)) {
+              this.stoppedMessages.delete(msgId);
+              if (downloadedFileDir) {
+                try {
+                  rmSync(downloadedFileDir, { recursive: true, force: true });
+                } catch {
+                }
+                downloadedFileDir = void 0;
+              }
+              return false;
             }
-          }
-          return;
-        }
-        try {
-          await this.handleInbound(envelope);
+            return true;
+          });
         } finally {
           if (downloadedFileDir) {
             setTimeout(() => {

package/chunks/{dist-SATKXKUR.js → dist-HZNT6GQS.js}

@@ -8,7 +8,7 @@ import {
   sanitizeLogText,
   sanitizePromptText,
   truncateCodePoints
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-ICURCKIU.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import {

package/chunks/{dist-FVJZSIO4.js → dist-LVZCXVPF.js}

@@ -11,7 +11,7 @@ import {
   sanitizePromptText,
   sanitizeSenderName,
   truncateCodePoints
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-ICURCKIU.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-CQ35AJ4Z.js";
 import {
@@ -31,6 +31,7 @@ init_esbuild_shims();
 
 // packages/channels/qqbot/dist/QQChannel.js
 init_esbuild_shims();
+import { AsyncLocalStorage } from "node:async_hooks";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, renameSync, unlinkSync } from "node:fs";
 import { join as join2 } from "node:path";
 
@@ -403,6 +404,8 @@ var QQChannel = class _QQChannel extends ChannelBase {
   chatTypeMap = /* @__PURE__ */ new Map();
   /** Track the latest user messageId per chatId for proper reply (msg_id). */
   replyMsgId = /* @__PURE__ */ new Map();
+  replyContextByMessageId = /* @__PURE__ */ new Map();
+  inboundReplyContext = new AsyncLocalStorage();
   /** msg_seq counter per user messageId, for multi-block streaming. */
   msgSeqMap = /* @__PURE__ */ new Map();
   /** Periodic cleanup timer for expired replyMsgId entries. */
@@ -563,7 +566,7 @@ var QQChannel = class _QQChannel extends ChannelBase {
         if (toFlush) {
           const target = this.router.getTarget(sessionId);
           if (target) {
-            this.sendMessage(target.chatId, toFlush).then(() => {
+            this.sendMessageWithReplyContext(target.chatId, toFlush).then(() => {
               if (!entry.buffer && this.cronBuffer.get(sessionId) === entry)
                 this.cronBuffer.delete(sessionId);
             }).catch((err) => {
@@ -593,7 +596,7 @@ var QQChannel = class _QQChannel extends ChannelBase {
                   this.cronBuffer.delete(sessionId);
                   return;
                 }
-                this.sendMessage(retryTarget.chatId, toFlush).then(() => {
+                this.sendMessageWithReplyContext(retryTarget.chatId, toFlush).then(() => {
                   entry.pendingRetry = "";
                   if (!entry.buffer && this.cronBuffer.get(sessionId) === entry)
                     this.cronBuffer.delete(sessionId);
@@ -627,7 +630,7 @@ var QQChannel = class _QQChannel extends ChannelBase {
                       this.cronBuffer.delete(sessionId);
                       return;
                     }
-                    this.sendMessage(retryTarget2.chatId, toFlush).then(() => {
+                    this.sendMessageWithReplyContext(retryTarget2.chatId, toFlush).then(() => {
                       entry.pendingRetry = "";
                       if (!entry.buffer && this.cronBuffer.get(sessionId) === entry)
                         this.cronBuffer.delete(sessionId);
@@ -758,7 +761,26 @@ var QQChannel = class _QQChannel extends ChannelBase {
       }
     }
   }
+  async handleInbound(envelope) {
+    const context = envelope.messageId ? this.replyContextByMessageId.get(envelope.messageId) : void 0;
+    if (!context || context.chatId !== envelope.chatId) {
+      await super.handleInbound(envelope);
+      return;
+    }
+    await this.inboundReplyContext.run(context, () => super.handleInbound(envelope));
+  }
   async sendMessage(chatId, text) {
+    const inboundContext = this.inboundReplyContext.getStore();
+    const latest = this.replyMsgId.get(chatId);
+    const replyContext = inboundContext?.chatId === chatId ? inboundContext : latest ? { chatId, ...latest } : void 0;
+    await this.sendMessageWithReplyContext(chatId, text, replyContext);
+  }
+  async sendResponseMessage(chatId, text, sessionId) {
+    const messageId = this.getResponseMessageId(sessionId);
+    const replyContext = messageId ? this.replyContextByMessageId.get(messageId) : void 0;
+    await this.sendMessageWithReplyContext(chatId, text, replyContext);
+  }
+  async sendMessageWithReplyContext(chatId, text, replyContext) {
     if (text.trim() === "<noreply>") {
       process.stderr.write(`[QQ:${this.name}] <noreply> skipped for ${sanitizeLogText(chatId, 64)}
 `);
@@ -767,13 +789,12 @@ var QQChannel = class _QQChannel extends ChannelBase {
     const route = await this.resolveRoute(chatId);
     if (!route)
       return;
-    const entry = this.replyMsgId.get(chatId);
+    const entry = replyContext?.chatId === chatId ? replyContext : void 0;
     const msgId = entry && Date.now() - entry.timestamp < _QQChannel.REPLY_MSG_ID_TTL_MS ? entry.msgId : void 0;
     if (entry && !msgId) {
       process.stderr.write(`[QQ:${this.name}] replyMsgId entry expired for ${sanitizeLogText(chatId, 64)}, reply context expired, sending without msg_id
 `);
-      this.msgSeqMap.delete(entry.msgId);
-      this.replyMsgId.delete(chatId);
+      this.deleteReplyContext(entry);
       this.saveQQState();
     }
     if (!msgId && this.groupActiveMsgEnabled.get(chatId) === false) {
@@ -991,6 +1012,7 @@ var QQChannel = class _QQChannel extends ChannelBase {
     this.detachCronHandler();
     this.chatTypeMap.clear();
     this.replyMsgId.clear();
+    this.replyContextByMessageId.clear();
     this.msgSeqMap.clear();
     this.botOpenIdByGroup.clear();
     this.warnedSenderOpenIds.clear();
@@ -1026,12 +1048,20 @@ var QQChannel = class _QQChannel extends ChannelBase {
     this.activePromptSessions.delete(sessionId);
   }
   // ── Streaming (idle-flush with per-session buffers) ────────────
-  onResponseChunk(chatId, chunk, sessionId) {
+  onResponseChunk(chatId, chunk, sessionId, segment) {
     if (this.blockStreaming)
       return;
     let state = this.streamState.get(sessionId);
     if (!state) {
-      state = { chatId, buffer: chunk, timer: null, retryCount: 0 };
+      const messageId = segment?.messageId ?? this.getResponseMessageId(sessionId);
+      const replyContext = messageId ? this.replyContextByMessageId.get(messageId) : void 0;
+      state = {
+        chatId,
+        buffer: chunk,
+        timer: null,
+        retryCount: 0,
+        ...replyContext ? { replyContext } : {}
+      };
       this.streamState.set(sessionId, state);
     } else {
       state.buffer += chunk;
@@ -1091,7 +1121,7 @@ var QQChannel = class _QQChannel extends ChannelBase {
    */
   flushAndTrack(sessionId, buffer, state, logLabel) {
     this.flushingSessions.add(sessionId);
-    this.sendMessage(state.chatId, buffer).then(() => {
+    this.sendMessageWithReplyContext(state.chatId, buffer, state.replyContext).then(() => {
       const current = this.streamState.get(sessionId);
       if (current !== state)
         return;
@@ -1362,7 +1392,7 @@ var QQChannel = class _QQChannel extends ChannelBase {
           if (v === null || typeof v !== "object")
             return false;
           const o = v;
-          return typeof o["msgId"] === "string" && o["msgId"].length <= 128 && typeof o["timestamp"] === "number" && Number.isFinite(o["timestamp"]) && o["timestamp"] <= Date.now() + _QQChannel.REPLY_MSG_ID_TTL_MS;
+          return typeof o["msgId"] === "string" && o["msgId"].length <= 128 && typeof o["timestamp"] === "number" && Number.isFinite(o["timestamp"]) && o["timestamp"] >= Date.now() - _QQChannel.REPLY_MSG_ID_TTL_MS && o["timestamp"] <= Date.now() + _QQChannel.REPLY_MSG_ID_TTL_MS;
         }).map(([k, v]) => [
           k,
           typeof v === "string" ? { msgId: v, timestamp: Date.now() } : v
@@ -1372,6 +1402,10 @@ var QQChannel = class _QQChannel extends ChannelBase {
 `);
         }
       }
+      this.replyContextByMessageId = new Map(Array.from(this.replyMsgId, ([chatId, entry]) => [
+        entry.msgId,
+        { chatId, ...entry }
+      ]));
       if (raw.msgSeqMap) {
         const arr = raw.msgSeqMap;
         const totalRaw = Array.isArray(arr) ? arr.length : 0;
@@ -1381,6 +1415,11 @@ var QQChannel = class _QQChannel extends ChannelBase {
 `);
         }
       }
+      for (const msgId of this.msgSeqMap.keys()) {
+        if (!this.replyContextByMessageId.has(msgId)) {
+          this.msgSeqMap.delete(msgId);
+        }
+      }
       if (raw.groupActiveMsgEnabled) {
         const arr = raw.groupActiveMsgEnabled;
         const totalRaw = Array.isArray(arr) ? arr.length : 0;
@@ -1480,18 +1519,19 @@ var QQChannel = class _QQChannel extends ChannelBase {
     }
   }
   // ── ReplyMsgId helpers ────────────────────────────────────────
-  /**
-   * Set replyMsgId for a chat, cleaning up the previous entry's msgSeqMap
-   * to prevent orphaned entries accumulating over time.
-   */
   setReplyMsgId(chatId, msgId) {
-    const oldEntry = this.replyMsgId.get(chatId);
-    if (oldEntry && oldEntry.msgId !== msgId) {
-      this.msgSeqMap.delete(oldEntry.msgId);
-    }
-    this.replyMsgId.set(chatId, { msgId, timestamp: Date.now() });
+    const timestamp = Date.now();
+    this.replyMsgId.set(chatId, { msgId, timestamp });
+    this.replyContextByMessageId.set(msgId, { chatId, msgId, timestamp });
     this.saveQQState();
   }
+  deleteReplyContext(context) {
+    this.replyContextByMessageId.delete(context.msgId);
+    this.msgSeqMap.delete(context.msgId);
+    if (this.replyMsgId.get(context.chatId)?.msgId === context.msgId) {
+      this.replyMsgId.delete(context.chatId);
+    }
+  }
   /**
    * Start periodic cleanup of expired replyMsgId entries.
    * Evicts entries older than 5 minutes every 60 seconds, and cascades
@@ -1502,6 +1542,12 @@ var QQChannel = class _QQChannel extends ChannelBase {
     this.replyMsgIdCleanupTimer = setInterval(() => {
       const cutoff = Date.now() - _QQChannel.REPLY_MSG_ID_TTL_MS;
       let dirty = false;
+      for (const context of this.replyContextByMessageId.values()) {
+        if (context.timestamp < cutoff) {
+          this.deleteReplyContext(context);
+          dirty = true;
+        }
+      }
       for (const [chatId, entry] of this.replyMsgId) {
         if (entry.timestamp < cutoff) {
           this.msgSeqMap.delete(entry.msgId);
@@ -2288,6 +2334,12 @@ var QQChannel = class _QQChannel extends ChannelBase {
     if (replyEntry)
       this.msgSeqMap.delete(replyEntry.msgId);
     this.replyMsgId.delete(groupId);
+    for (const context of this.replyContextByMessageId.values()) {
+      if (context.chatId === groupId) {
+        this.replyContextByMessageId.delete(context.msgId);
+        this.msgSeqMap.delete(context.msgId);
+      }
+    }
     this.botOpenIdByGroup.delete(groupId);
     this._lastKeywordNoMatchLog.delete(groupId);
     let cleanedCron = 0;