switchroom 0.16.23 → 0.16.27

package/telegram-plugin/stream-controller.ts

@@ -6,10 +6,13 @@
  *   - the `stream_reply` MCP case block (model-driven streaming)
  *   - `handlePtyPartial` (PTY-tail TUI extractor → live preview)
  *
- * Both paths do the same thing: given a chat/thread/parseMode, create a
- * draft stream whose `send` closure calls `bot.api.sendMessage` and whose
- * `edit` closure calls `bot.api.editMessageText`, both wrapped in the
- * shared retry/429/not-modified policy (`robustApiCall`).
+ * Both paths do the same thing: given a chat/thread, create a draft stream
+ * whose `send` closure first calls `bot.api.sendRichMessage` and whose
+ * `edit` closure calls `bot.api.editMessageText({ markdown })`, both wrapped
+ * in the shared retry/429/not-modified policy (`robustApiCall`). Because
+ * send and edit share the same opts, the "edit-rich-if-sent-rich" invariant
+ * holds automatically (#2669). A `format:'text'` literal stream bypasses the
+ * rich parser entirely (plain `sendMessage` / plain-string `editMessageText`).
  *
  * This module exists primarily so that wiring can be exercised by
  * integration tests against a mock bot.api, without having to mock the
@@ -17,32 +20,11 @@
  */
 
 import { createDraftStream, type DraftStreamHandle } from './draft-stream.js'
-import { htmlToPlainText } from './html-sanitize.js'
-
-/**
- * Telegram returns `400 Bad Request: can't parse entities: …` when the
- * body contains malformed HTML / MarkdownV2 / nested unbalanced tags.
- * Detect that specific error class so we can fall back to plain text
- * without confusing it with other 400s (rate-limit, message-not-found,
- * thread-not-found, etc.).
- */
-function isParseEntitiesError(err: unknown): boolean {
-  const msg =
-    typeof err === 'string'
-      ? err
-      : err instanceof Error
-        ? err.message
-        : typeof err === 'object' && err != null && 'description' in err
-          ? typeof (err as { description: unknown }).description === 'string'
-            ? (err as { description: string }).description
-            : ''
-          : ''
-  return /can't parse entities|can't find end of the entity|unsupported start tag|unmatched end tag/i.test(msg)
-}
+import { richMessage, isParseEntitiesError } from './rich-send.js'
 
 /**
  * Minimal bot.api surface the controller needs. Real callers pass grammy's
- * `bot.api`; tests pass a mock with just these two methods.
+ * `bot.api`; tests pass a mock with these methods.
  */
 export interface StreamBotApi {
   sendMessage(
@@ -50,16 +32,20 @@ export interface StreamBotApi {
     text: string,
     opts: StreamSendOpts,
   ): Promise<{ message_id: number }>
+  sendRichMessage(
+    chat_id: string,
+    rich_message: { markdown: string },
+    opts: StreamSendOpts,
+  ): Promise<{ message_id: number }>
   editMessageText(
     chat_id: string,
     message_id: number,
-    text: string,
+    text: string | { markdown: string },
     opts: StreamSendOpts,
   ): Promise<unknown>
 }
 
 export interface StreamSendOpts {
-  parse_mode?: 'HTML' | 'MarkdownV2'
   message_thread_id?: number
   link_preview_options?: { is_disabled: boolean }
   /**
@@ -99,7 +85,13 @@ export interface StreamControllerConfig {
   bot: { api: StreamBotApi }
   chatId: string
   threadId?: number
-  parseMode?: 'HTML' | 'MarkdownV2'
+  /**
+   * When true, this stream is a literal `format:'text'` send: the body
+   * bypasses the rich-markdown parser entirely (plain `sendMessage` /
+   * plain-string `editMessageText`). Default (false/undefined) → the
+   * rich-markdown path via `sendRichMessage` / `editMessageText({ markdown })`.
+   */
+  literalText?: boolean
   disableLinkPreview?: boolean
   /**
    * Optional quote-reply target. When set, the initial send attaches
@@ -186,7 +178,7 @@ export function createStreamController(cfg: StreamControllerConfig): DraftStream
     bot,
     chatId,
     threadId,
-    parseMode,
+    literalText = false,
     disableLinkPreview = true,
     throttleMs,
     idleMs,
@@ -205,9 +197,9 @@ export function createStreamController(cfg: StreamControllerConfig): DraftStream
 
   // Base opts shared by send + edit. The initial send adds reply_parameters
   // and protect_content on top (see below); edits must NOT carry those —
-  // Telegram's editMessageText rejects them.
+  // Telegram's editMessageText rejects them. Both send and edit share these
+  // opts, so a rich send is always followed by a rich edit (#2669 invariant).
   const baseOpts: StreamSendOpts = {
-    ...(parseMode ? { parse_mode: parseMode } : {}),
     ...(threadId != null ? { message_thread_id: threadId } : {}),
     ...(disableLinkPreview ? { link_preview_options: { is_disabled: true } } : {}),
     ...(replyMarkup != null ? { reply_markup: replyMarkup } : {}),
@@ -226,38 +218,44 @@ export function createStreamController(cfg: StreamControllerConfig): DraftStream
     ...(cfg.disableNotification === true ? { disable_notification: true } : {}),
   }
 
-  // Strip parse_mode from a copy of opts — used for the parse-entities
-  // fallback path. We keep thread/preview/reply markup untouched.
-  const sendOptsPlain: StreamSendOpts = { ...sendOpts }
-  delete sendOptsPlain.parse_mode
-  const baseOptsPlain: StreamSendOpts = { ...baseOpts }
-  delete baseOptsPlain.parse_mode
+  // Send the body via the rich-markdown path, unless this is a literal
+  // `format:'text'` stream (plain sendMessage, no rich wrapper).
+  // sendRichMessage does NOT accept link_preview_options (rich messages
+  // control previews via entity detection), so strip it for the rich path.
+  const doSend = (text: string, opts: StreamSendOpts) => {
+    if (literalText) return bot.api.sendMessage(chatId, text, opts)
+    const richOpts = { ...opts }
+    delete richOpts.link_preview_options
+    return bot.api.sendRichMessage(chatId, richMessage(text), richOpts)
+  }
+  const doEdit = (id: number, text: string, opts: StreamSendOpts) =>
+    bot.api.editMessageText(chatId, id, literalText ? text : richMessage(text), opts)
 
   return createDraftStream(
     async (text) => {
       try {
         const sent = await retry(
-          () => bot.api.sendMessage(chatId, text, sendOpts),
+          () => doSend(text, sendOpts),
           { threadId, chat_id: chatId },
         )
         onSend?.(sent.message_id, text.length)
         return sent.message_id
       } catch (err) {
-        if (parseMode != null && isParseEntitiesError(err)) {
-          // First send rejected for parse_mode error. There is no
-          // message_id to edit (the send 400'd before any message was
-          // created), so a single fresh send in plain-text is the
-          // correct recovery — see issue #657. Strip tags from the
-          // body so the user sees readable prose, not raw markup.
+        if (!literalText && isParseEntitiesError(err)) {
+          // First send rejected because the markdown couldn't be parsed.
+          // There is no message_id to edit (the send 400'd before any
+          // message was created), so a single fresh send as PLAIN text
+          // (no rich wrapper, so the parser never runs) is the correct
+          // recovery — see issue #657. The raw markdown source is itself
+          // readable, so we send it verbatim.
           warn?.(
-            `stream-controller: sendMessage parse-entities rejected — retrying once as plain text (${err instanceof Error ? err.message : String(err)})`,
+            `stream-controller: send parse-entities rejected — retrying once as plain text (${err instanceof Error ? err.message : String(err)})`,
           )
-          const plainText = htmlToPlainText(text)
           const sent = await retry(
-            () => bot.api.sendMessage(chatId, plainText, sendOptsPlain),
+            () => bot.api.sendMessage(chatId, text, sendOpts),
             { threadId, chat_id: chatId },
           )
-          onSend?.(sent.message_id, plainText.length)
+          onSend?.(sent.message_id, text.length)
           return sent.message_id
         }
         throw err
@@ -266,27 +264,26 @@ export function createStreamController(cfg: StreamControllerConfig): DraftStream
     async (id, text) => {
       try {
         await retry(
-          () => bot.api.editMessageText(chatId, id, text, baseOpts),
+          () => doEdit(id, text, baseOpts),
           { threadId, chat_id: chatId },
         )
         onEdit?.(id, text.length)
       } catch (err) {
-        if (parseMode != null && isParseEntitiesError(err)) {
-          // Edit rejected for parse_mode error — DO NOT send a fresh
-          // message. The whole point of issue #657 is that the previous
-          // implementation sent a duplicate plain-text message every
-          // time HTML rejection fired. Retry the edit on the SAME
-          // message_id with parse_mode stripped and the body
-          // tag-stripped to plain text.
+        if (!literalText && isParseEntitiesError(err)) {
+          // Edit rejected because the markdown couldn't be parsed — DO NOT
+          // send a fresh message. The whole point of issue #657 is that the
+          // previous implementation sent a duplicate message every time a
+          // parse rejection fired. Retry the edit on the SAME message_id as
+          // PLAIN text (no rich wrapper, so the parser never runs). The raw
+          // markdown source is itself readable, so we send it verbatim.
           warn?.(
-            `stream-controller: editMessageText parse-entities rejected — retrying same id=${id} as plain text (${err instanceof Error ? err.message : String(err)})`,
+            `stream-controller: edit parse-entities rejected — retrying same id=${id} as plain text (${err instanceof Error ? err.message : String(err)})`,
           )
-          const plainText = htmlToPlainText(text)
           await retry(
-            () => bot.api.editMessageText(chatId, id, plainText, baseOptsPlain),
+            () => bot.api.editMessageText(chatId, id, text, baseOpts),
             { threadId, chat_id: chatId },
           )
-          onEdit?.(id, plainText.length)
+          onEdit?.(id, text.length)
           return
         }
         throw err

package/telegram-plugin/stream-reply-handler.ts

@@ -22,28 +22,28 @@ import {
   type StreamBotApi,
   type RetryPolicy,
 } from './stream-controller.js'
-import { sanitizeTelegramHtml } from './html-sanitize.js'
+import { RICH_MESSAGE_MAX_CHARS } from './format.js'
 import { chatKey, chatKeyWithSuffix } from './gateway/chat-key.js'
 
 /**
  * Builds the inline status-accent header line for `reply` / `stream_reply`.
  *
- * Returns a string to prepend to the effective (already-rendered) message
- * body, including a trailing blank line so the header is visually separated.
- * Returns an empty string when accent is undefined or unrecognised (silent
- * ignore) so calls without `accent` produce identical output to today.
+ * Returns a string to prepend to the message body, including a trailing
+ * blank line so the header is visually separated. Returns an empty string
+ * when accent is undefined or unrecognised (silent ignore) so calls without
+ * `accent` produce identical output to today.
  *
- * The header uses Telegram HTML tags. Callers must ensure parseMode is HTML
- * (or that the body has already been rendered to HTML) before prepending.
+ * The header is GFM markdown — every outbound goes through the rich-message
+ * path (#2669), so `_italic_` / `**bold**` render correctly.
  */
 export function buildAccentHeader(accent: string | undefined): string {
   switch (accent) {
     case 'in-progress':
-      return '🔵 <i>In progress…</i>\n\n'
+      return '🔵 _In progress…_\n\n'
     case 'done':
-      return '✅ <b>Done</b>\n\n'
+      return '✅ **Done**\n\n'
     case 'issue':
-      return '⚠️ <b>Issue</b>\n\n'
+      return '⚠️ **Issue**\n\n'
     default:
       return ''
   }
@@ -118,9 +118,9 @@ export interface StreamReplyArgs {
    * Optional status accent prepended as a leading header line (issue #320
    * fallback for missing Telegram quote-bar color API).
    *
-   * - `'in-progress'` → `🔵 <i>In progress…</i>\n\n`
-   * - `'done'`        → `✅ <b>Done</b>\n\n`
-   * - `'issue'`       → `⚠️ <b>Issue</b>\n\n`
+   * - `'in-progress'` → `🔵 _In progress…_\n\n`
+   * - `'done'`        → `✅ **Done**\n\n`
+   * - `'issue'`       → `⚠️ **Issue**\n\n`
    *
    * Unrecognised values are silently ignored. Omit for plain reply (default
    * behavior — identical to today's output).
@@ -130,21 +130,6 @@ export interface StreamReplyArgs {
 
 export interface StreamReplyState {
   activeDraftStreams: Map<string, DraftStreamHandle>
-  /**
-   * Tracks the parseMode each active stream was created with, keyed the
-   * same way as `activeDraftStreams`. Used by `handleStreamReply` to
-   * detect when a subsequent call's resolved parseMode differs from the
-   * one baked into the existing stream controller — in that case the
-   * stale stream is finalized + discarded and a fresh one is created
-   * with the new parseMode (see bug 1: PTY-tail creates an activity-lane
-   * stream with parseMode=undefined; a later explicit stream_reply on
-   * the same key with format:'html' would otherwise inherit undefined
-   * and send literal markdown).
-   *
-   * Optional for backwards compatibility with external callers that
-   * construct a StreamReplyState without it.
-   */
-  activeDraftParseModes?: Map<string, 'HTML' | 'MarkdownV2' | undefined>
   /**
    * Chats whose PTY preview is claimed by an in-flight reply/stream_reply
    * handler. PTY-tail partials for these keys are dropped to avoid
@@ -165,12 +150,14 @@ export interface StreamReplyState {
 export interface StreamReplyDeps {
   bot: { api: StreamBotApi }
   retry?: RetryPolicy
-  /** Markdown → HTML renderer (used when format === 'html'). */
-  markdownToHtml: (text: string) => string
-  /** MarkdownV2 escaper (used when format === 'markdownv2'). */
-  escapeMarkdownV2: (text: string) => string
   /** Whitespace repair applied to the raw caller text. */
   repairEscapedWhitespace: (text: string) => string
+  /**
+   * Promote lone prose paragraph breaks into GFM hard breaks so the rich
+   * path doesn't collapse them. Optional for backward compat; when omitted,
+   * the raw (repaired) text is sent unchanged.
+   */
+  normalizeParagraphBreaks?: (text: string) => string
   /** Validates the chat id against the access list. Throws on deny. */
   assertAllowedChat: (chatId: string) => void
   /** Resolves the effective thread id (explicit, last-inbound, or undefined). */
@@ -185,7 +172,8 @@ export interface StreamReplyDeps {
   getLatestInboundMessageId?: (chatId: string, threadId: number | null) => number | null
   /** Config: disable link previews. Default true. */
   disableLinkPreview: boolean
-  /** Config: fallback parse mode when args.format is omitted ('html' | 'markdownv2' | 'text'). */
+  /** Config: fallback format when args.format is omitted. Anything other
+   *  than the literal `'text'` is treated as the rich-markdown path (#2669). */
   defaultFormat: string
   /** Observability: per-call event. */
   logStreamingEvent: (ev: {
@@ -320,7 +308,9 @@ export async function handleStreamReply(
   deps: StreamReplyDeps,
 ): Promise<StreamReplyResult> {
   const chat_id = args.chat_id
-  const rawText = deps.repairEscapedWhitespace(args.text)
+  const rawText = deps.normalizeParagraphBreaks
+    ? deps.normalizeParagraphBreaks(deps.repairEscapedWhitespace(args.text))
+    : deps.repairEscapedWhitespace(args.text)
   const done = Boolean(args.done)
   const format = args.format ?? deps.defaultFormat
   if (done) {
@@ -341,53 +331,36 @@ export async function handleStreamReply(
   // the progressive-streaming contract documented in
   // profiles/default/CLAUDE.md. See #481.
 
-  let parseMode: 'HTML' | 'MarkdownV2' | undefined
-  let effectiveText: string
-  if (format === 'html') {
-    parseMode = 'HTML'
-    // Pre-validate the rendered HTML against Telegram's tag allowlist
-    // before send. The sanitizer escapes unknown tags, drops disallowed
-    // attributes, and auto-closes unbalanced tags so we don't trip
-    // Telegram's `400 Bad Request: can't parse entities` (issue #657).
-    effectiveText = sanitizeTelegramHtml(deps.markdownToHtml(rawText))
-  } else if (format === 'markdownv2') {
-    parseMode = 'MarkdownV2'
-    effectiveText = deps.escapeMarkdownV2(rawText)
-  } else {
-    parseMode = undefined
-    effectiveText = rawText
-  }
+  // Single rich-markdown path (#2669). The only fork is the literal
+  // `format:'text'` send (plain string, no markdown parsing); everything
+  // else ships the raw GFM markdown via the rich-message path. No
+  // markdown→HTML / MarkdownV2 rendering happens here anymore — the raw
+  // text IS the wire payload.
+  const literalText = format === 'text'
+  let effectiveText: string = rawText
 
-  // Inline status-accent header (issue #320 fallback). Prepended AFTER
-  // format rendering so it leads the fully-rendered body. Since
-  // stream_reply callers pass the full text snapshot each call, the
-  // header is prepended on every call that supplies `accent` — this
-  // keeps the rendered message consistent across edits. Callers that
-  // don't want the header on a subsequent edit simply omit `accent`.
-  // Unrecognised values are silently ignored (empty string returned).
+  // Inline status-accent header (issue #320 fallback). Prepended so it
+  // leads the body. Since stream_reply callers pass the full text snapshot
+  // each call, the header is prepended on every call that supplies
+  // `accent` — keeping the rendered message consistent across edits.
+  // Callers that don't want the header on a subsequent edit simply omit
+  // `accent`. Unrecognised values are silently ignored (empty string).
   if (args.accent != null) {
     const accentHeader = buildAccentHeader(args.accent)
     if (accentHeader.length > 0) {
       effectiveText = accentHeader + effectiveText
-      // Re-sanitize after prepending the HTML header so the combined
-      // body is still guaranteed parse-mode=HTML safe.
-      if (parseMode === 'HTML') {
-        effectiveText = sanitizeTelegramHtml(effectiveText)
-      }
     }
   }
 
   // Over-limit pre-check. Throws BEFORE touching stream state so that
-  // (a) a first call over 4096 fails cleanly instead of creating a
-  // half-initialized stream, and (b) a mid-stream update over 4096
+  // (a) a first call over the cap fails cleanly instead of creating a
+  // half-initialized stream, and (b) a mid-stream update over the cap
   // fails loudly instead of setting the internal `stopped=true` flag
   // and silently dropping all subsequent text. Either way the caller
   // sees isError:true and can fall back to `reply`, which chunks.
-  // Check the rendered text (post-markdown-to-HTML) because that's
-  // what actually goes to Telegram's 4096-char wire limit.
-  if (effectiveText.length > 4096) {
+  if (effectiveText.length > RICH_MESSAGE_MAX_CHARS) {
     throw new Error(
-      `stream_reply rejected: text exceeds Telegram's 4096-char limit ` +
+      `stream_reply rejected: text exceeds Telegram's ${RICH_MESSAGE_MAX_CHARS}-char rich-message limit ` +
         `(length=${effectiveText.length}, format=${format}). stream_reply does not ` +
         `auto-chunk — split the text or use \`reply\`, which chunks.`,
     )
@@ -401,30 +374,10 @@ export async function handleStreamReply(
   // targets. Cleared on turn_end by server.ts.
   state.suppressPtyPreview?.add(streamKey(chat_id, threadId))
   let stream = state.activeDraftStreams.get(sKey)
-
-  // Bug 1 fix: parseMode is baked into the stream controller at creation
-  // time. If a prior call created the stream with a different parseMode
-  // (e.g. PTY-tail auto-stream using 'text' → undefined, followed by an
-  // explicit stream_reply with format:'html'), reusing it would send
-  // literal markdown. Finalize + discard the stale stream so the block
-  // below creates a fresh one with the correct parseMode.
-  if (stream != null && state.activeDraftParseModes != null) {
-    const existingParseMode = state.activeDraftParseModes.get(sKey)
-    if (existingParseMode !== parseMode) {
-      try {
-        await stream.finalize()
-      } catch (err) {
-        // Best-effort: the in-flight edit may 429 or race. Surface to
-        // stderr so the orphaned message id isn't invisible.
-        deps.writeError(
-          `telegram channel: stream_reply parseMode-rotation finalize failed: ${err}\n`,
-        )
-      }
-      state.activeDraftStreams.delete(sKey)
-      state.activeDraftParseModes.delete(sKey)
-      stream = undefined
-    }
-  }
+  // #2669: there is now a single rendering mode (rich markdown), so the
+  // legacy parseMode-rotation that finalized + recreated a stream whose
+  // baked parseMode no longer matched is gone — every stream renders the
+  // same way and can be reused as-is.
 
   const streamExisted = stream != null
 
@@ -487,7 +440,7 @@ export async function handleStreamReply(
       bot: deps.bot,
       chatId: chat_id,
       threadId,
-      parseMode,
+      literalText,
       disableLinkPreview: deps.disableLinkPreview,
       // Pass undefined when caller didn't override, so draft-stream's
       // DM/group throttle defaults apply (400 ms DMs, 1000 ms groups).
@@ -531,7 +484,6 @@ export async function handleStreamReply(
       },
     })
     state.activeDraftStreams.set(sKey, stream)
-    state.activeDraftParseModes?.set(sKey, parseMode)
   }
 
   await stream.update(effectiveText)
@@ -539,7 +491,6 @@ export async function handleStreamReply(
   if (done) {
     await stream.finalize()
     state.activeDraftStreams.delete(sKey)
-    state.activeDraftParseModes?.delete(sKey)
     // #1713: stream_reply done=true is a NON-EVENT for the status
     // reaction. The reaction reflects current turn activity, not
     // delivery state — only the `turn_end` IPC handler finalizes (👍).
@@ -549,15 +500,15 @@ export async function handleStreamReply(
     // the #1713 issue body for the rationale.
 
     // Hard-fail surface: if the stream finalized without ever assigning
-    // a message id, the initial send never landed (4096+ chars hits
+    // a message id, the initial send never landed (over-cap text hits
     // draft-stream's length guard and silently stops). Throw so the MCP
     // caller sees isError:true instead of a misleading "finalized
     // (id: pending)". The caller can fall back to `reply`, which chunks.
     if (stream.getMessageId() == null) {
       throw new Error(
         `stream_reply finalized without sending any message (length=${rawText.length}, ` +
-          `max=4096). Telegram's per-message limit is 4096 chars and stream_reply does not ` +
-          `auto-chunk. Split the text or use \`reply\` (which chunks).`,
+          `max=${RICH_MESSAGE_MAX_CHARS}). Telegram's rich-message limit is ${RICH_MESSAGE_MAX_CHARS} chars and ` +
+          `stream_reply does not auto-chunk. Split the text or use \`reply\` (which chunks).`,
       )
     }
 

package/telegram-plugin/subagent-watcher.ts

@@ -44,7 +44,7 @@ import { projectSubagentLine, sanitizeCwdToProjectName, detectErrorInTranscriptL
 import { sanitiseToolArg } from './fleet-state.js'
 import { clipNarrative, describeToolUse } from './tool-activity-summary.js'
 import { REPLY_TOOLS, isDraftOfReply } from './narrative-dedup.js'
-import { escapeHtml, truncate } from './card-format.js'
+import { truncate } from './card-format.js'
 import { bumpSubagentActivity, recordSubagentStall, recordSubagentResume, recordSubagentEnd, reapStuckRunningRows, countRunningBackgroundSubagents } from './registry/subagents-schema.js'
 import { touchTurnActiveMarker } from './gateway/turn-active-marker.js'
 
@@ -1439,7 +1439,7 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
       if (idleMs >= threshold) {
         entry.stallNotified = true
         entry.stalledAt = n
-        const desc = escapeHtml(truncate(entry.description, 80))
+        const desc = truncate(entry.description, 80)
         const idleSec = Math.floor(idleMs / 1000)
         log?.(`subagent-watcher: stall detected for ${entry.agentId} (idle ${idleSec}s): ${desc}`)
         // Bug 3 fix (#333): persist the stall into the registry DB.

package/telegram-plugin/tests/answer-stream-silent-markers.test.ts

@@ -166,13 +166,16 @@ describe('answer-stream — silent-marker suppression at materialize()', () => {
     stream.update(prose)
     const msgId = await stream.materialize()
 
-    // materialize() sends a fresh message — prose is not a silent marker
+    // materialize() sends a fresh message — prose is not a silent marker.
+    // Post-#2669 the body is the RAW transcript markdown and there is no
+    // parse_mode (the gateway wrapper ships it via the rich-message path).
     expect(sendMessage).toHaveBeenCalledTimes(1)
     expect(sendMessage).toHaveBeenCalledWith(
       'chat45',
       prose,
-      expect.objectContaining({ parse_mode: 'HTML' }),
+      expect.objectContaining({ link_preview_options: { is_disabled: true } }),
     )
+    expect(sendMessage.mock.calls[0][2]).not.toHaveProperty('parse_mode')
     expect(typeof msgId).toBe('number')
   })