@soffits/dsh-telegram-bot 0.0.0-stage → 0.4.0

package/src/config.js

@@ -0,0 +1,73 @@
+/** Editable plugin configuration schema. */
+import z from '@deepseek-ai/schemastery'
+import { DEFAULT_TOKEN_REF } from './constants.js'
+
+export const Config = z.object({
+  /**
+   * Credential reference that holds the bot token. The token itself lives in
+   * the credential store (or the matching environment variable for headless
+   * deployments); this config only names the reference.
+   */
+  tokenRef: z.string().default(DEFAULT_TOKEN_REF).volatile(),
+  /** Whether the Telegram runtime should poll while this profile runs. */
+  enabled: z.boolean().default(true).volatile(),
+  /** Language of the bot's Telegram messages. */
+  language: z.string().default('en').volatile(),
+  /**
+   * Telegram user ids or @usernames allowed to talk to the bot.
+   * Empty means nobody, except the one-time setup hint described below.
+   */
+  allowedUsers: z.array(z.string()).default([]).volatile(),
+  /**
+   * Telegram chat ids or @channelnames the bot may answer in.
+   * Empty means private chats only.
+   */
+  allowedChats: z.array(z.string()).default([]).volatile(),
+  /**
+   * Chat id (or @channelname) that gets lifecycle notices such as "Telegram
+   * bot enabled". Empty means the private chat of the first allowed user.
+   */
+  controlChat: z.string().default('').volatile(),
+  /**
+   * Monotonic value the Restart button writes. Any settings update restarts the
+   * runtime, but this field lets the button request a restart even when every
+   * other field is unchanged.
+   */
+  restartRequest: z.number().default(0).volatile(),
+  /** Working directory for Telegram-created DSH sessions. */
+  cwd: z.string().default(process.cwd()).volatile(),
+  /** Agent preset mounted for Telegram-created sessions when presets exist. */
+  agentPreset: z.string().default('standard').volatile(),
+  /** Mirror model reasoning deltas into the session topic. */
+  showThinking: z.boolean().default(true).volatile(),
+  /** Mirror tool calls into the session topic. */
+  showToolCalls: z.boolean().default(true).volatile(),
+  /**
+   * Also show turns started outside Telegram (Web UI, scheduled tasks, other
+   * plugins) in the topic bound to their session.
+   */
+  mirrorTurns: z.boolean().default(true).volatile(),
+  /**
+   * Telegram messages sent while the session's turn runs: `steer` sends them
+   * into that turn (the agent sees them at its next step, like a message typed
+   * in the Web UI during a turn); `queue` holds them until the turn ends.
+   */
+  busyMessages: z.union(['steer', 'queue']).default('steer').volatile(),
+  /**
+   * How voice messages, audio files and round video messages are turned into
+   * text: `dsh` uses the DSH speech-to-text service (decoded with ffmpeg),
+   * `command` runs `transcribeCommand`, `off` passes only the file.
+   */
+  transcriber: z.union(['dsh', 'command', 'off']).default('dsh').volatile(),
+  /** Language hint for the DSH speech-to-text service; empty uses its setting. */
+  transcribeLanguage: z.string().default('').volatile(),
+  /**
+   * Program and arguments for `transcriber: command`, run without a shell.
+   * `{file}` is replaced by the recording's path (appended when absent); the
+   * transcript is read from stdout.
+   */
+  transcribeCommand: z.array(z.string()).default([]).volatile(),
+  /** ffmpeg program used to decode recordings for the DSH service. */
+  ffmpegPath: z.string().default('ffmpeg').volatile(),
+})
+

package/src/constants.js

