@qwen-code/qwen-code 0.19.5 → 0.19.6-nightly.20260705.015ee4248

package/chunks/{dist-Z57Q4YF5.js → dist-DN6M6TJ5.js}

@@ -7,8 +7,8 @@ import {
   sanitizeLogText,
   sanitizePromptText,
   sanitizeSenderName
-} from "./chunk-7DMQRPC7.js";
-import "./chunk-UFC57OYT.js";
+} from "./chunk-6BEOH4KK.js";
+import "./chunk-VRDMOSQS.js";
 import "./chunk-K5PGHDBN.js";
 import {
   wrapper_default
@@ -1114,7 +1114,7 @@ init_esbuild_shims();
 
 // packages/channels/qqbot/dist/QQChannel.js
 init_esbuild_shims();
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "node:fs";
+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";
 
 // packages/channels/qqbot/dist/types.js
@@ -1351,8 +1351,11 @@ async function fetchAccessToken(appId, appSecret) {
     signal: AbortSignal.timeout(FETCH_TIMEOUT)
   });
   if (!resp.ok) {
-    const body = await resp.text().catch(() => "");
-    throw new Error(`QQ Bot token request failed (HTTP ${resp.status}): ${body}`);
+    await resp.body?.cancel().catch(() => {
+    });
+    process.stderr.write(`[QQ] Token request failed (HTTP ${resp.status})
+`);
+    throw new Error(`QQ Bot token request failed (HTTP ${resp.status})`);
   }
   const data = await resp.json();
   if (!data.access_token) {
@@ -1364,6 +1367,27 @@ async function fetchAccessToken(appId, appSecret) {
   };
 }
 __name(fetchAccessToken, "fetchAccessToken");
