@xmanrui/dsh-im 4.17.1 → 4.18.1

package/src/channels/shared/text-harness-bridge.mjs

@@ -144,6 +144,7 @@ export class TextHarnessBridge {
   #logger;
   #replyTimeoutMs;
   #signal;
+  #keepaliveIntervalMs;
   #queues = new Map();
   #pendingInteractions = new Map();
   #interactionKeys = new Map();
@@ -165,6 +166,7 @@ export class TextHarnessBridge {
     logger = console,
     replyTimeoutMs = 600_000,
     signal,
+    keepaliveIntervalMs = 4_000,
   }) {
     if (!descriptor?.key || !descriptor?.label) throw new TypeError('A channel descriptor is required');
     if (!bot || typeof bot.sendText !== 'function') throw new TypeError('A bot client is required');
@@ -179,6 +181,7 @@ export class TextHarnessBridge {
     this.#logger = logger;
     this.#replyTimeoutMs = replyTimeoutMs;
     this.#signal = signal;
+    this.#keepaliveIntervalMs = keepaliveIntervalMs;
     this.#deferred = createDeferredDeliveryCoordinator({ harness, state, signal, logger,
       deliver: (entry, outcome) => this.#deliverDeferredOutcome(entry, outcome),
     });
@@ -586,6 +589,15 @@ export class TextHarnessBridge {
     const batchSubmission = message.batchSubmission;
     let stream = null;
     let semanticStream = false;
+    // A keepalive heartbeat keeps short-lived carriers (e.g. Telegram's
+    // private-chat Rich Draft) visible during long silent stretches such as a
+    // running tool call. Declared outside the try so every exit path (including
+    // pre-prompt failures like image parsing) clears the timer.
+    let keepaliveTimer = null;
+    const stopKeepalive = () => {
+      if (keepaliveTimer !== null) clearInterval(keepaliveTimer);
+      keepaliveTimer = null;
+    };
     try {
       this.#signal?.throwIfAborted();
       if (message.kind === 'group' && message.addressed !== true) {
@@ -685,6 +697,29 @@ export class TextHarnessBridge {
         }));
         contextEnhanced = content !== originalContent;
       }
