@goodandready/dsh-messenger-gateway 0.3.2 → 0.3.8

package/lib/gateway.js

@@ -8,7 +8,8 @@ import { SessionId } from '@deepseek-ai/dsh-session'
 import createAdapters from './adapters/index.js'
 import { transcribeVoice, speakText } from './integrations.js'
 import { attachInboundPhoto, photoOnlyHint } from './photos.js'
-import { formatInboundDocument, documentOnlyHint } from './documents.js'
+import { formatInboundDocument, documentOnlyHint, parseDocument } from './documents.js'
+import { listFiles, getFileForDownload, formatFileSize } from './file-manager.js'
 import { collectAssistantParts, buildOutboundFiles, stripImageUrls } from './outbound.js'
 import { assistantText, splitText, stripReasoningPreamble, MESSENGER_RELAY_INSTRUCTION } from './text.js'
 import { chatKey, sessionKey } from './topics.js'
@@ -16,9 +17,14 @@ import { listHomes, resolveNamedHome, upsertHome, normalizeHomeName } from './ho
 import { createVoicePrefs, shouldSpeakReply } from './voice-prefs.js'
 import { prepareTtsText, toTelegramVoiceFile } from './tts.js'
 import {
-  makeAskToken, buildInlineKeyboard, indexCallbacks, releaseCallbacks,
-  parseCallbackData, targetMatchesAsk, rejectPendingAsk, REMOVE_KEYBOARD,
+  makeAskToken, buildInlineKeyboard, buildMultiSelectKeyboard, indexCallbacks, releaseCallbacks,
+  parseCallbackData, parseAskCallback, targetMatchesAsk, rejectPendingAsk, REMOVE_KEYBOARD,
 } from './ask.js'
