@goodandready/dsh-messenger-gateway 0.3.18 → 0.3.19

package/lib/adapters/telegram.js

@@ -11,7 +11,7 @@ import { normalizeThreadId, telegramThreadParams } from '../topics.js'
 import {
   shouldProcessTelegramMessage, stripBotCommandSuffix,
 } from '../groups.js'
-import { isResendSafeNetworkError, isPollingConflict, computePollBackoffMs } from '../telegram-errors.js'
+import { isResendSafeNetworkError, isPollingConflict, isTopicGoneError, computePollBackoffMs } from '../telegram-errors.js'
 
 const API = 'https://api.telegram.org'
 const TELEGRAM_MAX = 4096
@@ -75,6 +75,7 @@ export class TelegramAdapter {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(params),
+      keepalive: true,
       signal: AbortSignal.timeout(timeoutMs),
     })
     const json = await res.json().catch(() => ({}))
@@ -87,6 +88,7 @@ export class TelegramAdapter {
     const res = await fetch(`${API}/bot${this.token}/${method}`, {
       method: 'POST',
       body: form,
+      keepalive: true,
       signal: AbortSignal.timeout(timeoutMs),
     })
     const json = await res.json().catch(() => ({}))
@@ -117,6 +119,7 @@ export class TelegramAdapter {
   async downloadFile(filePath) {
     const timeoutMs = (this.timeoutSeconds * 1000) + 30000
     const res = await fetch(`${API}/file/bot${this.token}/${filePath}`, {
+      keepalive: true,
       signal: AbortSignal.timeout(timeoutMs),
     })
     if (!res.ok) throw new Error(`telegram download HTTP ${res.status}`)
@@ -469,12 +472,26 @@ export class TelegramAdapter {
   }
 
   async startStreamMessage(chatId, replyTo, threadId = 0) {
-    const result = await this.call('sendMessage', {
-      chat_id: chatId,
-      text: '…',
-      reply_to_message_id: replyTo,
-      ...telegramThreadParams(threadId),
-    })
+    let result
+    try {
+      result = await this.call('sendMessage', {
+        chat_id: chatId,
+        text: '…',
+        reply_to_message_id: replyTo,
+        ...telegramThreadParams(threadId),
+      })
+    } catch (err) {
+      if (threadId && isTopicGoneError(err)) {
+        this.logger?.warn?.(`telegram stream start topic gone (thread ${threadId}), fallback main chat: ${err.message}`)
+        result = await this.call('sendMessage', {
+          chat_id: chatId,
+          text: '…',
+          reply_to_message_id: replyTo,
+        })
+      } else {
+        throw err
+      }
+    }
     const messageId = result?.message_id
     return {
       messageId,
@@ -514,12 +531,30 @@ export class TelegramAdapter {
     const blob = new Blob([file.bytes])
     const name = safeName(file.name || 'file')
     const isSvg = file.mime === 'image/svg+xml' || (file.name && file.name.toLowerCase().endsWith('.svg'))
-    if (file.kind === 'photo' && !isSvg) { form.append('photo', blob, name); return this.sendWithRetry('sendPhoto', form, { multipart: true }) }
-    if (file.kind === 'voice') { form.append('voice', blob, name); return this.sendWithRetry('sendVoice', form, { multipart: true }) }
-    if (file.kind === 'audio') { form.append('audio', blob, name); return this.sendWithRetry('sendAudio', form, { multipart: true }) }
-    if (file.kind === 'video') { form.append('video', blob, name); return this.sendWithRetry('sendVideo', form, { multipart: true }) }
-    form.append('document', blob, name)
-    return this.sendWithRetry('sendDocument', form, { multipart: true })
+    const send = (m, f) => this.sendWithRetry(m, f, { multipart: true })
+    const method = (file.kind === 'photo' && !isSvg) ? 'sendPhoto'
+      : (file.kind === 'voice') ? 'sendVoice'
+      : (file.kind === 'audio') ? 'sendAudio'
+      : (file.kind === 'video') ? 'sendVideo'
+      : 'sendDocument'
+    const fieldName = (file.kind === 'photo' && !isSvg) ? 'photo'
+      : (file.kind === 'voice') ? 'voice'
+      : (file.kind === 'audio') ? 'audio'
+      : (file.kind === 'video') ? 'video'
+      : 'document'
+    form.append(fieldName, blob, name)
+    try {
+      return await send(method, form)
+    } catch (err) {
+      if (threadId && isTopicGoneError(err)) {
+        this.logger?.warn?.(`telegram sendMedia topic gone (thread ${threadId}), fallback main chat: ${err.message}`)
+        const fallbackForm = new FormData()
+        fallbackForm.append('chat_id', String(chatId))
+        fallbackForm.append(fieldName, blob, name)
+        return await send(method, fallbackForm)
+      }
+      throw err
+    }
   }
 
   formatOutgoingText(text, payload = {}) {
@@ -550,19 +585,41 @@ export class TelegramAdapter {
       try {
         await this.sendWithRetry('sendMessage', params)
       } catch (err) {
+        if (threadId && isTopicGoneError(err)) {
+          this.logger?.warn?.(`telegram send topic gone (thread ${threadId}), fallback main chat: ${err.message}`)
+          params.message_thread_id = undefined
+          delete params.message_thread_id
+          await this.sendWithRetry('sendMessage', params)
+          continue
+        }
         if (!parseMode) throw err
         this.logger?.warn?.(`telegram HTML send failed, fallback plain: ${err.message}`)
-        await this.call('sendMessage', {
-          chat_id: chatId,
-          text: plainChunks[i] ?? chunks[i],
-          reply_to_message_id: replyTo,
-          reply_markup: i === 0 ? effectiveMarkup : undefined,
-          ...telegramThreadParams(threadId),
-        })
+        try {
+          await this.call('sendMessage', {
+            chat_id: chatId,
+            text: plainChunks[i] ?? chunks[i],
+            reply_to_message_id: replyTo,
+            reply_markup: i === 0 ? effectiveMarkup : undefined,
+            ...telegramThreadParams(threadId),
+          })
+        } catch (err2) {
+          if (threadId && isTopicGoneError(err2)) {
+            this.logger?.warn?.(`telegram plain send topic gone (thread ${threadId}), fallback main chat: ${err2.message}`)
+            await this.call('sendMessage', {
+              chat_id: chatId,
+              text: plainChunks[i] ?? chunks[i],
+              reply_to_message_id: replyTo,
+              reply_markup: i === 0 ? effectiveMarkup : undefined,
+            })
+          } else {
+            throw err2
+          }
+        }
       }
     }
   }
 
+
   async sendReply(chatId, replyTo, payload, threadId = 0) {
     const body = typeof payload === 'string' ? { text: payload } : (payload || {})
     const files = Array.isArray(body.files) ? body.files : []

package/lib/client.js

@@ -496,6 +496,11 @@ window.__ModuleLoader__.load({
       React.useEffect(() => {
         loadStatus()
         loadPairing()
+        const timer = setInterval(() => {
+          loadStatus()
+          loadPairing()
+        }, 10000)
+        return () => clearInterval(timer)
       }, [loadStatus, loadPairing])
 
       const handleSmoke = async () => {

package/lib/gateway.js

@@ -1199,12 +1199,13 @@ export class Gateway {
       if (typeof react === 'function' && tg.reactionsEnabled !== false) {
         react('👀').catch?.(() => {})
       }
-      if (progressEnabled) stopTyping = startTypingHeartbeat(typing, 4000)
+      if (typeof typing === 'function') stopTyping = startTypingHeartbeat(typing, 4000)
       if (streaming) {
         try {
           stream = await startStream()
           scheduler = createEditScheduler((text) => stream.edit(text), Number(tg.streamEditIntervalMs) || 1200)
           collector.onStream = (text, toolName) => {
+            if (text) stopTyping()
             if (!progressEnabled && !text) return
             scheduler.push(buildStreamPreview(text, progressEnabled ? toolName : ''))
           }
@@ -1223,12 +1224,10 @@ export class Gateway {
         } catch (e) {
           this.ctx.logger?.warn?.(`progress start: ${e.message}`)
           progress = null
-          if (typing) await typing()
         }
-      } else if (typing) {
-        await typing()
       }
 
+
       const content = await this.buildUserContent(input, signal)
       chat.agent.followup(createUserMessage({
         content: ensureContentArray(content),

package/lib/stream.js

@@ -1,101 +1,114 @@
-/** Helpers for Telegram streaming edits + progress. */
-
-export function extractTextDelta(chunk) {
-  if (!chunk || typeof chunk !== 'object') return ''
-  if (chunk.type === 'text-delta' && typeof chunk.text === 'string') return chunk.text
-  return ''
-}
-
-export function extractToolName(eventData) {
-  const name = eventData?.tool?.name || eventData?.toolName || eventData?.name
-  return name ? String(name) : ''
-}
-
-export function formatProgressLine(toolName) {
-  if (!toolName) return '⏳ Думаю…'
-  return `🔧 ${toolName}…`
-}
-
-export function buildStreamPreview(streamText, toolName, maxLen = 3500) {
-  const body = String(streamText || '').trimEnd()
-  const head = toolName ? `${formatProgressLine(toolName)}\n\n` : ''
-  const combined = head + (body || '…')
-  if (combined.length <= maxLen) return combined
-  return combined.slice(0, maxLen - 1) + '…'
-}
-
-export function parseRetryAfter(err) {
-  if (!err) return 0
-  const msg = err.message || String(err)
-  const match = /retry after (\d+)/i.exec(msg)
-  if (match) return parseInt(match[1], 10) * 1000
-  return 0
-}
-
-export function createEditScheduler(editFn, intervalMs = 1200) {
-  let pending = null
-  let timer = null
-  let lastSent = ''
-  let inFlight = Promise.resolve()
-  let retryDelayMs = 0
-
-  const flush = () => {
-    timer = null
-    if (pending === null || pending === lastSent) return
-    const text = pending
-    inFlight = inFlight.then(async () => {
-      try {
-        if (retryDelayMs > 0) {
-          const delay = retryDelayMs
-          retryDelayMs = 0
-          await new Promise((r) => setTimeout(r, delay))
-        }
-        await editFn(text)
-        lastSent = text
-      } catch (err) {
-        const retry = parseRetryAfter(err)
-        if (retry > 0) {
-          retryDelayMs = retry
-          // Re-schedule flush with retry delay
-          if (!timer) {
-            timer = setTimeout(flush, retry + 100)
-            timer.unref?.()
-          }
-        }
-      }
-    })
-  }
-
-  return {
-    push(text) {
-      pending = text
-      if (timer) return
-      timer = setTimeout(flush, Math.max(200, intervalMs))
-      timer.unref?.()
-    },
-    async flush() {
-      if (timer) { clearTimeout(timer); timer = null }
-      flush()
-      await inFlight
-      // If there's still a pending difference (e.g. rate limit delay happened), wait and retry
-      if (pending !== null && pending !== lastSent) {
-        if (retryDelayMs > 0) {
-          await new Promise((r) => setTimeout(r, retryDelayMs + 50))
-          retryDelayMs = 0
-        }
-        try {
-          await editFn(pending)
-          lastSent = pending
-        } catch {}
-      }
-    },
-  }
-}
-
-export function startTypingHeartbeat(typingFn, intervalMs = 4000) {
-  if (typeof typingFn !== 'function') return () => {}
-  typingFn().catch?.(() => {})
-  const timer = setInterval(() => { typingFn().catch?.(() => {}) }, intervalMs)
-  timer.unref?.()
-  return () => clearInterval(timer)
-}
+/** Helpers for Telegram streaming edits + progress. */
+
+export function extractTextDelta(chunk) {
+  if (!chunk || typeof chunk !== 'object') return ''
+  if (chunk.type === 'text-delta' && typeof chunk.text === 'string') return chunk.text
+  return ''
+}
+
+export function extractToolName(eventData) {
+  const name = eventData?.tool?.name || eventData?.toolName || eventData?.name
+  return name ? String(name) : ''
+}
+
+export function formatProgressLine(toolName) {
+  if (!toolName) return '⏳ Думаю…'
+  return `🔧 ${toolName}…`
+}
+
+export function buildStreamPreview(streamText, toolName, maxLen = 3500) {
+  const body = String(streamText || '').trimEnd()
+  const head = toolName ? `${formatProgressLine(toolName)}\n\n` : ''
+  const combined = head + (body || '…')
+  if (combined.length <= maxLen) return combined
+  return combined.slice(0, maxLen - 1) + '…'
+}
+
+export function parseRetryAfter(err) {
+  if (!err) return 0
+  const msg = err.message || String(err)
+  const match = /retry after (\d+)/i.exec(msg)
+  if (match) return parseInt(match[1], 10) * 1000
+  return 0
+}
+
+export function createEditScheduler(editFn, intervalMs = 1200, firstChunkDelayMs = 250) {
+  let pending = null
+  let timer = null
+  let lastSent = ''
+  let inFlight = Promise.resolve()
+  let retryDelayMs = 0
+
+  const flush = () => {
+    timer = null
+    if (pending === null || pending === lastSent) return
+    const text = pending
+    inFlight = inFlight.then(async () => {
+      try {
+        if (retryDelayMs > 0) {
+          const delay = retryDelayMs
+          retryDelayMs = 0
+          await new Promise((r) => setTimeout(r, delay))
+        }
+        await editFn(text)
+        lastSent = text
+      } catch (err) {
+        const retry = parseRetryAfter(err)
+        if (retry > 0) {
+          retryDelayMs = retry
+          // Re-schedule flush with retry delay
+          if (!timer) {
+            timer = setTimeout(flush, retry + 100)
+            timer.unref?.()
+          }
+        }
+      }
+    })
+  }
+
+  return {
+    push(text) {
+      pending = text
+      if (timer) return
+      // Fast first chunk: when lastSent is empty, dispatch quickly so user sees immediate response.
+      // Subsequent edits throttle to intervalMs to respect Telegram rate limits.
+      const delay = !lastSent ? Math.min(firstChunkDelayMs, intervalMs) : Math.max(200, intervalMs)
+      timer = setTimeout(flush, delay)
+      timer.unref?.()
+    },
+    async flush() {
+      if (timer) { clearTimeout(timer); timer = null }
+      flush()
+      await inFlight
+      // If there's still a pending difference (e.g. rate limit delay happened), wait and retry
+      if (pending !== null && pending !== lastSent) {
+        if (retryDelayMs > 0) {
+          await new Promise((r) => setTimeout(r, retryDelayMs + 50))
+          retryDelayMs = 0
+        }
+        try {
+          await editFn(pending)
+          lastSent = pending
+        } catch {}
+      }
+    },
+  }
+}
+
+export function startTypingHeartbeat(typingFn, intervalMs = 4000) {
+  if (typeof typingFn !== 'function') return () => {}
+  let active = true
+  const safeInvoke = () => {
+    if (!active) return
+    try {
+      typingFn()?.catch?.(() => {})
+    } catch {}
+  }
+  safeInvoke()
+  const timer = setInterval(safeInvoke, intervalMs)
+  timer.unref?.()
+  return () => {
+    active = false
+    clearInterval(timer)
+  }
+}

package/lib/telegram-errors.js

@@ -1,51 +1,51 @@
-// Network error classification for Telegram sends (mirrors Hermes adapter policy).
-//
-// The key distinction: some network failures mean the request NEVER left the
-// process (connect/pool timeout, ECONNRESET before send) → resending is safe.
-// Others (a generic timeout after the request may have reached Telegram) could
-// duplicate a message if we resend → do NOT retry.
-
-function rootCause(err) {
-  let e = err
-  let depth = 0
-  while (e && e.cause && e.cause !== e && depth < 10) {
-    e = e.cause
-    depth++
-  }
-  return e || err
-}
-
-// True when a resend cannot duplicate a message: the request did not reach Telegram.
-export function isResendSafeNetworkError(err) {
-  const c = rootCause(err)
-  const msg = String(c?.message || err?.message || '').toLowerCase()
-  if (/not sent to telegram|connect timeout|und_err_connect|econnreset|enotfound|econnrefused|ECONNRESET|ENOTFOUND|ECONNREFUSED/i.test(msg)) {
-    return true
-  }
-  // undici PoolTimeout message: "Request was *not* sent to Telegram."
-  if (/pool timeout|request was \*?not\*? sent/i.test(msg)) return true
-  return false
-}
-
-// True for a 409 from getUpdates: a second bot instance polls the same token.
-export function isPollingConflict(err) {
-  const msg = String(err?.message || '').toLowerCase()
-  return /terminated by other getupdates request|another bot instance is running|getupdates.*conflict|conflict.*getupdates/i.test(msg)
-}
-
-// True when the target chat/topic no longer exists (deleted/closed/upgraded).
-// Such sends should not be retried and any pending ask binding must be pruned.
-export function isTopicGoneError(err) {
-  const msg = String(err?.message || '').toLowerCase()
-  return /thread not found|message thread not found|topic[_ ]?(not found|closed|deleted)|chat (not found|was (upgraded|deleted))|group chat was (upgraded|deleted)/i.test(msg)
-}
-
-/**
- * Calculates exponential backoff with max cap for polling retries.
- * errorCount is 1-indexed.
- */
-export function computePollBackoffMs(baseIntervalMs, errorCount, maxDelayMs = 30_000) {
-  const count = Math.max(1, Math.min(10, Number(errorCount) || 1))
-  const base = Math.max(100, Number(baseIntervalMs) || 500)
-  return Math.min(maxDelayMs, base * Math.pow(2, count - 1))
-}
+// Network error classification for Telegram sends (mirrors Hermes adapter policy).
+//
+// The key distinction: some network failures mean the request NEVER left the
+// process (connect/pool timeout, ECONNRESET before send) → resending is safe.
+// Others (a generic timeout after the request may have reached Telegram) could
+// duplicate a message if we resend → do NOT retry.
+
+function rootCause(err) {
+  let e = err
+  let depth = 0
+  while (e && e.cause && e.cause !== e && depth < 10) {
+    e = e.cause
+    depth++
+  }
+  return e || err
+}
+
+// True when a resend cannot duplicate a message: the request did not reach Telegram.
+export function isResendSafeNetworkError(err) {
+  const c = rootCause(err)
+  const msg = String(c?.message || err?.message || '').toLowerCase()
+  if (/not sent to telegram|connect timeout|und_err_connect|econnreset|enotfound|econnrefused|ECONNRESET|ENOTFOUND|ECONNREFUSED/i.test(msg)) {
+    return true
+  }
+  // undici PoolTimeout message: "Request was *not* sent to Telegram."
+  if (/pool timeout|request was \*?not\*? sent/i.test(msg)) return true
+  return false
+}
+
+// True for a 409 from getUpdates: a second bot instance polls the same token.
+export function isPollingConflict(err) {
+  const msg = String(err?.message || '').toLowerCase()
+  return /terminated by other getupdates request|another bot instance is running|getupdates.*conflict|conflict.*getupdates/i.test(msg)
+}
+
+// True when the target chat/topic no longer exists (deleted/closed/upgraded).
+// Such sends should not be retried and any pending ask binding must be pruned.
+export function isTopicGoneError(err) {
+  const msg = String(err?.message || '').toLowerCase()
+  return /thread not found|message thread not found|topic[_ ]?(not found|closed|deleted)|chat (not found|was (upgraded|deleted))|group chat was (upgraded|deleted)/i.test(msg)
+}
+
+/**
+ * Calculates exponential backoff with max cap for polling retries.
+ * errorCount is 1-indexed.
+ */
+export function computePollBackoffMs(baseIntervalMs, errorCount, maxDelayMs = 30_000) {
+  const count = Math.max(1, Math.min(10, Number(errorCount) || 1))
+  const base = Math.max(100, Number(baseIntervalMs) || 500)
+  return Math.min(maxDelayMs, base * Math.pow(2, count - 1))
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-messenger-gateway",
-  "version": "0.3.18",
+  "version": "0.3.19",
   "description": "Telegram messenger bridge for DeepSeek Harness: sessions, steer, homes, inline asks, notify bridge, and optional TTS voice notes.",
   "license": "MIT",
   "type": "module",