+function validateGatewayUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "wss:") {
+      throw new Error(`QQ Bot gateway URL must use wss:// protocol, got: ${parsed.protocol}`);
+    }
+    if (!parsed.hostname.toLowerCase().endsWith(".qq.com")) {
+      throw new Error(`QQ Bot gateway URL has unexpected hostname: ${parsed.hostname} (expected *.qq.com)`);
+    }
+    const clean = new URL(url);
+    clean.username = "";
+    clean.password = "";
+    return clean.href;
+  } catch (e) {
+    if (e instanceof TypeError) {
+      throw new Error("QQ Bot gateway URL is not a valid URL");
+    }
+    throw e;
+  }
+}
+__name(validateGatewayUrl, "validateGatewayUrl");
 async function fetchGatewayUrl(accessToken, sandbox) {
   const gw = sandbox ? `${SANDBOX_HOST}/gateway` : `${API_HOST}/gateway`;
   const resp = await fetch(gw, {
@@ -1371,13 +1395,15 @@ async function fetchGatewayUrl(accessToken, sandbox) {
     signal: AbortSignal.timeout(FETCH_TIMEOUT)
   });
   if (!resp.ok) {
+    await resp.body?.cancel().catch(() => {
+    });
     throw new Error(`QQ Bot gateway request failed (HTTP ${resp.status})`);
   }
   const data = await resp.json();
   if (!data["url"]) {
     throw new Error("QQ Bot gateway response missing WebSocket URL");
   }
-  return data["url"];
+  return validateGatewayUrl(data["url"]);
 }
 __name(fetchGatewayUrl, "fetchGatewayUrl");
 function getApiBase(sandbox) {
@@ -1402,32 +1428,7 @@ function isValidChatId(id) {
   return /^[A-Za-z0-9_-]+$/.test(id) && id.length <= 128;
 }
 __name(isValidChatId, "isValidChatId");
-function hasLinkSyntax(text) {
-  const open = text.indexOf("[");
-  if (open === -1)
-    return false;
-  const mid = text.indexOf("](", open + 1);
-  if (mid === -1)
-    return false;
-  return text.indexOf(")", mid + 2) !== -1;
-}
-__name(hasLinkSyntax, "hasLinkSyntax");
-function hasMarkdownSyntax(text) {
-  return /^#{1,6}\s/m.test(text) || text.includes("```") || /\*\*|__|~~/.test(text) || /`[^`]+`/.test(text) || hasLinkSyntax(text) || /^[-*+]\s/m.test(text) || /^\d+\.\s/m.test(text);
-}
-__name(hasMarkdownSyntax, "hasMarkdownSyntax");
-function splitText(text) {
-  const MAX = 2e3;
-  if (text.length <= MAX)
-    return [text];
-  const chunks = [];
-  for (let i = 0; i < text.length; i += MAX) {
-    chunks.push(text.slice(i, i + MAX));
-  }
-  return chunks;
-}
-__name(splitText, "splitText");
-var QQChannel = class extends ChannelBase {
+var QQChannel = class _QQChannel extends ChannelBase {
   static {
     __name(this, "QQChannel");
   }
@@ -1459,8 +1460,12 @@ var QQChannel = class extends ChannelBase {
   lastHeartbeatAck = 0;
   /** Debounce timer for saveQQState to avoid blocking event loop. */
   saveTimer = null;
+  /** beforeExit hook to flush state when the event loop drains naturally. Does NOT fire for SIGKILL, OOM kills, or uncaughtException. */
+  beforeExitHook = null;
   /** Timer for reconnectWithRetry fallback (unref'd so it doesn't block exit). */
   reconnectTimer = null;
+  /** 30s READY timeout to prevent hanging on gateway without response. */
+  readyTimeout = null;
   /** Guard against parallel reconnectWithRetry chains from stale close events. */
   isReconnecting = false;
   /** Track whether a chatId is a group or C2C for correct API routing. */
@@ -1469,7 +1474,44 @@ var QQChannel = class extends ChannelBase {
   replyMsgId = /* @__PURE__ */ new Map();
   /** msg_seq counter per user messageId, for multi-block streaming. */
   msgSeqMap = /* @__PURE__ */ new Map();
+  /** Periodic cleanup timer for expired replyMsgId entries. */
+  replyMsgIdCleanupTimer = null;
+  /** 5-minute TTL for replyMsgId entries and seenMessages dedup. */
+  static REPLY_MSG_ID_TTL_MS = 3e5;
+  /** Idle-flush timeout: buffer is sent after this many ms of silence. */
+  static IDLE_FLUSH_MS = 2e3;
+  /** Max consecutive send failures before the stream is abandoned. */
+  static MAX_FLUSH_RETRIES = 3;
+  /** Retry delay for subsequent attempts (backoff beyond first retry). */
+  static IDLE_FLUSH_BACKOFF_MS = 4e3;
+  /** Max buffer length before forcing an immediate flush. */
+  static MAX_BUFFER_LENGTH = 4096;
   /** Path to persisted QQ routing state: chatTypeMap, replyMsgId, msgSeqMap. */
+  /**
+   * Streaming state machine with per-session buffers.
+   *
+   * Three states for each session:
+   *   active   — accumulating chunks in buffer (onResponseChunk extends timer)
+   *   flushing — sendMessage() is in-flight (prevents parallel sends)
+   *   idle     — waiting for next chunk (timer counting down to idleFlush)
+   *
+   * Transitions:
+   *   active → flushing: idleFlush timer fires, or onToolCall cancels timer
+   *   flushing → idle: send settles, idle timer restarts on retry
+   *   any → done: onResponseComplete sends remaining content
+   *
+   * Guards:
+   *   - flushingSessions prevents concurrent sends per session
+   *   - pendingStreamDelete defers cleanup until in-flight send resolves
+   *   - flushedSessions tracks already-sent sessions to skip final fullText
+   */
+  // ── Streaming state ───────────────────────────────────────────
+  streamState = /* @__PURE__ */ new Map();
+  flushingSessions = /* @__PURE__ */ new Set();
+  pendingStreamDelete = /* @__PURE__ */ new Set();
+  reconnectId = 0;
+  blockStreaming = false;
+  flushedSessions = /* @__PURE__ */ new Set();
   qqStatePath;
   /**
    * Path to the SessionRouter persistence file we back up before shutdown.
@@ -1492,6 +1534,7 @@ var QQChannel = class extends ChannelBase {
       registerBridgeEvents: options?.registerBridgeEvents ?? !hasExternalRouter
     });
     this.qqConfig = config;
+    this.blockStreaming = this.config.blockStreaming === "on";
     this.qqStatePath = join2(stateDir, `${safeName}-state.json`);
     this.globalSessionsPath = hasExternalRouter ? join2(stateDir, "sessions.json") : sessionsPath;
     this.sessionsBackupPath = join2(stateDir, `${safeName}-sessions-backup.json`);
@@ -1499,76 +1542,151 @@ var QQChannel = class extends ChannelBase {
   // ── ChannelBase interface ──────────────────────────────────────
   async connect() {
     this.disposed = false;
+    this.reconnectId++;
     if (!this.config.instructions) {
       this.config.instructions = [
         "## QQ Bot Channel",
         "",
         "\u4F60\u662F\u901A\u8FC7 QQ Bot \u4E0E\u7528\u6237\u5BF9\u8BDD\u7684 AI \u52A9\u624B\u3002",
-        "\u56DE\u590D\u63A7\u5236\u5728 2000 \u5B57\u7B26\u4EE5\u5185\uFF08\u8D85\u957F\u4F1A\u81EA\u52A8\u5206\u5757\uFF09\uFF0C\u652F\u6301 Markdown \u683C\u5F0F\u3002"
+        "\u56DE\u590D\u63A7\u5236\u5728 2000 \u5B57\u7B26\u4EE5\u5185\uFF0C\u652F\u6301 Markdown \u683C\u5F0F\u3002"
       ].join("\n");
     }
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
         await this.fetchToken();
         await this.connectGateway();
+        if (this.beforeExitHook) {
+          process.off("beforeExit", this.beforeExitHook);
+        }
+        this.beforeExitHook = () => this.flushQQState();
+        process.on("beforeExit", this.beforeExitHook);
+        this.startReplyMsgIdCleanup();
         return;
       } catch (e) {
         if (attempt < 2) {
           const msg = e instanceof Error ? e.message : String(e);
-          process.stderr.write(`[QQ:${this.name}] Connect attempt ${attempt + 1} failed: ${msg}, retrying...
+          process.stderr.write(`[QQ:${this.name}] Connect attempt ${attempt + 1} failed: ${sanitizeLogText(msg, 200)}, retrying...
 `);
           await this.sleep(2e3);
         } else {
-          throw e;
+          throw new Error(sanitizeLogText(e instanceof Error ? e.message : String(e), 200), { cause: e });
         }
       }
     }
   }
   async sendMessage(chatId, text) {
+    if (text.trim() === "<noreply>") {
+      process.stderr.write(`[QQ:${this.name}] <noreply> skipped for ${sanitizeLogText(chatId, 64)}
+`);
+      return;
+    }
     const route = await this.resolveRoute(chatId);
     if (!route)
       return;
-    const msgId = this.replyMsgId.get(chatId);
-    const useMarkdown = hasMarkdownSyntax(text);
-    for (const chunk of splitText(text)) {
-      try {
-        const body = useMarkdown ? { msg_type: 2, markdown: { content: chunk } } : { content: chunk, msg_type: 0 };
-        const nextSeq = msgId ? (this.msgSeqMap.get(msgId) ?? 0) + 1 : 0;
-        if (msgId) {
-          body["msg_id"] = msgId;
-          body["msg_seq"] = nextSeq;
-        }
-        let resp = await sendQQMessage(route.base, route.path, this.accessToken, body);
-        if (!resp.ok && useMarkdown) {
-          const errBody = await resp.text().catch(() => "");
-          process.stderr.write(`[QQ:${this.name}] Markdown rejected (HTTP ${resp.status}: ${errBody.slice(0, 100)}), retrying as plain text
+    const entry = this.replyMsgId.get(chatId);
+    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.saveQQState();
+    }
+    let nextSeq = 0;
+    let rollbackApplied = false;
+    try {
+      const body = {
+        msg_type: 2,
+        markdown: { content: text }
+      };
+      nextSeq = msgId ? (this.msgSeqMap.get(msgId) ?? 0) + 1 : 0;
+      if (msgId) {
+        this.msgSeqMap.set(msgId, nextSeq);
+        body["msg_id"] = msgId;
+        body["msg_seq"] = nextSeq;
+      }
+      const resp = await sendQQMessage(route.base, route.path, this.accessToken, body);
+      if (!resp.ok) {
+        const errBody = await resp.text().catch(() => "");
+        process.stderr.write(`[QQ:${this.name}] Send failed (HTTP ${resp.status}: ${sanitizeLogText(errBody, 200)})
+`);
+        if (resp.status === 429) {
+          process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: rate-limited (429) on markdown attempt for ${sanitizeLogText(chatId, 64)}
 `);
-          const plainBody = {
-            content: chunk,
-            msg_type: 0
-          };
           if (msgId) {
-            plainBody["msg_id"] = msgId;
-            plainBody["msg_seq"] = nextSeq;
+            this.msgSeqMap.set(msgId, nextSeq - 1);
+            this.saveQQState();
           }
-          resp = await sendQQMessage(route.base, route.path, this.accessToken, plainBody);
+          return;
         }
-        if (!resp.ok) {
-          const errBody = await resp.text().catch(() => "");
-          process.stderr.write(`[QQ:${this.name}] Send HTTP ${resp.status} (msg_seq=${body["msg_seq"] ?? "-"}): ${errBody.slice(0, 200)}
+        if (msgId) {
+          this.msgSeqMap.set(msgId, nextSeq - 1);
+          rollbackApplied = true;
+          const activeBody = {
+            content: text,
+            msg_type: 0,
+            msg_id: msgId,
+            msg_seq: nextSeq
+          };
+          const activeResp = await sendQQMessage(route.base, route.path, this.accessToken, activeBody);
+          if (activeResp.ok) {
+            process.stderr.write(`[QQ:${this.name}] Active retry succeeded for ${sanitizeLogText(chatId, 64)}
 `);
-          break;
+            const current = this.replyMsgId.get(chatId);
+            if (current?.msgId === msgId) {
+              this.msgSeqMap.set(msgId, nextSeq);
+            }
+            this.saveQQState();
+            await activeResp.text().catch(() => "");
+            return;
+          }
+          process.stderr.write(`[QQ:${this.name}] Active retry also failed (HTTP ${activeResp.status}: ${sanitizeLogText(await activeResp.text().catch(() => ""), 200)})
+`);
+          if (activeResp.status === 429) {
+            process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: active retry rate-limited (HTTP 429) for ${sanitizeLogText(chatId, 64)}
+`);
+            this.saveQQState();
+            return;
+          }
+          process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: both passive and active send failed for ${sanitizeLogText(chatId, 64)}
+`);
+          this.saveQQState();
+          return;
         }
-        if (msgId)
-          this.msgSeqMap.set(msgId, nextSeq);
-      } catch (e) {
-        process.stderr.write(`[QQ:${this.name}] Send error: ${e}
+        const plainBody = {
+          content: text,
+          msg_type: 0
+        };
+        const fallbackRes = await sendQQMessage(route.base, route.path, this.accessToken, plainBody);
+        if (!fallbackRes.ok) {
+          const fbErrBody = await fallbackRes.text().catch(() => "");
+          if (fallbackRes.status === 429) {
+            process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: rate-limited (429) on plain-text fallback for ${sanitizeLogText(chatId, 64)}
 `);
-        break;
+            return;
+          }
+          process.stderr.write(`[QQ:${this.name}] MESSAGE DROPPED: plain-text fallback failed (HTTP ${fallbackRes.status}: ${sanitizeLogText(fbErrBody, 200)}) for ${sanitizeLogText(chatId, 64)}
+`);
+          return;
+        }
+        process.stderr.write(`[QQ:${this.name}] Plain-text fallback succeeded for ${sanitizeLogText(chatId, 64)}
+`);
+        await fallbackRes.text().catch(() => "");
+        return;
       }
+      await resp.text().catch(() => "");
+      if (msgId)
+        this.saveQQState();
+    } catch (e) {
+      if (msgId && !rollbackApplied) {
+        this.msgSeqMap.set(msgId, nextSeq - 1);
+      }
+      if (msgId)
+        this.saveQQState();
+      process.stderr.write(`[QQ:${this.name}] Send error: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
+`);
+      throw e;
     }
-    if (msgId)
-      this.saveQQState();
   }
   /**
    * Resolve API routing: handles disposed check, token refresh, chatId validation,
@@ -1594,6 +1712,7 @@ var QQChannel = class extends ChannelBase {
     this.disposed = true;
     this.stopHeartbeat();
     this.stopTokenRefresh();
+    this.stopReplyMsgIdCleanup();
     if (this.seenCleanupTimer) {
       clearInterval(this.seenCleanupTimer);
       this.seenCleanupTimer = null;
@@ -1602,8 +1721,16 @@ var QQChannel = class extends ChannelBase {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
+    if (this.beforeExitHook) {
+      process.off("beforeExit", this.beforeExitHook);
+      this.beforeExitHook = null;
+    }
     this.flushQQState();
     this.backupGlobalSessions();
+    if (this.readyTimeout) {
+      clearTimeout(this.readyTimeout);
+      this.readyTimeout = null;
+    }
     if (this.ws) {
       this.ws.close(1e3);
       this.ws = null;
@@ -1615,6 +1742,16 @@ var QQChannel = class extends ChannelBase {
     this.chatTypeMap.clear();
     this.replyMsgId.clear();
     this.msgSeqMap.clear();
+    for (const [, state] of this.streamState) {
+      if (state.timer)
+        clearTimeout(state.timer);
+    }
+    this.streamState.clear();
+    this.flushingSessions.clear();
+    this.pendingStreamDelete.clear();
+    this.flushedSessions.clear();
+    this.seenMessages.clear();
+    this.reconnectId++;
   }
   /**
    * QQ Bot API V2 does not provide a typing indicator endpoint.
@@ -1625,21 +1762,210 @@ var QQChannel = class extends ChannelBase {
   }
   onPromptEnd(_chatId, _sessionId, _messageId) {
   }
+  // ── Streaming (idle-flush with per-session buffers) ────────────
+  onResponseChunk(chatId, chunk, sessionId) {
+    if (this.blockStreaming)
+      return;
+    let state = this.streamState.get(sessionId);
+    if (!state) {
+      state = { chatId, buffer: chunk, timer: null, retryCount: 0 };
+      this.streamState.set(sessionId, state);
+    } else {
+      state.buffer += chunk;
+      if (state.timer) {
+        clearTimeout(state.timer);
+        state.timer = null;
+      }
+      if (state.buffer.length >= _QQChannel.MAX_BUFFER_LENGTH) {
+        const buf = state.buffer;
+        state.buffer = "";
+        this.flushAndTrack(sessionId, buf, state, "idleFlush");
+        return;
+      }
+    }
+    const reconnectId = this.reconnectId;
+    state.timer = setTimeout(() => {
+      this.idleFlush(sessionId, reconnectId);
+    }, _QQChannel.IDLE_FLUSH_MS);
+    state.timer.unref?.();
+  }
+  idleFlush(sessionId, reconnectId) {
+    if (this.reconnectId !== reconnectId) {
+      process.stderr.write(`[QQ:${this.name}] idleFlush discarded (reconnect) session=${sanitizeLogText(sessionId, 32)}
+`);
+      return;
+    }
+    const state = this.streamState.get(sessionId);
+    if (!state || !state.buffer)
+      return;
+    if (this.flushingSessions.has(sessionId)) {
+      if (!state.timer) {
+        const retryReconnectId = this.reconnectId;
+        state.timer = setTimeout(() => {
+          this.idleFlush(sessionId, retryReconnectId);
+        }, _QQChannel.IDLE_FLUSH_MS);
+        state.timer.unref?.();
+      }
+      return;
+    }
+    const buffer = state.buffer;
+    state.buffer = "";
+    state.timer = null;
+    this.flushAndTrack(sessionId, buffer, state, "idleFlush");
+  }
+  /**
+   * Shared send-and-track helper used by idleFlush and onToolCall.
+   * Encapsulates .then() (cleanup on success) and .catch() (retry/re-buffer
+   * on failure) logic to eliminate duplication.
+   */
+  flushAndTrack(sessionId, buffer, state, logLabel) {
+    this.flushingSessions.add(sessionId);
+    this.sendMessage(state.chatId, buffer).then(() => {
+      const current = this.streamState.get(sessionId);
+      if (current !== state)
+        return;
+      current.retryCount = 0;
+      this.flushedSessions.add(sessionId);
+      if (this.pendingStreamDelete.has(sessionId)) {
+        this.pendingStreamDelete.delete(sessionId);
+        const s2 = this.streamState.get(sessionId);
+        if (s2 === state && s2.buffer) {
+          this.idleFlush(sessionId, this.reconnectId);
+        }
+      }
+      const s = this.streamState.get(sessionId);
+      if (s === state && !s.buffer) {
+        this.streamState.delete(sessionId);
+      }
+    }).catch((e) => {
+      process.stderr.write(`[QQ:${this.name}] ${logLabel} send failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
+`);
+      if (this.pendingStreamDelete.has(sessionId)) {
+        this.pendingStreamDelete.delete(sessionId);
+        const current = this.streamState.get(sessionId);
+        if (current === state) {
+          current.buffer = buffer;
+          current.retryCount++;
+          if (current.retryCount < _QQChannel.MAX_FLUSH_RETRIES) {
+            const reconnectId = this.reconnectId;
+            const delay = current.retryCount > 1 ? _QQChannel.IDLE_FLUSH_BACKOFF_MS : _QQChannel.IDLE_FLUSH_MS;
+            current.timer = setTimeout(() => {
+              this.idleFlush(sessionId, reconnectId);
+            }, delay);
+            current.timer.unref?.();
+          } else {
+            this.streamState.delete(sessionId);
+            this.flushedSessions.delete(sessionId);
+            process.stderr.write(`[QQ:${this.name}] ${logLabel} retries exhausted for ${sanitizeLogText(sessionId, 64)}
+`);
+          }
+        }
+      } else {
+        const current = this.streamState.get(sessionId);
+        if (current === state) {
+          current.buffer = buffer + (current.buffer || "");
+          if (current.buffer.length >= _QQChannel.MAX_BUFFER_LENGTH) {
+            this.idleFlush(sessionId, this.reconnectId);
+          } else {
+            current.retryCount++;
+            if (current.retryCount < _QQChannel.MAX_FLUSH_RETRIES) {
+              if (!current.timer) {
+                const reconnectId = this.reconnectId;
+                const delay = current.retryCount > 1 ? _QQChannel.IDLE_FLUSH_BACKOFF_MS : _QQChannel.IDLE_FLUSH_MS;
+                current.timer = setTimeout(() => {
+                  this.idleFlush(sessionId, reconnectId);
+                }, delay);
+                current.timer.unref?.();
+              }
+            } else {
+              this.streamState.delete(sessionId);
+              this.flushedSessions.delete(sessionId);
+              process.stderr.write(`[QQ:${this.name}] ${logLabel} retries exhausted for ${sanitizeLogText(sessionId, 64)}
+`);
+            }
+          }
+        }
+      }
+    }).finally(() => {
+      const current = this.streamState.get(sessionId);
+      if (!current || current === state) {
+        this.flushingSessions.delete(sessionId);
+      }
+    });
+  }
+  onToolCall(_chatId, event) {
+    const state = this.streamState.get(event.sessionId);
+    if (!state || !state.buffer)
+      return;
+    if (this.flushingSessions.has(event.sessionId))
+      return;
+    if (state.timer) {
+      clearTimeout(state.timer);
+      state.timer = null;
+    }
+    const buffer = state.buffer;
+    state.buffer = "";
+    this.flushAndTrack(event.sessionId, buffer, state, "toolCallFlush");
+  }
+  async onResponseComplete(chatId, fullText, sessionId) {
+    const state = this.streamState.get(sessionId);
+    if (state?.timer) {
+      clearTimeout(state.timer);
+      state.timer = null;
+    }
+    if (state && this.flushingSessions.has(sessionId)) {
+      this.pendingStreamDelete.add(sessionId);
+      process.stderr.write(`[QQ:${this.name}] onResponseComplete deferred (flush in-flight) session=${sanitizeLogText(sessionId, 32)}
+`);
+      return;
+    }
+    const wasFlushed = this.flushedSessions.has(sessionId);
+    const remaining = state?.buffer ?? (wasFlushed ? "" : fullText);
+    this.streamState.delete(sessionId);
+    this.flushedSessions.delete(sessionId);
+    if (remaining) {
+      await super.onResponseComplete(chatId, remaining, sessionId);
+    }
+  }
+  onSessionDied(sessionId) {
+    const state = this.streamState.get(sessionId);
+    if (state?.timer) {
+      clearTimeout(state.timer);
+    }
+    this.streamState.delete(sessionId);
+    this.flushingSessions.delete(sessionId);
+    this.pendingStreamDelete.delete(sessionId);
+    this.flushedSessions.delete(sessionId);
+    super.onSessionDied(sessionId);
+  }
   // ── State Persistence (cross-server context continuation) ──────
   /** Debounced state persistence to avoid blocking event loop. */
   saveQQState() {
+    if (this.disposed)
+      return;
     if (this.saveTimer)
       clearTimeout(this.saveTimer);
+    const tmpPath = this.qqStatePath + ".tmp";
     this.saveTimer = setTimeout(() => {
+      if (this.disposed)
+        return;
       try {
-        writeFileSync2(this.qqStatePath, JSON.stringify({
+        writeFileSync2(tmpPath, JSON.stringify({
           chatTypeMap: Array.from(this.chatTypeMap.entries()),
           replyMsgId: Array.from(this.replyMsgId.entries()),
           msgSeqMap: Array.from(this.msgSeqMap.entries())
         }), { mode: 384 });
-      } catch {
+        renameSync(tmpPath, this.qqStatePath);
+      } catch (e) {
+        try {
+          unlinkSync(tmpPath);
+        } catch {
+        }
+        process.stderr.write(`[QQ:${this.name}] saveQQState write failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
+`);
       }
     }, 500);
+    this.saveTimer.unref();
   }
   /** Flush pending state writes immediately (called on disconnect). */
   flushQQState() {
@@ -1647,35 +1973,78 @@ var QQChannel = class extends ChannelBase {
       clearTimeout(this.saveTimer);
       this.saveTimer = null;
     }
+    const tmpPath = this.qqStatePath + ".tmp";
     try {
-      writeFileSync2(this.qqStatePath, JSON.stringify({
+      writeFileSync2(tmpPath, JSON.stringify({
         chatTypeMap: Array.from(this.chatTypeMap.entries()),
         replyMsgId: Array.from(this.replyMsgId.entries()),
         msgSeqMap: Array.from(this.msgSeqMap.entries())
-      }));
-    } catch {
+      }), { mode: 384 });
+      renameSync(tmpPath, this.qqStatePath);
+    } catch (e) {
+      try {
+        unlinkSync(tmpPath);
+      } catch {
+      }
+      process.stderr.write(`[QQ:${this.name}] flushQQState write failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
+`);
     }
   }
   /**
    * Restore QQ routing state from disk.
-   * Trusts persisted JSON — if the file is corrupt, new Map() may create
-   * entries with undefined values, causing get()===undefined to fall through
-   * to default routing (C2C). This is acceptable for a rare edge case.
+   * Validates and filters every entry on restore — corrupt or unexpected
+   * entries (e.g. unknown chat types, oversized replyMsgIds, negative seqs)
+   * are silently dropped so they don't propagate into runtime routing.
    */
   restoreQQState() {
     try {
       if (!existsSync2(this.qqStatePath))
         return false;
       const raw = JSON.parse(readFileSync2(this.qqStatePath, "utf-8"));
-      if (raw.chatTypeMap)
-        this.chatTypeMap = new Map(raw.chatTypeMap);
-      if (raw.replyMsgId)
-        this.replyMsgId = new Map(raw.replyMsgId);
-      if (raw.msgSeqMap)
-        this.msgSeqMap = new Map(raw.msgSeqMap);
+      if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        process.stderr.write(`[QQ:${this.name}] Invalid QQ state file (not an object), ignoring
+`);
+        return false;
+      }
+      if (raw.chatTypeMap && Array.isArray(raw.chatTypeMap)) {
+        const rawCT = raw.chatTypeMap;
+        this.chatTypeMap = new Map(rawCT.filter(([k, v]) => typeof k === "string" && k.length <= 256 && (v === "c2c" || v === "group")));
+        const dropped = rawCT.length - this.chatTypeMap.size;
+        if (dropped > 0)
+          process.stderr.write(`[QQ:${this.name}] Dropped ${dropped} invalid chatTypeMap entries during restore
+`);
+      }
+      if (raw.replyMsgId && Array.isArray(raw.replyMsgId)) {
+        const now = Date.now();
+        const rawRM = raw.replyMsgId;
+        this.replyMsgId = new Map(rawRM.map(([k, v]) => (
+          // Old format: string -> { msgId: v, timestamp: now }
+          // New format: { msgId, timestamp } -> pass through
+          typeof v === "string" ? [k, { msgId: v, timestamp: now }] : [k, v]
+        )).filter(([k, v]) => {
+          if (typeof k !== "string" || k.length > 256)
+            return false;
+          if (typeof v !== "object" || v === null)
+            return false;
+          const entry = v;
+          return typeof entry.msgId === "string" && entry.msgId.length <= 128 && typeof entry.timestamp === "number" && Number.isFinite(entry.timestamp) && entry.timestamp <= now + _QQChannel.REPLY_MSG_ID_TTL_MS;
+        }));
+        const dropped = rawRM.length - this.replyMsgId.size;
+        if (dropped > 0)
+          process.stderr.write(`[QQ:${this.name}] Dropped ${dropped} invalid replyMsgId entries during restore
+`);
+      }
+      if (raw.msgSeqMap && Array.isArray(raw.msgSeqMap)) {
+        const rawMS = raw.msgSeqMap;
+        this.msgSeqMap = new Map(rawMS.filter(([k, v]) => typeof k === "string" && k.length <= 256 && typeof v === "number" && Number.isSafeInteger(v) && v >= 0));
+        const dropped = rawMS.length - this.msgSeqMap.size;
+        if (dropped > 0)
+          process.stderr.write(`[QQ:${this.name}] Dropped ${dropped} invalid msgSeqMap entries during restore
+`);
+      }
       return true;
     } catch (e) {
-      process.stderr.write(`[QQ:${this.name}] Failed to restore QQ state: ${e instanceof Error ? e.message : String(e)}
+      process.stderr.write(`[QQ:${this.name}] Failed to restore QQ state: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
 `);
       return false;
     }
@@ -1744,6 +2113,47 @@ var QQChannel = class extends ChannelBase {
     } catch {
     }
   }
+  // ── 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() });
+    this.saveQQState();
+  }
+  /**
+   * Start periodic cleanup of expired replyMsgId entries.
+   * Evicts entries older than 5 minutes every 60 seconds, and cascades
+   * to msgSeqMap.
+   */
+  startReplyMsgIdCleanup() {
+    this.stopReplyMsgIdCleanup();
+    this.replyMsgIdCleanupTimer = setInterval(() => {
+      const cutoff = Date.now() - _QQChannel.REPLY_MSG_ID_TTL_MS;
+      let dirty = false;
+      for (const [chatId, entry] of this.replyMsgId) {
+        if (entry.timestamp < cutoff) {
+          this.msgSeqMap.delete(entry.msgId);
+          this.replyMsgId.delete(chatId);
+          dirty = true;
+        }
+      }
+      if (dirty)
+        this.saveQQState();
+    }, 6e4);
+    this.replyMsgIdCleanupTimer.unref();
+  }
+  stopReplyMsgIdCleanup() {
+    if (this.replyMsgIdCleanupTimer) {
+      clearInterval(this.replyMsgIdCleanupTimer);
+      this.replyMsgIdCleanupTimer = null;
+    }
+  }
   // ── Token ──────────────────────────────────────────────────────
   async fetchToken() {
     const safeName = this.name.replace(/[^A-Za-z0-9_-]/g, "_");
@@ -1785,7 +2195,7 @@ var QQChannel = class extends ChannelBase {
         this.fetchToken().catch((e) => {
           if (this.disposed)
             return;
-          process.stderr.write(`[QQ:${this.name}] Token refresh failed: ${e}, retrying in 60s
+          process.stderr.write(`[QQ:${this.name}] Token refresh failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}, retrying in 60s
 `);
           this.scheduleTokenRefreshRetry();
         });
@@ -1800,7 +2210,7 @@ var QQChannel = class extends ChannelBase {
       this.fetchToken().catch((e) => {
         if (this.disposed)
           return;
-        process.stderr.write(`[QQ:${this.name}] Token refresh failed: ${e}, retrying in 60s
+        process.stderr.write(`[QQ:${this.name}] Token refresh failed: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}, retrying in 60s
 `);
         this.scheduleTokenRefreshRetry();
       });
@@ -1825,6 +2235,13 @@ var QQChannel = class extends ChannelBase {
   dialGateway(url, resolve, reject) {
     this.ws = new wrapper_default(url);
     const dialed = this.ws;
+    this.readyTimeout = setTimeout(() => {
+      if (this.ws !== dialed)
+        return;
+      this.ws.close(4002, "READY timeout");
+      reject(new Error(`[QQ:${this.name}] READY timeout after 30s`));
+    }, 3e4);
+    this.readyTimeout.unref?.();
     this.ws.on("open", () => {
       process.stderr.write(`[QQ:${this.name}] WebSocket connected
 `);
@@ -1834,7 +2251,7 @@ var QQChannel = class extends ChannelBase {
         const msg = JSON.parse(data.toString());
         this.handleGatewayMessage(msg, resolve);
       } catch (e) {
-        process.stderr.write(`[QQ:${this.name}] Malformed gateway message: ${e instanceof Error ? e.message : String(e)}
+        process.stderr.write(`[QQ:${this.name}] Malformed gateway message: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
 `);
       }
     });
@@ -1843,6 +2260,10 @@ var QQChannel = class extends ChannelBase {
         return;
       process.stderr.write(`[QQ:${this.name}] WebSocket closed (code=${code})
 `);
+      if (this.readyTimeout) {
+        clearTimeout(this.readyTimeout);
+        this.readyTimeout = null;
+      }
       this.stopHeartbeat();
       this.ws = null;
       const shouldReconnect = this.serverRequestedReconnect || code !== 1e3 && this.reconnectAttempts < this.maxReconnectAttempts;
@@ -1874,7 +2295,7 @@ var QQChannel = class extends ChannelBase {
       }
     });
     this.ws.on("error", (e) => {
-      process.stderr.write(`[QQ:${this.name}] WebSocket error: ${e.message}
+      process.stderr.write(`[QQ:${this.name}] WebSocket error: ${sanitizeLogText(e.message, 200)}
 `);
       if (!this.ws || this.ws.readyState !== wrapper_default.OPEN) {
         reject(e);
@@ -1897,6 +2318,10 @@ var QQChannel = class extends ChannelBase {
         if (t === "READY") {
           this.reconnectAttempts = 0;
           this.isReconnecting = false;
+          if (this.readyTimeout) {
+            clearTimeout(this.readyTimeout);
+            this.readyTimeout = null;
+          }
           this.sessionId = msg["d"]?.["session_id"] || "";
           this.tryResume = true;
           this.connectReject = null;
@@ -1918,6 +2343,10 @@ var QQChannel = class extends ChannelBase {
         } else if (t === "RESUMED") {
           this.reconnectAttempts = 0;
           this.isReconnecting = false;
+          if (this.readyTimeout) {
+            clearTimeout(this.readyTimeout);
+            this.readyTimeout = null;
+          }
           this.connectReject = null;
           this.startHeartbeat();
           onReady();
@@ -2002,7 +2431,7 @@ var QQChannel = class extends ChannelBase {
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
         const backoff = Math.min(1e3 * 2 ** (attempt + 1), 3e4);
-        process.stderr.write(`[QQ:${this.name}] RC: ${msg} (retry in ${backoff}ms, attempt ${attempt + 1}/${maxGwRetries})
+        process.stderr.write(`[QQ:${this.name}] RC: ${sanitizeLogText(msg, 200)} (retry in ${backoff}ms, attempt ${attempt + 1}/${maxGwRetries})
 `);
         if (attempt < maxGwRetries - 1)
           await this.sleep(backoff);
@@ -2035,6 +2464,7 @@ var QQChannel = class extends ChannelBase {
       }
       this.ws.send(JSON.stringify({ op: OpCode.HEARTBEAT, d: this.seq }));
     }, this.heartbeatInterval);
+    this.heartbeatTimer.unref();
   }
   stopHeartbeat() {
     if (this.heartbeatTimer) {
@@ -2051,7 +2481,7 @@ var QQChannel = class extends ChannelBase {
     this.seenMessages.set(eventId, now);
     if (!this.seenCleanupTimer) {
       this.seenCleanupTimer = setInterval(() => {
-        const cutoff = Date.now() - 3e5;
+        const cutoff = Date.now() - _QQChannel.REPLY_MSG_ID_TTL_MS;
         for (const [id, ts] of this.seenMessages) {
           if (ts < cutoff)
             this.seenMessages.delete(id);
@@ -2060,7 +2490,7 @@ var QQChannel = class extends ChannelBase {
           clearInterval(this.seenCleanupTimer);
           this.seenCleanupTimer = null;
         }
-      }, 6e4);
+      }, 6e4).unref();
     }
     return false;
   }
@@ -2069,10 +2499,11 @@ var QQChannel = class extends ChannelBase {
       return;
     if (!event.content?.trim())
       return;
+    if (!event.author)
+      return;
     const chatId = event.author.user_openid || event.author.id;
     this.chatTypeMap.set(chatId, "c2c");
-    this.replyMsgId.set(chatId, event.id);
-    this.saveQQState();
+    this.setReplyMsgId(chatId, event.id);
     this.handleInbound({
       channelName: this.name,
       senderId: chatId,
@@ -2083,7 +2514,7 @@ var QQChannel = class extends ChannelBase {
       isGroup: false,
       isMentioned: true,
       isReplyToBot: false
-    }).catch((e) => process.stderr.write(`[QQ:${this.name}] C2C handler error: ${e}
+    }).catch((e) => process.stderr.write(`[QQ:${this.name}] C2C handler error: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
 `));
   }
   handleGroup(event) {
@@ -2096,8 +2527,7 @@ var QQChannel = class extends ChannelBase {
     }
     const chatId = event.group_openid;
     this.chatTypeMap.set(chatId, "group");
-    this.replyMsgId.set(chatId, event.id);
-    this.saveQQState();
+    this.setReplyMsgId(chatId, event.id);
     const senderName = event.author.username || event.author.id || "QQ User";
     const cleanText = (event.content || "").replace(/<@[^>]{1,64}>/g, "").trim();
     if (!cleanText)
@@ -2123,7 +2553,7 @@ var QQChannel = class extends ChannelBase {
       // every group message is semantically a reply to the bot.
       isReplyToBot: true,
       ...isSlash ? {} : { alreadyPrefixed: true }
-    }).catch((e) => process.stderr.write(`[QQ:${this.name}] Group handler error: ${e}
+    }).catch((e) => process.stderr.write(`[QQ:${this.name}] Group handler error: ${sanitizeLogText(e instanceof Error ? e.message : String(e), 200)}
 `));
   }
 };