+import { processDiagramsAndTables } from './artifacts.js'
+import { createPersonaStore, getPersona, listPersonas, BUILTIN_PERSONAS } from './personas.js'
+import { exportSessionToMarkdown, rewindSession } from './session-ops.js'
+import { formatAlertMessage, resolveAlertTarget } from './alerts.js'
+import { createScheduler, parseRelativeTime, formatRemaining } from './scheduler.js'
 import { createPairingStore } from './pairing.js'
 import {
   extractTextDelta, extractToolName, buildStreamPreview, formatProgressLine,
@@ -64,6 +70,16 @@ export class Gateway {
     this.voicePrefs = createVoicePrefs(join(home, 'messenger-gateway', 'voice-prefs.json'))
     this.chatTts = createVoicePrefs(join(home, 'messenger-gateway', 'chat-tts.json'))
     this.muted = createVoicePrefs(join(home, 'messenger-gateway', 'muted.json'))
+    this.personas = createPersonaStore(join(home, 'messenger-gateway', 'personas.json'))
+    this.scheduler = createScheduler(join(home, 'messenger-gateway', 'scheduled.json'), async (task) => {
+      const target = {
+        platform: task.platform || 'telegram',
+        chatId: task.chatId,
+        threadId: task.threadId || 0,
+      }
+      const text = `⏰ <b>[Напоминание]</b>\n${task.text}`
+      await this.sendToMessenger(target, { text })
+    })
     this.stats = { sent: 0, errors: 0, startedAt: Date.now() }
   }
 
@@ -97,6 +113,20 @@ export class Gateway {
     return out
   }
 
+  async sendAlert(type, payload = {}) {
+    try {
+      const target = resolveAlertTarget(this)
+      if (!target) return
+      const allowedEvents = this.config.telegram?.alerts?.events || ['error', 'pairing']
+      if (type !== 'status' && !allowedEvents.includes(type)) return
+
+      const text = formatAlertMessage(type, payload)
+      await this.sendToMessenger(target, { text })
+    } catch (err) {
+      this.ctx.logger?.warn?.(`sendAlert (${type}): ${err.message}`)
+    }
+  }
+
   async start() {
     this.disposeListener = this.ctx.on('session/event', (session, event) => {
       const collector = this.pending.get(session.id)
@@ -147,9 +177,11 @@ export class Gateway {
       this.idleTimer = setInterval(() => this.reapIdle(), Math.min(idleMs, 60_000))
       this.idleTimer.unref?.()
     }
+    this.scheduler.start()
   }
 
   stop() {
+    if (this.scheduler) this.scheduler.stop()
     if (this.disposeListener) this.disposeListener()
     if (this.idleTimer) clearInterval(this.idleTimer)
     for (const a of this.adapterList) { try { a.stop() } catch {} }
@@ -195,7 +227,24 @@ export class Gateway {
     const adapter = this.getAdapter(target.platform)
     if (!adapter) throw new Error(`adapter ${target.platform} unavailable`)
     const token = makeAskToken()
-    const { replyMarkup, callbackKeys } = buildInlineKeyboard(token, payload.buttons || [])
+    const isMulti = payload.mode === 'multi' || (Array.isArray(payload.options) && payload.options.length > 0)
+    let replyMarkup
+    let callbackKeys
+    let selectedSet
+    let page = 0
+    const pageSize = Number(payload.pageSize) || 6
+
+    if (isMulti) {
+      selectedSet = new Set(Array.isArray(payload.selected) ? payload.selected : [])
+      const kb = buildMultiSelectKeyboard(token, payload.options || payload.buttons, selectedSet, page, pageSize, payload)
+      replyMarkup = kb.replyMarkup
+      callbackKeys = kb.callbackKeys
+    } else {
+      const kb = buildInlineKeyboard(token, payload.buttons || [])
+      replyMarkup = kb.replyMarkup
+      callbackKeys = kb.callbackKeys
+    }
+
     indexCallbacks(this.callbackIndex, callbackKeys, token)
     try {
       await adapter.sendTo(target.chatId, { text: payload.text, replyMarkup }, { threadId: target.threadId })
@@ -215,7 +264,12 @@ export class Gateway {
         reject(new Error('messenger.ask timed out'))
       }, timeoutMs)
       timer.unref?.()
-      this.pendingAsks.set(token, { resolve, reject, timer, target, callbackKeys })
+      this.pendingAsks.set(token, {
+        resolve, reject, timer, target, callbackKeys, isMulti,
+        options: payload.options || payload.buttons,
+        selected: selectedSet,
+        page, pageSize, payload,
+      })
     })
   }
 
@@ -232,6 +286,7 @@ export class Gateway {
     try {
       const { code } = this.pairing.requestCode(userId, { username })
       await reply(`Нет доступа.\nВаш id: ${userId}\nКод сопряжения: ${code}\n\nВладелец должен отправить боту:\n/pair ${code}`)
+      this.sendAlert('pairing', { userId, username, code }).catch(() => {})
     } catch (err) {
       if (err.code === 'RATE_LIMIT') await reply('Код уже выдан. Подождите или попросите владельца /pair.')
       else await reply(`Не удалось выдать код: ${err.message}`)
@@ -248,12 +303,60 @@ export class Gateway {
         await cb.answer('Кнопка для другого чата')
         return
       }
+      const action = parseAskCallback(cb.data)
+      if (pending.isMulti) {
+        if (action.kind === 'toggle') {
+          if (pending.selected.has(action.id)) pending.selected.delete(action.id)
+          else pending.selected.add(action.id)
+          releaseCallbacks(this.callbackIndex, pending.callbackKeys)
+          const nextKb = buildMultiSelectKeyboard(askToken, pending.options, pending.selected, pending.page, pending.pageSize, pending.payload)
+          pending.callbackKeys = nextKb.callbackKeys
+          indexCallbacks(this.callbackIndex, nextKb.callbackKeys, askToken)
+          try {
+            if (cb.editReplyMarkup) await cb.editReplyMarkup(nextKb.replyMarkup)
+            else await cb.editMessage(cb.message?.text || 'Выбор', nextKb.replyMarkup)
+          } catch {}
+          await cb.answer(pending.selected.has(action.id) ? 'Выбрано' : 'Снято')
+          return
+        }
+        if (action.kind === 'page') {
+          pending.page = action.page
+          releaseCallbacks(this.callbackIndex, pending.callbackKeys)
+          const nextKb = buildMultiSelectKeyboard(askToken, pending.options, pending.selected, pending.page, pending.pageSize, pending.payload)
+          pending.callbackKeys = nextKb.callbackKeys
+          indexCallbacks(this.callbackIndex, nextKb.callbackKeys, askToken)
+          try {
+            if (cb.editReplyMarkup) await cb.editReplyMarkup(nextKb.replyMarkup)
+            else await cb.editMessage(cb.message?.text || 'Выбор', nextKb.replyMarkup)
+          } catch {}
+          await cb.answer()
+          return
+        }
+        if (action.kind === 'done') {
+          clearTimeout(pending.timer)
+          this.pendingAsks.delete(askToken)
+          releaseCallbacks(this.callbackIndex, pending.callbackKeys)
+          await cb.answer('OK')
+          try { await cb.editMessage(cb.message?.text || 'Выбрано', REMOVE_KEYBOARD) } catch {}
+          pending.resolve({ buttonId: 'done', selected: Array.from(pending.selected), data: cb.data })
+          return
+        }
+        if (action.kind === 'cancel') {
+          clearTimeout(pending.timer)
+          this.pendingAsks.delete(askToken)
+          releaseCallbacks(this.callbackIndex, pending.callbackKeys)
+          await cb.answer('Отменено')
+          try { await cb.editMessage(cb.message?.text || 'Отменено', REMOVE_KEYBOARD) } catch {}
+          pending.resolve({ buttonId: 'cancel', selected: [], data: cb.data })
+          return
+        }
+      }
       clearTimeout(pending.timer)
       this.pendingAsks.delete(askToken)
       releaseCallbacks(this.callbackIndex, pending.callbackKeys)
       await cb.answer('OK')
       try { await cb.editMessage(cb.message?.text || 'Выбрано', REMOVE_KEYBOARD) } catch {}
-      pending.resolve({ buttonId, data: cb.data })
+      pending.resolve({ buttonId: action.id || buttonId, data: cb.data })
       return
     }
     await cb.answer()
@@ -300,7 +403,16 @@ export class Gateway {
         chat.pendingMedia = []
       }
       const inboundWasVoice = attachments.some((a) => a.kind === 'voice' || a.kind === 'audio')
-      const turnInput = { ...input, text: body, attachments, inboundWasVoice }
+      let personaOverride
+      for (const [pId] of Object.entries(BUILTIN_PERSONAS)) {
+        if (pId === 'default') continue
+        const tag = `@${pId}`
+        if (body.toLowerCase().includes(tag)) {
+          personaOverride = pId
+          break
+        }
+      }
+      const turnInput = { ...input, text: body, attachments, inboundWasVoice, personaOverride }
 
       // Hermes-like steer: while a turn is running, inject followup instead of abort+restart
       if (this.isChatBusy(chat)) {
@@ -328,6 +440,13 @@ export class Gateway {
       run.catch((err) => {
         const msg = err instanceof Error ? err.message : String(err)
         this.ctx.logger?.warn?.(`dsh-messenger-gateway: background turn: ${msg}`)
+        this.sendAlert('error', {
+          code: err?.code || 'BACKGROUND_ERROR',
+          message: msg,
+          sessionId: chat.agent?.session?.id,
+          chatId: input.chatId,
+          threadId: input.threadId,
+        }).catch(() => {})
         chat.turnActive = false
         chat.abort = undefined
       })
@@ -353,12 +472,157 @@ export class Gateway {
         '/stop — прервать текущий ответ',
         '/status — статус шлюза',
         '/model — текущая модель; /model provider model — сменить',
+        '/role [name] — персоны и роли агента (/role list)',
+        '/skills / /tools — список инструментов и навыков',
+        '/fork — ответвление текущей сессии',
+        '/export — выгрузка истории диалога в Markdown',
+        '/rewind [N] — откат последних N сообщений',
+        '/files [dir] — менеджер файлов в рабочей папке агента',
+        '/get <path> — скачать файл из рабочей папки в Telegram',
         '/pair CODE — одобрить пользователя',
         '/sethome [name] — этот чат = home (имя опционально)',
         '/home — список home',
+        '/setalert — назначить этот чат каналом алертов',
+        '/alert [test] — статус канала алертов и тест',
+        '/remind <время> <текст> — напоминание (/remind 10m текст, /remind list)',
         '/voice on|off|status — голосовые ответы',
+        '/tts on|off|status — озвучка в этом чате',
+        '/mute / /unmute — заглушить уведомления в этот чат',
+        '/keyboard on|off — быстрая клавиатура',
       ].join('\n'))
     }
+    if (cmd === '/role' || cmd === '/persona') {
+      const targetRole = parts[1]?.toLowerCase()
+      if (!targetRole || targetRole === 'list') {
+        const currentId = this.personas.get(chatId)
+        const lines = [
+          '🎭 <b>Доступные роли и персоны:</b>',
+          '',
+          ...listPersonas().map((p) => {
+            const isCurrent = p.id === currentId ? ' (активна)' : ''
+            return `${p.icon} <b>${p.id}</b> — ${p.name}: ${p.description}${isCurrent}`
+          }),
+          '',
+          'Смена роли: <code>/role coder</code> (или /role reset)',
+        ]
+        return reply(lines.join('\n'))
+      }
+      if (targetRole === 'reset' || targetRole === 'default') {
+        this.personas.set(chatId, 'default')
+        return reply('🎭 Роль сброшена на стандартную (Default).')
+      }
+      const persona = getPersona(targetRole)
+      if (!persona) {
+        return reply(`Неизвестная роль "${targetRole}". Список: /role list`)
+      }
+      this.personas.set(chatId, persona.id)
+      return reply(`🎭 Роль изменена на: ${persona.icon} <b>${persona.name}</b>\n${persona.description}`)
+    }
+    if (cmd === '/skills' || cmd === '/tools') {
+      const toolsList = []
+      if (this.ctx.tools?.tools) {
+        for (const [name, t] of this.ctx.tools.tools.entries()) {
+          toolsList.push(`• <b>${name}</b>: ${t.description || '(нет описания)'}`)
+        }
+      }
+      if (!toolsList.length) {
+        return reply('🛠️ <b>Инструменты агента:</b>\n(нет зарегистрированных инструментов)')
+      }
+      return reply([
+        '🛠️ <b>Активные инструменты и скиллы:</b>',
+        '',
+        ...toolsList,
+      ].join('\n'))
+    }
+    if (cmd === '/export') {
+      const chat = this.chats.get(key)
+      if (!chat?.agent?.session) {
+        return reply('Нет активной сессии для экспорта.')
+      }
+      try {
+        const { filename, buffer, messagesCount } = exportSessionToMarkdown(chat.agent.session)
+        if (!messagesCount) {
+          return reply('Сессия пуста, нет сообщений для экспорта.')
+        }
+        const file = {
+          name: filename,
+          mime: 'text/markdown',
+          kind: 'document',
+          bytes: buffer,
+          dataBase64: buffer.toString('base64'),
+        }
+        return reply({ text: `📄 Экспорт диалога (${messagesCount} сообщений):`, files: [file] })
+      } catch (err) {
+        return reply(`Ошибка экспорта: ${err.message}`)
+      }
+    }
+    if (cmd === '/rewind') {
+      const chat = this.chats.get(key)
+      if (!chat?.agent?.session) {
+        return reply('Нет активной сессии для отката.')
+      }
+      const count = Number(parts[1]) || 1
+      const res = rewindSession(chat.agent.session, count)
+      if (!res.removed) {
+        return reply('В истории сессии нет сообщений для отката.')
+      }
+      try { await this.ctx.sessions?.flush(chat.agent.session) } catch {}
+      return reply(`⏪ Откачено сообщений: ${res.removed}. Осталось в контексте: ${res.remaining}.`)
+    }
+    if (cmd === '/fork') {
+      const chat = this.chats.get(key)
+      if (!chat?.agent?.session) {
+        return reply('Нет активной сессии для форка.')
+      }
+      try {
+        const oldSession = chat.agent.session
+        const oldMessages = Array.isArray(oldSession.messages) ? [...oldSession.messages] : []
+        const newChat = await this.createChat(key, input)
+        if (newChat.agent?.session && oldMessages.length) {
+          newChat.agent.session.messages = oldMessages
+          try { await this.ctx.sessions?.flush(newChat.agent.session) } catch {}
+        }
+        this.chats.set(key, newChat)
+        return reply(`🔀 Создан форк сессии!\nСтарая сессия: ${oldSession.id}\nНовая активная сессия: ${newChat.agent.session.id}\nКонтекст сохранён (${oldMessages.length} сообщений).`)
+      } catch (err) {
+        return reply(`Ошибка форка: ${err.message}`)
+      }
+    }
+    if (cmd === '/files') {
+      const subPath = parts.slice(1).join(' ').trim() || '.'
+      const agentCwd = this.config.agent?.cwd || process.cwd()
+      const res = await listFiles(agentCwd, subPath)
+      if (!res.ok) return reply(`❌ ${res.error}`)
+      return reply(res.formattedText)
+    }
+    if (cmd === '/get') {
+      const targetRel = parts.slice(1).join(' ').trim()
+      if (!targetRel) {
+        return reply('Укажите имя файла для скачивания: <code>/get <файл></code>\nСписок: <code>/files</code>')
+      }
+      const agentCwd = this.config.agent?.cwd || process.cwd()
+      const maxDocBytes = Number(this.config.media?.maxDocBytes) || 50 * 1024 * 1024
+      const res = await getFileForDownload(agentCwd, targetRel, maxDocBytes)
+      if (!res.ok) return reply(`❌ ${res.error}`)
+      const file = {
+        name: res.name,
+        mime: res.mime,
+        kind: 'document',
+        bytes: res.bytes,
+        dataBase64: res.bytes.toString('base64'),
+      }
+      return reply({ text: `📄 Файл: <b>${res.name}</b> (${formatFileSize(res.size)})`, files: [file] })
+    }
+    if (cmd === '/keyboard') {
+      const sub = String(parts[1] || 'status').toLowerCase()
+      const tgAdapter = this.getAdapter('telegram')
+      if (sub === 'on' || sub === 'off') {
+        if (tgAdapter) tgAdapter.quickActions = sub === 'on'
+        return reply(sub === 'on' ? 'Быстрая клавиатура: включена.' : 'Быстрая клавиатура: выключена.', sub === 'off' ? { replyMarkup: { remove_keyboard: true } } : undefined)
+      }
+      const cur = tgAdapter?.quickActions !== false
+      return reply(`Быстрая клавиатура: ${cur ? 'on' : 'off'}\nСмена: /keyboard on|off`)
+    }
     if (cmd === '/new') {
       const chat = this.chats.get(key)
       if (chat) {
@@ -477,6 +741,89 @@ export class Gateway {
       if (!homes.length) return reply('Home не задан. /sethome или /sethome name')
       return reply(['Homes:', ...homes.map((h) => `• ${h.name}: chat ${h.chatId}${h.threadId ? ` topic ${h.threadId}` : ''}`)].join('\n'))
     }
+    if (cmd === '/setalert') {
+      if (!this.isUserAllowed(userId)) return reply('Нет доступа.')
+      const nextTg = {
+        ...this.tg(),
+        alerts: {
+          ...(this.tg().alerts || {}),
+          enabled: true,
+          chatId,
+          threadId: threadId || 0,
+        },
+      }
+      this.config.telegram = nextTg
+      try { await this.hooks?.persistHomes?.(nextTg) } catch {}
+      return reply(`🔔 Этот чат назначен каналом алертов (chat: ${chatId}${threadId ? `, topic: ${threadId}` : ''}).`)
+    }
+    if (cmd === '/alert') {
+      const sub = parts[1]?.toLowerCase()
+      if (sub === 'test') {
+        const target = resolveAlertTarget(this)
+        if (!target) return reply('Канал алертов не настроен или выключен. Назначить: /setalert')
+        await this.sendAlert('status', { title: 'Тестовый алерт', details: `Отправлен пользователем id ${userId}` })
+        return reply('Тестовый алерт отправлен в канал алертов.')
+      }
+      const target = resolveAlertTarget(this)
+      const alertsCfg = this.tg().alerts || {}
+      return reply([
+        '🔔 <b>Канал алертов:</b>',
+        `Статус: ${alertsCfg.enabled ? 'включен' : 'выключен'}`,
+        `Чат: ${target ? `${target.chatId}${target.threadId ? ` (topic: ${target.threadId})` : ''}` : '(не назначен)'}`,
+        `События: ${(alertsCfg.events || ['error', 'pairing']).join(', ')}`,
+        '',
+        'Команды:',
+        '/setalert — назначить текущий чат каналом алертов',
+        '/alert test — отправить тестовый алерт',
+      ].join('\n'))
+    }
+    if (cmd === '/remind') {
+      const sub = parts[1]?.toLowerCase()
+      if (sub === 'list') {
+        const active = await this.scheduler.list(chatId)
+        if (!active.length) return reply('Нет активных напоминаний для этого чата.')
+        const lines = [
+          '⏰ <b>Активные напоминания:</b>',
+          '',
+          ...active.map((t) => {
+            const left = formatRemaining(t.dueAt - Date.now())
+            return `• <code>${t.id}</code> (через ${left}): ${t.text}`
+          }),
+          '',
+          'Отмена: <code>/remind cancel ID</code>',
+        ]
+        return reply(lines.join('\n'))
+      }
+      if (sub === 'cancel') {
+        const targetId = parts[2]?.trim()
+        if (!targetId) return reply('Укажите ID напоминания: <code>/remind cancel ID</code>')
+        const ok = await this.scheduler.cancel(targetId, chatId)
+        return reply(ok ? `✅ Напоминание <code>${targetId}</code> отменено.` : `❌ Напоминание с ID <code>${targetId}</code> не найдено.`)
+      }
+      const timeArg = parts[1]
+      const textArg = parts.slice(2).join(' ').trim()
+      const delayMs = parseRelativeTime(timeArg)
+      if (!delayMs || !textArg) {
+        return reply([
+          '⏰ <b>Напоминания:</b>',
+          'Создать: <code>/remind &lt;время&gt; &lt;текст&gt;</code>',
+          'Примеры: <code>/remind 10m Позвонить</code>, <code>/remind 2h Проверить деплой</code>',
+          'Список: <code>/remind list</code>',
+          'Отмена: <code>/remind cancel ID</code>',
+        ].join('\n'))
+      }
+      const dueAt = Date.now() + delayMs
+      const task = await this.scheduler.schedule({
+        platform: platform || 'telegram',
+        chatId,
+        threadId: threadId || 0,
+        userId,
+        text: textArg,
+        dueAt,
+      })
+      const left = formatRemaining(delayMs)
+      return reply(`⏰ Напоминание установлено на <b>через ${left}</b> (ID: <code>${task.id}</code>):\n«${textArg}»`)
+    }
     if (cmd === '/voice') {
       const sub = String(parts[1] || 'status').toLowerCase()
       if (sub === 'on' || sub === 'off') {
@@ -574,9 +921,14 @@ export class Gateway {
   }
 
   async buildUserContent(input, signal) {
-    const { text, attachments = [], replyText, steer } = input
+    const { text, attachments = [], replyText, steer, personaOverride } = input
     const parts = []
     parts.push(String(this.config.agent?.instructionPrefix || MESSENGER_RELAY_INSTRUCTION))
+    const activePersonaId = personaOverride || this.personas.get(input.chatId)
+    const activePersona = getPersona(activePersonaId)
+    if (activePersona?.instruction) {
+      parts.push(`[Persona: ${activePersona.name} (${activePersona.icon})]\n${activePersona.instruction}`)
+    }
     if (steer) parts.push('[Steer / дополнение к текущему ходу — учти вместе с предыдущим запросом, не начинай ответ заново с нуля]')
     if (replyText?.trim()) parts.push(`[Ответ на сообщение: ${replyText.trim()}]`)
     const blocks = []
@@ -606,7 +958,14 @@ export class Gateway {
           parts.push(`[Голосовое сообщение (dsh-voice недоступен: ${msg})]`)
         }
       } else if (att.kind === 'document' || att.kind === 'video' || att.kind === 'animation' || att.kind === 'sticker') {
-        parts.push(formatInboundDocument(att))
+        let parsed = null
+        if (att.kind === 'document' && att.path) {
+          try {
+            const maxDocBytes = Number(this.config.media?.maxTextInjectBytes) || 100 * 1024
+            parsed = await parseDocument(att.path, { maxBytes: maxDocBytes })
+          } catch {}
+        }
+        parts.push(formatInboundDocument(att, parsed))
       } else {
         parts.push(`[Файл: ${att.path}${att.name ? ` (${att.name})` : ''}]`)
       }
@@ -688,16 +1047,28 @@ export class Gateway {
       if (progress) try { await progress.remove() } catch {}
       progress = null
       if (typeof react === 'function') react('').catch?.(() => {})
-      const answer = stripReasoningPreamble(stripImageUrls(collector.lastText || collector.streamText || collector.parts.join('\n\n')))
+      const rawAnswer = stripReasoningPreamble(stripImageUrls(collector.lastText || collector.streamText || collector.parts.join('\n\n')))
+      const processed = processDiagramsAndTables(rawAnswer, {
+        artifactPreviews: this.tg().artifactPreviews !== false,
+      })
+      const answer = processed.text
       if (collector.reason?.kind === 'error') {
         const err = collector.reason.error
         const msg = `Ошибка агента: ${err?.code || 'error'}: ${err?.message || 'unknown'}`
+        this.sendAlert('error', {
+          code: err?.code || 'AGENT_ERROR',
+          message: err?.message || 'unknown',
+          sessionId,
+          chatId: input.chatId,
+          threadId: input.threadId,
+        }).catch(() => {})
         if (stream) { await scheduler?.flush(); await stream.finalize(msg) }
         else await reply(msg)
         return
       }
       const files = await buildOutboundFiles(this.ctx, this.baseUrl(), collector, { signal, logger: this.ctx.logger })
-      if (!answer && !files.length) {
+      const allFiles = [...files, ...(processed.files || [])]
+      if (!answer && !allFiles.length) {
         if (stream) { await scheduler?.flush(); await stream.finalize('(нет ответа)') }
         else await reply('(нет ответа)')
         return
@@ -708,10 +1079,10 @@ export class Gateway {
         await scheduler?.flush()
         await stream.finalize(chunks[0] || '(нет ответа)')
         for (let i = 1; i < chunks.length; i++) await reply({ text: chunks[i] })
-        if (files.length) await reply({ files })
+        if (allFiles.length) await reply({ files: allFiles })
       } else {
         for (let i = 0; i < chunks.length; i++) {
-          await reply({ text: chunks[i] || undefined, files: i === 0 ? files : [] })
+          await reply({ text: chunks[i] || undefined, files: i === 0 ? allFiles : [] })
         }
       }
       const chatTtsPref = this.chatTts.get(chat.target?.chatId)
@@ -736,6 +1107,13 @@ export class Gateway {
       }
     } catch (err) {
       if (!signal?.aborted) {
+        this.sendAlert('error', {
+          code: err?.code || 'EXCEPTION',
+          message: err?.message || String(err),
+          sessionId,
+          chatId: input.chatId,
+          threadId: input.threadId,
+        }).catch(() => {})
         try {
           if (stream) await stream.finalize(`Сбой: ${err.message}`)
           else await reply(`Сбой: ${err.message}`)

package/lib/index.js

@@ -52,6 +52,8 @@ function publicConfig(cfg) {
       webhookSecretConfigured: Boolean(String(cfg.telegram.webhookSecret || '').trim()),
       botTokenConfigured: Boolean(String(cfg.telegram.botToken || '').trim()),
       voiceMode: cfg.telegram.voiceMode,
+      quickActions: cfg.telegram.quickActions !== false,
+      artifactPreviews: cfg.telegram.artifactPreviews !== false,
       notifyBridge: {
         enabled: Boolean(cfg.telegram.notifyBridge?.enabled),
         events: cfg.telegram.notifyBridge?.events || ['task_done', 'error'],
@@ -167,15 +169,27 @@ export function apply(ctx, config) {
     ctx.effect(() => ctx.tools.register(defineTool({
       name: 'messenger_ask',
       description:
-        'Ask the Telegram user a multiple-choice question with inline buttons and wait for their choice. '
-        + 'Use for confirmations and short choices. Only works inside messenger-gateway sessions (msgw-*).',
+        'Ask the Telegram user a single or multiple-choice question with inline buttons/checkboxes and wait for their choice. '
+        + 'Supports mode: "single" (default) or "multi" (checkboxes with Done/Cancel buttons). Only works inside messenger-gateway sessions (msgw-*).',
       parameters: {
         text: { type: 'string', required: true, description: 'Question text shown in Telegram.' },
         buttons: {
           type: 'array',
-          required: true,
-          description: 'Rows of buttons: [[{ id, text }, ...], ...]',
+          description: 'Rows of buttons: [[{ id, text }, ...], ...] (for single choice)',
         },
+        options: {
+          type: 'array',
+          description: 'List of options: [{ id, text, selected?: boolean }, ...] (for single or multi choice)',
+        },
+        mode: {
+          type: 'string',
+          description: '"single" for instant choice or "multi" for checkboxes form',
+        },
+        selected: {
+          type: 'array',
+          description: 'Initial selected option IDs for multi-select mode',
+        },
+        pageSize: { type: 'number', description: 'Number of options per page (default 6).' },
         timeoutMs: { type: 'number', description: 'Wait timeout ms (default 300000).' },
       },
       output: {
@@ -185,6 +199,7 @@ export function apply(ctx, config) {
           properties: {
             ok: { type: 'boolean' },
             buttonId: { type: 'string' },
+            selected: { type: 'array', items: { type: 'string' } },
             data: { type: 'string' },
             error: { type: 'string' },
           },
@@ -192,7 +207,7 @@ export function apply(ctx, config) {
         render: (_args, value) => [{
           type: 'text',
           text: value && value.ok
-            ? `User chose: ${value.buttonId}`
+            ? (value.selected?.length ? `User selected: ${value.selected.join(', ')}` : `User chose: ${value.buttonId}`)
             : `messenger_ask failed: ${value && value.error ? value.error : 'unknown'}`,
         }],
       },
@@ -200,12 +215,15 @@ export function apply(ctx, config) {
         const gw = getGw()
         if (!gw) return { ok: false, error: 'gateway not running' }
         try {
-          const buttons = args.buttons
           const result = await gw.messengerAskFromAgent(exec.agent, {
             text: String(args.text || ''),
-            buttons,
+            buttons: args.buttons,
+            options: args.options,
+            mode: args.mode,
+            selected: args.selected,
+            pageSize: args.pageSize,
           }, Number(args.timeoutMs) || 300_000)
-          return { ok: true, buttonId: result?.buttonId, data: result?.data }
+          return { ok: true, buttonId: result?.buttonId, selected: result?.selected, data: result?.data }
         } catch (err) {
           return { ok: false, error: err instanceof Error ? err.message : String(err) }
         }
@@ -277,6 +295,45 @@ export function apply(ctx, config) {
     },
   }), 'dsh-messenger-gateway: messenger schema')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact', path: '/dsh-messenger-gateway/events',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') return writeJson(res, 405, { ok: false, error: 'POST only' })
+      const gw = getGw()
+      if (!gw) return writeJson(res, 503, { ok: false, error: 'gateway not ready' })
+      let payload
+      try {
+        payload = JSON.parse((await readBody(req)).toString('utf8') || '{}')
+      } catch {
+        return writeJson(res, 400, { ok: false, error: 'invalid json' })
+      }
+
+      const expectedSecret = source().webhooks?.secret
+      if (expectedSecret) {
+        const authHeader = req.headers?.authorization || ''
+        const bearer = authHeader.startsWith('Bearer ') ? authHeader.slice(7).trim() : ''
+        const tokenHeader = req.headers?.['x-webhook-secret'] || ''
+        const provided = bearer || tokenHeader || payload.secret
+        if (provided !== expectedSecret) {
+          return writeJson(res, 401, { ok: false, error: 'unauthorized' })
+        }
+      }
+
+      const { target, text, home, chatId, threadId, platform = 'telegram', files } = payload
+      if (!text && (!files || !files.length)) {
+        return writeJson(res, 400, { ok: false, error: 'text or files required' })
+      }
+
+      const dest = target || { platform, chatId, threadId, home }
+      try {
+        const result = await gw.messengerSend(dest, { text, files })
+        writeJson(res, 200, { ok: true, sent: result })
+      } catch (err) {
+        writeJson(res, 500, { ok: false, error: err.message })
+      }
+    },
+  }), 'dsh-messenger-gateway: webhook events')
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact', path: '/dsh-messenger-gateway/config',
     handler: async (req, res) => {