@@ -0,0 +1,80 @@
+/** Shared constants and Telegram command menus. */
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+/** Default credential reference holding the bot token. */
+export const DEFAULT_TOKEN_REF = 'TELEGRAM_BOT_TOKEN'
+/** Long-poll timeout requested from Telegram, in seconds. */
+export const POLL_TIMEOUT_SECONDS = 25
+/** Pause after a failed poll before trying again, in milliseconds. */
+export const RETRY_DELAY_MS = 3000
+/** Coalesce a settings write and a token write into one restart. */
+export const RESTART_DEBOUNCE_MS = 300
+/**
+ * Forwarding several messages delivers one update per message. Forwards that
+ * arrive in the same topic within this window become a single prompt.
+ */
+export const FORWARD_BATCH_MS = 1200
+
+/** Loader row id and settings namespace; the npm package name is @soffits/dsh-telegram-bot. */
+export const name = 'telegram-bot'
+
+/** Command menu shown by Telegram clients while the user types `/`. */
+const BOT_COMMANDS = [
+  { command: 'start', description: 'Start the bot and show help' },
+  { command: 'help', description: 'List commands' },
+  { command: 'stop', description: 'Stop the current task' },
+  { command: 'clear', description: 'Clear queued Telegram messages' },
+  { command: 'status', description: 'Bot and session status' },
+  { command: 'sessions', description: 'Browse workspaces and sessions' },
+  { command: 'new', description: 'Start a new session in this topic' },
+  { command: 'workspace', description: 'Switch this topic to another workspace' },
+  { command: 'current', description: 'Show the topic session' },
+  { command: 'menu', description: 'Show the model and session controls' },
+  { command: 'rename', description: 'Rename this Telegram topic' },
+  { command: 'topic', description: 'Manage topics: delete, wipe' },
+  { command: 'fork', description: 'Fork this session into a new topic' },
+  { command: 'last', description: 'Show the latest assistant messages' },
+  { command: 'goal', description: 'Goal: /goal <objective>, edit, pause, resume, clear' },
+  { command: 'restart', description: 'Restart the Telegram bot runtime' },
+  { command: 'id', description: 'Show user and chat ids' },
+  { command: 'ping', description: 'Check connectivity' },
+]
+
+/** Russian command menu for clients with language_code=ru. */
+const BOT_COMMANDS_RU = [
+  { command: 'start', description: 'Запустить бота и показать справку' },
+  { command: 'help', description: 'Список команд' },
+  { command: 'stop', description: 'Остановить текущую задачу' },
+  { command: 'clear', description: 'Очистить очередь сообщений' },
+  { command: 'status', description: 'Статус бота и сессии' },
+  { command: 'sessions', description: 'Выбрать workspace и сессию' },
+  { command: 'new', description: 'Новая сессия в этом топике' },
+  { command: 'workspace', description: 'Сменить workspace этого топика' },
+  { command: 'current', description: 'Показать сессию этого топика' },
+  { command: 'menu', description: 'Показать меню модели и сессии' },
+  { command: 'rename', description: 'Переименовать Telegram-топик' },
+  { command: 'topic', description: 'Управление топиками: delete, wipe' },
+  { command: 'fork', description: 'Форкнуть сессию в новый topic' },
+  { command: 'last', description: 'Показать последние ответы ассистента' },
+  { command: 'goal', description: 'Цель: /goal <цель>, edit, pause, resume, clear' },
+  { command: 'restart', description: 'Перезапустить Telegram-бота' },
+  { command: 'id', description: 'Показать user id и chat id' },
+  { command: 'ping', description: 'Проверить связь' },
+]
+
+/** Bound one Telegram message body to stay under the 4096-character API limit. */
+const MAX_TELEGRAM_TEXT = 3800
+/** A final answer of exactly this text posts nothing in the topic. */
+const SILENT_REPLY = '[SILENT]'
+/** Host-local diagnostics directory; no secrets are written here. */
+const STATUS_DIR = join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'telegram')
+
+
+export {
+  BOT_COMMANDS,
+  BOT_COMMANDS_RU,
+  MAX_TELEGRAM_TEXT,
+  SILENT_REPLY,
+  STATUS_DIR,
+}

package/src/errors.js

@@ -0,0 +1,16 @@
+/** Error classification and diagnostics policy. */
+import { isTelegramParseError } from './formatting.js'
+import { messageOf } from './utils.js'
+
+/** Classify a failure for diagnostics without mixing it with formatting errors. */
+function classifyError(error) {
+  const detail = messageOf(error)
+  if (isTelegramParseError(detail)) return 'format'
+  if (error?.telegram === true) return 'telegram'
+  if (/agent|turn|session|approval|question/iu.test(detail)) return 'agent'
+  if (/state|storage|write|read|ENOENT|EACCES|EPERM/iu.test(detail)) return 'storage'
+  return 'runtime'
+}
+
+
+export { classifyError }