+      // Start the keepalive only after the inbound payload is ready, so a
+      // pre-prompt failure (image parsing, context building) cannot leave the
+      // timer running; the outermost finally below clears it on every path.
+      if (stream && stream.keepalive === true && typeof stream.refresh === 'function') {
+        let refreshing = false;
+        keepaliveTimer = setInterval(async () => {
+          // Skip ticks while the previous heartbeat is pending so redundant
+          // refreshes cannot queue ahead of the final answer on a slow network.
+          if (refreshing) return;
+          refreshing = true;
+          try {
+            await Promise.allSettled([
+              this.#bot.sendTyping?.(target),
+              stream.refresh(),
+            ]);
+          } catch {
+            // Keepalive is best-effort, including synchronous adapter failures.
+          } finally {
+            refreshing = false;
+          }
+        }, this.#keepaliveIntervalMs);
+        keepaliveTimer.unref?.();
+      }
       const { answer, artifacts = [] } = await askInWorkspaceSession({
         deferredDelivery: () => ({ coordinator: this.#deferred, target: this.#descriptor.key === 'whatsapp' ? { jid: target.jid, selfChat: target.selfChat } : target }),
         harness: this.#harness,
@@ -719,6 +754,7 @@ export class TextHarnessBridge {
           files: message.files,
         },
       });
+      stopKeepalive();
       if (batchSubmission) {
         this.#batches.complete(conversationKey, batchSubmission.token);
       }
@@ -805,6 +841,7 @@ export class TextHarnessBridge {
       }
       return delivery.receipt;
     } catch (error) {
+      stopKeepalive();
       const turnStopped = error?.code === 'turn-stopped';
       if (batchSubmission && turnStopped) {
         this.#batches.complete(conversationKey, batchSubmission.token);
@@ -875,6 +912,7 @@ export class TextHarnessBridge {
       }
       return error.deliveryReceipt;
     } finally {
+      stopKeepalive();
       await Promise.allSettled([
         this.#cancelPendingInteraction(conversationKey),
         this.#approvals.closeRoute(conversationKey),

package/src/channels/telegram/telegram-runtime.mjs

@@ -325,48 +325,99 @@ class TelegramDeliveryStream {
   #providerMessageIds;
   #closed = false;
   #lastUpdate = null;
+  #lastBlock = null;
+  #keepalive = false;
+  #chain = Promise.resolve();
 
-  constructor({ update, finish, fail, providerMessageIds = [], presentation, logger }) {
+  constructor({
+    update,
+    finish,
+    fail,
+    providerMessageIds = [],
+    presentation,
+    logger,
+    keepalive = false,
+  }) {
     this.#update = update;
     this.#finish = finish;
     this.#fail = fail;
     this.#providerMessageIds = providerMessageIds;
     this.presentation = presentation;
     this.#logger = logger;
+    // Only short-lived carriers (e.g. the private-chat Rich Draft) need a
+    // keepalive refresh; editing a real placeholder message with identical
+    // content would be rejected by the platform.
+    this.#keepalive = keepalive === true;
   }
 
   get providerMessageIds() {
     return [...this.#providerMessageIds];
   }
 
-  async update(value) {
-    if (this.#closed) return undefined;
-    const block = createTextDeliveryBlock(value);
-    const key = `${block.format}:${block.text}`;
-    if (key === this.#lastUpdate) return undefined;
-    this.#lastUpdate = key;
-    try {
-      return await this.#update(block);
-    } catch (error) {
-      this.#logger.warn?.('[dsh-im:telegram] rich stream update failed:', error);
-      return undefined;
-    }
+  /** Whether this carrier is short-lived and wants a keepalive heartbeat. */
+  get keepalive() {
+    return this.#keepalive;
   }
 
-  async finish(value) {
-    if (this.#closed) throw new Error('Message stream is already closed');
-    this.#closed = true;
-    const result = await this.#finish(createTextDeliveryBlock(value));
-    this.#providerMessageIds.push(...(result?.providerMessageIds ?? []));
-    return result;
+  /** Serialize every write so an in-flight keepalive refresh can never land
+   *  after the final frame: finish()/fail() queue behind refresh()/update(). */
+  #enqueue(task) {
+    const run = this.#chain.then(task);
+    this.#chain = run.catch(() => undefined);
+    return run;
   }
 
-  async fail(text) {
-    if (this.#closed) return undefined;
-    this.#closed = true;
-    const result = await this.#fail(createTextDeliveryBlock(text, 'plain'));
-    this.#providerMessageIds.push(...(result?.providerMessageIds ?? []));
-    return result;
+  update(value) {
+    return this.#enqueue(async () => {
+      if (this.#closed) return undefined;
+      const block = createTextDeliveryBlock(value);
+      this.#lastBlock = block;
+      const key = `${block.format}:${block.text}`;
+      if (key === this.#lastUpdate) return undefined;
+      this.#lastUpdate = key;
+      try {
+        return await this.#update(block);
+      } catch (error) {
+        this.#logger.warn?.('[dsh-im:telegram] rich stream update failed:', error);
+        return undefined;
+      }
+    });
+  }
+
+  /** Re-send the most recent frame even when unchanged, to keep a short-lived
+   *  carrier (the private-chat Rich Draft) visible during long silent
+   *  stretches such as a running tool call. Serialized like update() so it
+   *  never overtakes a later finish(). No-op for carriers without keepalive. */
+  refresh() {
+    return this.#enqueue(async () => {
+      if (this.#closed || !this.#keepalive || !this.#lastBlock) return undefined;
+      try {
+        return await this.#update(this.#lastBlock);
+      } catch (error) {
+        this.#logger.warn?.('[dsh-im:telegram] rich stream refresh failed:', error);
+        return undefined;
+      }
+    });
+  }
+
+  finish(value) {
+    return this.#enqueue(async () => {
+      if (this.#closed) throw new Error('Message stream is already closed');
+      this.#closed = true;
+      const result = await this.#finish(createTextDeliveryBlock(value));
+      this.#providerMessageIds.push(...(result?.providerMessageIds ?? []));
+      return result;
+    });
+  }
+
+  fail(text) {
+    return this.#enqueue(async () => {
+      if (this.#closed) return undefined;
+      this.#closed = true;
+      const result = await this.#fail(createTextDeliveryBlock(text, 'plain'));
+      this.#providerMessageIds.push(...(result?.providerMessageIds ?? []));
+      return result;
+    });
   }
 
   cancel() {
@@ -663,6 +714,7 @@ export class TelegramBotClient {
         finish: (block) => this.#sendRich(target, block),
         fail: (block) => this.#sendPlain(target, block.text),
         presentation: 'telegram-rich-draft',
+        keepalive: true,
         logger: this.#logger,
       });
       await stream.update(createTextDeliveryBlock('正在处理…', 'plain'));