@qwen-code/qwen-code 0.22.0 → 0.22.2-nightly.20260828.7357136dd1

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

@@ -11,11 +11,11 @@ import {
   sendMessage,
   sendTyping,
   uploadToCdn
-} from "./chunk-ZLCT4C5A.js";
+} from "./chunk-FTF2YIZ5.js";
 import {
   ChannelBase,
   isTerminalTaskLifecycleType
-} from "./chunk-AW27A43Y.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-2OG3PGKO.js → dist-GFN5DCBX.js}

@@ -4,11 +4,11 @@ import {
   require_axios,
   require_ws
 } from "./chunk-AVNATYLY.js";
+import "./chunk-XIQ5HQ2F.js";
+import "./chunk-K6KS3LTN.js";
 import {
   require_lib
 } from "./chunk-HMJ2P3SV.js";
-import "./chunk-XIQ5HQ2F.js";
-import "./chunk-K6KS3LTN.js";
 import "./chunk-7E7UCJHS.js";
 import {
   ChannelBase,
@@ -16,7 +16,7 @@ import {
   isChannelProactiveDeliveryError,
   isTerminalTaskLifecycleType,
   sanitizeSenderName
-} from "./chunk-AW27A43Y.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-K7IQB53U.js → dist-HZNT6GQS.js}

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