package/src/final-text.js

@@ -0,0 +1,45 @@
+/**
+ * The text a finished turn leaves in its topic.
+ *
+ * Text written between tool calls ("Now the board entries.") streams into the
+ * live reply like everything else, but it is working narration, not part of
+ * the answer. So the final reply keeps, from each assistant message of the
+ * turn, only an answer: the last text block of a message that called no tool.
+ * A message that called a tool is mid-chain, so its text goes. The last block,
+ * not all of them: Claude Code through dsh-oh-my-claude puts every text block
+ * of its own tool loop into one message, with its tools recorded beside it.
+ * Answers of several tool-free messages in one turn (a steer answered after a
+ * first answer) are all kept, in order.
+ */
+
+/**
+ * The answer one assistant message holds, or '' when it holds none.
+ * @param message - an assistant message (`{ content: [...] }`).
+ * @returns the last text block when the message called no tool.
+ */
+export function messageAnswer(message) {
+  const content = Array.isArray(message?.content) ? message.content : []
+  if (content.some((block) => block?.type === 'tool-call')) return ''
+  const texts = content
+    .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+    .map((block) => block.text.trim())
+    .filter((text) => text.length > 0)
+  return texts.at(-1) ?? ''
+}
+
+/**
+ * The answer of one turn, read from the session's durable events.
+ * @param events - session events (`{ type, data }`).
+ * @param turn - DSH turn number.
+ * @returns the answers of the turn's messages joined by blank lines, or '' when none.
+ */
+export function turnAnswer(events, turn) {
+  if (!Array.isArray(events) || turn === undefined) return ''
+  const answers = []
+  for (const event of events) {
+    if (event?.type !== 'assistant/message' || event.data?.turn !== turn) continue
+    const answer = messageAnswer(event.data?.message ?? event.data)
+    if (answer.length > 0) answers.push(answer)
+  }
+  return answers.join('\n\n')
+}

package/src/formatting.js

