@qwen-code/qwen-code 0.19.8 → 0.19.9

package/chunks/{de-ZFPPQVSF.js → de-EBJN3OVN.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import "./chunk-J2S4EL5Y.js";
 
 // packages/cli/src/i18n/locales/de.js
@@ -168,6 +168,42 @@ var de_default = {
   "Delete {{name}}": "{{name}} l\xF6schen",
   "Unknown Step": "Unbekannter Schritt",
   "Esc to close": "Esc zum Schlie\xDFen",
+  Transcript: "Transkript",
+  "to close": "zum Schlie\xDFen",
+  "to scroll": "zum Scrollen",
+  "Failed to render transcript.": "Transkript konnte nicht gerendert werden.",
+  "Read {{count}} file": "{{count}} Datei gelesen",
+  "Read {{count}} files": "{{count}} Dateien gelesen",
+  "Reading {{count}} file": "Lese {{count}} Datei",
+  "Reading {{count}} files": "Lese {{count}} Dateien",
+  "Edited {{count}} file": "{{count}} Datei bearbeitet",
+  "Edited {{count}} files": "{{count}} Dateien bearbeitet",
+  "Editing {{count}} file": "Bearbeite {{count}} Datei",
+  "Editing {{count}} files": "Bearbeite {{count}} Dateien",
+  "Wrote {{count}} file": "{{count}} Datei geschrieben",
+  "Wrote {{count}} files": "{{count}} Dateien geschrieben",
+  "Writing {{count}} file": "Schreibe {{count}} Datei",
+  "Writing {{count}} files": "Schreibe {{count}} Dateien",
+  "Searched {{count}} pattern": "{{count}} Muster durchsucht",
+  "Searched {{count}} patterns": "{{count}} Muster durchsucht",
+  "Searching {{count}} pattern": "Durchsuche {{count}} Muster",
+  "Searching {{count}} patterns": "Durchsuche {{count}} Muster",
+  "Listed {{count}} directory": "{{count}} Verzeichnis aufgelistet",
+  "Listed {{count}} directories": "{{count}} Verzeichnisse aufgelistet",
+  "Listing {{count}} directory": "Liste {{count}} Verzeichnis auf",
+  "Listing {{count}} directories": "Liste {{count}} Verzeichnisse auf",
+  "Ran {{count}} command": "{{count}} Befehl ausgef\xFChrt",
+  "Ran {{count}} commands": "{{count}} Befehle ausgef\xFChrt",
+  "Running {{count}} command": "F\xFChre {{count}} Befehl aus",
+  "Running {{count}} commands": "F\xFChre {{count}} Befehle aus",
+  "Ran {{count}} agent": "{{count}} Agent ausgef\xFChrt",
+  "Ran {{count}} agents": "{{count}} Agenten ausgef\xFChrt",
+  "Running {{count}} agent": "F\xFChre {{count}} Agent aus",
+  "Running {{count}} agents": "F\xFChre {{count}} Agenten aus",
+  "Used {{count}} tool": "{{count}} Werkzeug verwendet",
+  "Used {{count}} tools": "{{count}} Werkzeuge verwendet",
+  "Using {{count}} tool": "Verwende {{count}} Werkzeug",
+  "Using {{count}} tools": "Verwende {{count}} Werkzeuge",
   "Enter to select, \u2191\u2193 to navigate, Esc to close": "Enter zum Ausw\xE4hlen, \u2191\u2193 zum Navigieren, Esc zum Schlie\xDFen",
   "Esc to go back": "Esc zum Zur\xFCckgehen",
   "Enter to confirm, Esc to cancel": "Enter zum Best\xE4tigen, Esc zum Abbrechen",
@@ -1277,7 +1313,6 @@ var de_default = {
   "You can switch permission mode quickly with Shift+Tab or /approval-mode.": "Sie k\xF6nnen den Berechtigungsmodus schnell mit Shift+Tab oder /approval-mode wechseln.",
   "You can switch permission mode quickly with Tab or /approval-mode.": "Sie k\xF6nnen den Berechtigungsmodus schnell mit Tab oder /approval-mode wechseln.",
   "Try /insight to generate personalized insights from your chat history.": "Probieren Sie /insight, um personalisierte Erkenntnisse aus Ihrem Chatverlauf zu erstellen.",
-  "Press Ctrl+O to toggle compact mode \u2014 hide tool output and thinking for a cleaner view.": "Ctrl+O dr\xFCcken, um den Kompaktmodus umzuschalten \u2014 Tool-Ausgabe und Denkprozess ausblenden.",
   "Add a QWEN.md file to give Qwen Code persistent project context.": "F\xFCgen Sie eine QWEN.md-Datei hinzu, um Qwen Code dauerhaften Projektkontext zu geben.",
   "Use /btw to ask a quick side question without disrupting the conversation.": "Verwenden Sie /btw, um eine kurze Nebenfrage zu stellen, ohne die Unterhaltung zu unterbrechen.",
   "Context is almost full! Run /compress now or start /new to continue.": "Der Kontext ist fast voll! F\xFChren Sie jetzt /compress aus oder starten Sie /new, um fortzufahren.",
@@ -1387,9 +1422,7 @@ var de_default = {
   "Select an option:": "Option ausw\xE4hlen:",
   "Raw mode not available. Please run in an interactive terminal.": "Raw-Modus nicht verf\xFCgbar. Bitte in einem interaktiven Terminal ausf\xFChren.",
   "(Use \u2191 \u2193 arrows to navigate, Enter to select, Ctrl+C to exit)\n": "(\u2191 \u2193 Pfeiltasten zum Navigieren, Enter zum Ausw\xE4hlen, Ctrl+C zum Beenden)\n",
-  "to toggle compact mode": "Kompaktmodus umschalten",
-  "Hide tool output and thinking for a cleaner view (toggle with Ctrl+O).": "Tool-Ausgabe und Denkprozess ausblenden f\xFCr eine \xFCbersichtlichere Ansicht (mit Ctrl+O umschalten).",
-  "Press Ctrl+O to show full tool output": "Ctrl+O f\xFCr vollst\xE4ndige Tool-Ausgabe dr\xFCcken",
+  "to view transcript": "zum Anzeigen des Transkripts",
   "Switch to plan mode or exit plan mode": "In den Plan-Modus wechseln oder den Plan-Modus verlassen",
   "Set how hard reasoning-capable models think ({{tiers}}); mapped and clamped per provider.": "Legt fest, wie intensiv schlussfolgerungsf\xE4hige Modelle denken ({{tiers}}); je nach Anbieter zugeordnet und begrenzt.",
   "Exited plan mode. Previous approval mode restored.": "Plan-Modus verlassen. Vorheriger Genehmigungsmodus wiederhergestellt.",
@@ -1557,6 +1590,32 @@ var de_default = {
   in: "ein",
   out: "aus",
   "In/Out": "Ein/Aus",
+  // Update command
+  "Check for Qwen Code updates and install if available": "Auf Qwen Code-Updates pr\xFCfen und installieren, falls verf\xFCgbar",
+  "Qwen Code update available! {{current}} \u2192 {{latest}}": "Qwen Code-Update verf\xFCgbar! {{current}} \u2192 {{latest}}",
+  "A new version of Qwen Code is available! {{current}} \u2192 {{latest}}": "Eine neue Version von Qwen Code ist verf\xFCgbar! {{current}} \u2192 {{latest}}",
+  "Qwen Code {{version}} is up to date!": "Qwen Code {{version}} ist aktuell!",
+  "Failed to check for updates. Please check your network or registry configuration.": "Suche nach Updates fehlgeschlagen. Bitte Netzwerk- oder Registry-Konfiguration pr\xFCfen.",
+  "Unable to check for updates: {{reason}}": "Updates k\xF6nnen nicht gepr\xFCft werden: {{reason}}",
+  "Update successful! The new version will be used on your next run.": "Update erfolgreich! Die neue Version wird beim n\xE4chsten Start verwendet.",
+  "Update downloaded. It will be applied after you exit this session.": "Update heruntergeladen. Es wird nach dem Beenden dieser Sitzung angewendet.",
+  "Update failed: {{error}}": "Update fehlgeschlagen: {{error}}",
+  "Downloading update...": "Update wird heruntergeladen...",
+  "Update successful! Please restart Qwen Code to use the new version. Switching model providers before restarting may not work correctly.": "Update erfolgreich! Bitte starten Sie Qwen Code neu, um die neue Version zu verwenden. Das Wechseln von Modellanbietern vor dem Neustart funktioniert m\xF6glicherweise nicht korrekt.",
+  "Automatic update failed. Please try updating manually.": "Automatisches Update fehlgeschlagen. Bitte versuchen Sie, manuell zu aktualisieren.",
+  "Automatic update failed: {{error}}. Re-run the installer to update manually.": "Automatisches Update fehlgeschlagen: {{error}}. F\xFChren Sie das Installationsprogramm erneut aus, um manuell zu aktualisieren.",
+  'Running from a local git clone. Please update with "git pull".': 'Wird aus einem lokalen Git-Klon ausgef\xFChrt. Bitte mit "git pull" aktualisieren.',
+  "Running via npx, update not applicable.": "Wird \xFCber npx ausgef\xFChrt, Update nicht anwendbar.",
+  "Running via pnpx, update not applicable.": "Wird \xFCber pnpx ausgef\xFChrt, Update nicht anwendbar.",
+  "Running via bunx, update not applicable.": "Wird \xFCber bunx ausgef\xFChrt, Update nicht anwendbar.",
+  'Installed via Homebrew. Please update with "brew upgrade".': '\xDCber Homebrew installiert. Bitte mit "brew upgrade" aktualisieren.',
+  "Locally installed. Please update via your project's package.json.": "Lokal installiert. Bitte \xFCber die package.json Ihres Projekts aktualisieren.",
+  "Update requires sudo. Please run:": "Das Update erfordert sudo. Bitte ausf\xFChren:",
+  "Standalone install detected. Attempting to automatically update now...": "Standalone-Installation erkannt. Automatisches Update wird jetzt versucht...",
+  "Standalone install detected. Please rerun the standalone installer to update:": "Standalone-Installation erkannt. Bitte f\xFChren Sie den Standalone-Installer zum Aktualisieren erneut aus:",
+  "Run the following to update:": "F\xFChren Sie Folgendes zum Aktualisieren aus:",
+  "Unable to auto-update this standalone installation. Please reinstall from:": "Diese Standalone-Installation kann nicht automatisch aktualisiert werden. Bitte neu installieren von:",
+  "Manual update required. Please reinstall Qwen Code.": "Manuelles Update erforderlich. Bitte installieren Sie Qwen Code neu.",
   // ============================================================================
   // reload-plugins command
   // ============================================================================

package/chunks/{devtools-FM6GJPYG.js → devtools-4QFYJT6U.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   wrapper_default
-} from "./chunk-H6BD2ELD.js";
-import "./chunk-5IFG2VC4.js";
+} from "./chunk-TYAMGABM.js";
+import "./chunk-FCMNKVXT.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __commonJS,
   __name,

package/chunks/{dist-Z34QPAQW.js → dist-PNVLTKTL.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-34Z3U5RQ.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 && client.registered && 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 && client.registered && 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}";
@@ -4497,6 +4751,7 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     __name(this, "DingtalkChannel");
   }
   client;
+  connectionManager;
   seenMessages = /* @__PURE__ */ new Map();
   dedupTimer;
   /** Map conversationId → latest sessionWebhook URL for sending replies. */
@@ -4520,20 +4775,56 @@ var DingtalkChannel = class _DingtalkChannel extends ChannelBase {
     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 +4858,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 +4900,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) {
@@ -4806,7 +5097,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.
 `);
   }
@@ -5081,6 +5376,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;

package/chunks/{dist-63IS3ZMI.js → dist-PZV5RKM6.js}

@@ -2,9 +2,9 @@
 "use strict";
 import {
   require_dist
-} from "./chunk-ZERZSAZL.js";
-import "./chunk-QN5NZ3UQ.js";
-import "./chunk-BR4QREVK.js";
-import "./chunk-A4BMJM77.js";
+} from "./chunk-75DOP5OR.js";
+import "./chunk-DMTGGOSA.js";
+import "./chunk-YQ3U5MUC.js";
+import "./chunk-5O2XNYP6.js";
 import "./chunk-J2S4EL5Y.js";
 export default require_dist();