@@ -0,0 +1,390 @@
+/** Markdown/Telegram formatting helpers. */
+import telegramifyMarkdown from 'telegramify-markdown'
+
+/**
+ * Split one Markdown table row into trimmed cells.
+ * @param line - table row.
+ * @returns cells without the outer pipes.
+ */
+function splitTableRow(line) {
+  return line.replace(/^\s*\|/u, '').replace(/\|\s*$/u, '').split('|').map((cell) => cell.trim())
+}
+
+/**
+ * Whether a line is a Markdown table separator.
+ * @param line - candidate line.
+ * @returns true for `|---|:---:|` rows.
+ */
+function isTableSeparator(line) {
+  return /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/u.test(line)
+}
+
+/**
+ * Whether a line looks like a Markdown table row.
+ * @param line - candidate line.
+ * @returns true when it has at least one inner pipe.
+ */
+function isTableRow(line) {
+  return line.includes('|') && line.trim().length > 1 && !line.includes('\u0000')
+}
+
+/**
+ * Convert Markdown tables into compact Telegram-friendly lists.
+ * Telegram Markdown has no table syntax, so each row becomes one bullet.
+ * @param markdown - raw assistant text.
+ * @returns text with tables expanded to headings and bullets.
+ */
+function preprocessTables(markdown) {
+  const lines = markdown.split('\n')
+  const out = []
+  let fenced = false
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]
+    if (/^\s*```/u.test(line)) fenced = !fenced
+    if (!fenced && isTableRow(line) && index + 1 < lines.length && isTableSeparator(lines[index + 1])) {
+      const headers = splitTableRow(line)
+      out.push(`**${headers.join(' · ')}**`)
+      index += 2
+      while (index < lines.length && isTableRow(lines[index]) && !isTableSeparator(lines[index])) {
+        out.push(`- ${splitTableRow(lines[index]).join(' · ')}`)
+        index += 1
+      }
+      index -= 1
+      continue
+    }
+    out.push(line)
+  }
+  return out.join('\n')
+}
+
+/**
+ * Replace Markdown links to relative workspace paths with their labels.
+ * Telegram cannot open relative paths, and telegramify-markdown double-escapes
+ * their labels. Absolute http/tg/mailto links are preserved.
+ * @param markdown - raw assistant text.
+ * @returns text without relative links.
+ */
+function preprocessRelativeLinks(markdown) {
+  const strip = (value) => value.replace(/\[([^\]]+)\]\(([^)\s]+)\)/gu, (whole, label, target) => {
+    if (/^(?:https?:|tg:|mailto:)/iu.test(target)) return whole
+    return label
+  })
+  const out = []
+  let fenced = false
+  for (const line of markdown.split('\n')) {
+    if (/^\s*```/u.test(line)) {
+      fenced = !fenced
+      out.push(line)
+      continue
+    }
+    if (fenced) {
+      out.push(line)
+      continue
+    }
+    out.push(line.split(/(`[^`]*`)/gu).map((part) => part.startsWith('`') ? part : strip(part)).join(''))
+  }
+  return out.join('\n')
+}
+
+/**
+ * Convert assistant Markdown to Telegram MarkdownV2.
+ * @param markdown - raw assistant text.
+ * @returns MarkdownV2 text, or the original text if conversion fails.
+ */
+function toTelegramMarkdown(markdown) {
+  try {
+    return telegramifyMarkdown(preprocessTables(preprocessRelativeLinks(markdown)), 'escape')
+  } catch {
+    return markdown
+  }
+}
+
+/** Maximum converted MarkdownV2 length accepted by Telegram. */
+export const ANSWER_MARKDOWN_LIMIT = 3900
+
+/**
+ * Find the longest prefix whose converted MarkdownV2 fits Telegram.
+ * @param text - raw Markdown.
+ * @param limit - converted character budget.
+ * @returns a safe partial prefix.
+ */
+function fitAnswerText(text, limit = ANSWER_MARKDOWN_LIMIT) {
+  if (text.length === 0) return ''
+  if (toTelegramMarkdown(text).length <= limit) return text
+  let low = 0
+  let high = text.length
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2)
+    if (toTelegramMarkdown(text.slice(0, middle)).length <= limit) low = middle
+    else high = middle - 1
+  }
+  let cut = low
+  const boundary = Math.max(text.lastIndexOf('\n', cut), text.lastIndexOf(' ', cut))
+  if (boundary > cut / 2) cut = boundary
+  const prefix = text.slice(0, cut).trimEnd()
+  return prefix.length === 0 ? '' : `${prefix}…`
+}
+
+/**
+ * Parse streamed tool arguments when they form complete JSON.
+ * @param raw - raw argument string.
+ * @returns the object, or undefined while the stream is incomplete.
+ */
+function parseToolArguments(raw) {
+  if (typeof raw !== 'string' || raw.trim().length === 0) return undefined
+  try {
+    const value = JSON.parse(raw)
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Convert one tool argument value to a compact single-line label.
+ * @param value - argument value.
+ * @returns display text.
+ */
+function compactToolValue(value) {
+  if (typeof value === 'string') return value.replace(/\s+/gu, ' ').trim()
+  if (Array.isArray(value)) return `${value.length} item${value.length === 1 ? '' : 's'}`
+  if (value !== null && typeof value === 'object') {
+    return Object.entries(value).slice(0, 3).map(([key, item]) => `${key}=${compactToolValue(item)}`).join(' · ')
+  }
+  return String(value)
+}
+
+/**
+ * Pick one argument by its possible names.
+ * @param args - parsed tool arguments.
+ * @param names - candidate keys.
+ * @returns the first present value.
+ */
+function toolArg(args, ...names) {
+  if (args === undefined) return undefined
+  for (const name of names) {
+    if (args[name] !== undefined && args[name] !== null) return args[name]
+  }
+  return undefined
+}
+
+/**
+ * Wrap text into fixed-width visual lines without dropping content.
+ * @param text - source text.
+ * @param width - target line width.
+ * @returns wrapped lines.
+ */
+function wrapVisualLines(text, width = 52) {
+  const lines = []
+  for (const sourceLine of String(text).split('\n')) {
+    const words = sourceLine.replace(/\s+/gu, ' ').trim().split(' ').filter(Boolean)
+    let current = ''
+    for (let word of words) {
+      while (word.length > width) {
+        if (current.length > 0) {
+          lines.push(current)
+          current = ''
+        }
+        lines.push(word.slice(0, width))
+        word = word.slice(width)
+      }
+      if (word.length === 0) continue
+      if (current.length === 0) current = word
+      else if (current.length + 1 + word.length <= width) current += ` ${word}`
+      else {
+        lines.push(current)
+        current = word
+      }
+    }
+    if (current.length > 0) lines.push(current)
+  }
+  return lines
+}
+
+/**
+ * Strip HTML tags for the plain-text fallback.
+ * @param value - HTML body.
+ * @returns readable plain text.
+ */
+function htmlToPlain(value) {
+  return String(value)
+    .replace(/<[^>]*>/gu, '')
+    .replaceAll('&lt;', '<')
+    .replaceAll('&gt;', '>')
+    .replaceAll('&amp;', '&')
+}
+
+/**
+ * Whether Telegram rejected the entity markup rather than the request itself.
+ * @param detail - Telegram error description.
+ * @returns true when a plain-text retry is appropriate.
+ */
+function isTelegramParseError(detail) {
+  return /can't parse entities|unsupported start tag|can't find end tag|reserved and must be escaped|parse entities/iu.test(String(detail))
+}
+
+/** Whether a Telegram thread id denotes the General / All topic. */
+function isAllThread(threadId) {
+  return threadId === undefined || threadId === null || threadId === 0 || threadId === 1
+}
+
+/** Normalize a Telegram command token, dropping an optional @botname suffix. */
+function normalizeCommand(token) {
+  return String(token ?? '')
+    .replace(/[\u200B-\u200D\uFEFF]/gu, '')
+    .trim()
+    .toLowerCase()
+    .split('@')[0]
+}
+
+/**
+ * Decide where an ordinary (non-command) message belongs.
+ * @param {{ threadId?: number|null, inSession: boolean, hasAttachment?: boolean }} input
+ * @returns {'new-topic'|'current-topic'|'continue'|'command'}
+ */
+function routeMessage({ threadId, inSession, hasAttachment = false }) {
+  if (isAllThread(threadId)) return 'new-topic'
+  if (hasAttachment) return inSession ? 'continue' : 'current-topic'
+  return inSession ? 'continue' : 'current-topic'
+}
+
+/**
+ * Trim a session preview at a line boundary so formatting is not cut mid-construct.
+ * @param text - raw assistant Markdown.
+ * @param limit - maximum characters.
+ * @returns clipped preview.
+ */
+function clipPreview(text, limit = 2500) {
+  if (text.length <= limit) return text
+  const cut = text.slice(0, limit)
+  const newline = cut.lastIndexOf('\n')
+  return newline > limit / 2 ? cut.slice(0, newline) : cut
+}
+
+/**
+ * Split raw Markdown into chunks whose converted MarkdownV2 fits Telegram.
+ * @param text - complete answer.
+ * @param limit - converted character budget.
+ * @returns chunks in reading order.
+ */
+/** Return the last unclosed fenced code block in a Markdown chunk. */
+function openFenceAtEnd(text) {
+  let open
+  for (const line of text.split('\n')) {
+    const match = /^ {0,3}(`{3,}|~{3,})(.*)$/u.exec(line)
+    if (match === null) continue
+    if (open === undefined) {
+      open = { marker: match[1], info: match[2].trim() }
+    } else if (match[1][0] === open.marker[0] && match[1].length >= open.marker.length && match[2].trim().length === 0) {
+      open = undefined
+    }
+  }
+  return open
+}
+
+/** Wrap reasoning to the phone width and keep only the last lines. */
+function wrapThinkingLines(text, width = 43, maxLines = 9) {
+  // Hard character wrapping is prefix-stable: growing text never reflows the
+  // lines above, so only the bottom of the window changes.
+  const lines = []
+  for (const source of String(text).split('\n')) {
+    if (source.length === 0) {
+      lines.push('')
+      continue
+    }
+    for (let index = 0; index < source.length; index += width) {
+      lines.push(source.slice(index, index + width))
+    }
+  }
+  const tail = lines.slice(-maxLines)
+  if (tail.length > 0) tail[tail.length - 1] = tail.at(-1).slice(0, 30).trimEnd()
+  return tail.join('\n')
+}
+
+function splitAnswerText(text, limit = ANSWER_MARKDOWN_LIMIT) {
+  const chunks = []
+  let rest = text.trim()
+  while (rest.length > 0) {
+    if (toTelegramMarkdown(rest).length <= limit) {
+      chunks.push(rest)
+      break
+    }
+    let cut = Math.min(rest.length, 2200)
+    const boundary = Math.max(rest.lastIndexOf('\n', cut), rest.lastIndexOf(' ', cut))
+    if (boundary > cut / 2) cut = boundary
+    while (cut > 200 && toTelegramMarkdown(rest.slice(0, cut)).length > limit) {
+      cut = Math.floor(cut * 0.8)
+      const nextBoundary = Math.max(rest.lastIndexOf('\n', cut), rest.lastIndexOf(' ', cut))
+      if (nextBoundary > cut / 2) cut = nextBoundary
+    }
+    if (cut < 1) cut = Math.min(rest.length, 500)
+    let chunk = rest.slice(0, cut).trimEnd()
+    if (chunk.length === 0) break
+    let tail = rest.slice(cut).trimStart()
+    const fence = openFenceAtEnd(chunk)
+    if (fence !== undefined) {
+      chunk += `\n${fence.marker}`
+      tail = `${fence.marker}${fence.info}\n${tail}`
+    }
+    chunks.push(chunk)
+    rest = tail
+  }
+  return chunks
+}
+/**
+ * Local files shown as Markdown images (`![alt](/abs/path.png)`,
+ * `![alt](</abs/path with spaces.png>)` or `file://` URLs), outside code.
+ * Telegram cannot show these inline, so the bridge uploads them.
+ * @param markdown - assistant text.
+ * @returns absolute paths, in order, without repeats.
+ */
+function localImagePaths(markdown) {
+  const found = []
+  const pattern = /!\[[^\]]*\]\(\s*(?:<([^>\n]+)>|([^)\s]+))(?:\s+"[^"\n]*")?\s*\)/gu
+  const take = (text) => {
+    for (const match of text.matchAll(pattern)) {
+      let target = (match[1] ?? match[2]).trim()
+      if (/^file:\/\//iu.test(target)) {
+        try {
+          target = decodeURIComponent(new URL(target).pathname)
+        } catch {
+          continue
+        }
+      }
+      if (target.startsWith('/') && !found.includes(target)) found.push(target)
+    }
+  }
+  let fenced = false
+  for (const line of String(markdown ?? '').split('\n')) {
+    if (/^\s*```/u.test(line)) {
+      fenced = !fenced
+      continue
+    }
+    if (fenced) continue
+    take(line.split(/`[^`]*`/gu).join(' '))
+  }
+  return found
+}
+
+export {
+  localImagePaths,
+  splitTableRow,
+  isTableSeparator,
+  isTableRow,
+  preprocessTables,
+  preprocessRelativeLinks,
+  toTelegramMarkdown,
+  fitAnswerText,
+  parseToolArguments,
+  compactToolValue,
+  toolArg,
+  wrapVisualLines,
+  htmlToPlain,
+  isTelegramParseError,
+  isAllThread,
+  normalizeCommand,
+  routeMessage,
+  clipPreview,
+  splitAnswerText,
+  wrapThinkingLines,
+}

package/src/index.js

@@ -0,0 +1,24 @@
+/** Public host entry point for @soffits/dsh-telegram-bot. */
+export { apply } from './app.js'
+export { Config } from './config.js'
+export { name } from './constants.js'
+export { classifyError } from './errors.js'
+export {
+  isAllThread,
+  isTelegramParseError,
+  normalizeCommand,
+  routeMessage,
+  splitAnswerText,
+} from './formatting.js'
+
+/** Pure helpers exposed for the local regression suite. */
+import { classifyError as classify } from './errors.js'
+import { isAllThread as isAll, isTelegramParseError as isParse, normalizeCommand as normalize, routeMessage as route, splitAnswerText as split } from './formatting.js'
+export const __testing = {
+  classifyError: classify,
+  isAllThread: isAll,
+  isTelegramParseError: isParse,
+  normalizeCommand: normalize,
+  routeMessage: route,
+  splitAnswerText: split,
+}