</Accordion>

<Accordion title="Rich message formatting">

Outbound text uses Telegram rich messages.

Outbound text uses standard Telegram HTML messages by default so replies remain readable across current Telegram clients.

Set `channels.telegram.richMessages: true` to opt into Bot API 10.1 rich messages:

```json5

{

channels: {

telegram: {

richMessages: true,

},

},

}

```

- Markdown text is rendered through OpenClaw's Markdown IR and sent as Telegram rich HTML.

- Explicit rich HTML payloads preserve supported Bot API 10.1 tags such as headings, tables, details, rich media, and formulas.

- Media captions still use Telegram HTML captions because rich messages do not replace captions.

This keeps model text away from Telegram Rich Markdown sigils, so currency like `$400-600K` is not parsed as math. Long rich text is split automatically across Telegram's rich text and rich block limits. Tables over Telegram's column limit are sent as code blocks.

Rich messages require compatible Telegram clients. Some current Desktop, Web, Android, and third-party clients display accepted rich messages as unsupported, so keep this option disabled unless every client used with the bot can render them.

Link previews are enabled by default. `channels.telegram.linkPreview: false` skips automatic entity detection for rich text.

</Accordion>

- command/menu: `commands.native`, `commands.nativeSkills`, `customCommands`

- threading/replies: `replyToMode`

- streaming: `streaming` (preview), `streaming.preview.toolProgress`, `blockStreaming`

- formatting/delivery: `textChunkLimit`, `chunkMode`, `linkPreview`, `responsePrefix`

- formatting/delivery: `textChunkLimit`, `chunkMode`, `richMessages`, `linkPreview`, `responsePrefix`

- media/network: `mediaMaxMb`, `mediaGroupFlushMs`, `timeoutSeconds`, `pollingStallThresholdMs`, `retry`, `network.autoSelectFamily`, `network.dangerouslyAllowPrivateNetwork`, `proxy`

- custom API root: `apiRoot` (Bot API root only; do not include `/bot<TOKEN>`)

- webhook: `webhookUrl`, `webhookSecret`, `webhookPath`, `webhookHost`

resolveTelegramOutboundClientTimeoutFloorSeconds,

} from "./client-fetch.js";

import { resolveTelegramTransport } from "./fetch.js";

import { TELEGRAM_TEXT_CHUNK_LIMIT } from "./outbound-adapter.js";

import { stringifyTelegramRawUpdateForLog } from "./raw-update-log.js";

import { TELEGRAM_RICH_TEXT_LIMIT } from "./rich-message.js";

import { createTelegramSendChatActionHandler } from "./sendchataction-401-backoff.js";

DEFAULT_GROUP_HISTORY_LIMIT,

);

const groupHistories = new Map<string, HistoryEntry[]>();

const telegramTextLimit =

telegramCfg.richMessages === true ? TELEGRAM_RICH_TEXT_LIMIT : TELEGRAM_TEXT_CHUNK_LIMIT;

const textLimit = Math.min(

resolveTextChunkLimit(cfg, "telegram", account.accountId, {

fallbackLimit: TELEGRAM_RICH_TEXT_LIMIT,

fallbackLimit: telegramTextLimit,

}),

TELEGRAM_RICH_TEXT_LIMIT,

telegramTextLimit,

);

const dmPolicy = telegramCfg.dmPolicy ?? "pairing";

const allowFrom = opts.allowFrom ?? telegramCfg.allowFrom;

expect(draftStream.clear).toHaveBeenCalledTimes(1);

});

it("renders default draft previews with standard Telegram HTML", async () => {

const draftStream = createDraftStream();

createTelegramDraftStream.mockReturnValue(draftStream);

dispatchReplyWithBufferedBlockDispatcher.mockImplementation(

async ({ dispatcherOptions, replyOptions }) => {

await replyOptions?.onPartialReply?.({ text: "# Heading" });

await dispatcherOptions.deliver({ text: "# Heading" }, { kind: "final" });

return { queuedFinal: true };

},

);

deliverReplies.mockResolvedValue({ delivered: true });

await dispatchWithContext({ context: createContext() });

const params = expectDraftStreamParams({});

const renderText = params.renderText as ((text: string) => Record<string, unknown>) | undefined;

expect(renderText?.("# Heading")).toEqual({

text: "Heading",

parseMode: "HTML",

});

});

it("renders rich draft previews only when enabled", async () => {

resolveMarkdownTableMode.mockReturnValueOnce("block");

const draftStream = createDraftStream();

createTelegramDraftStream.mockReturnValue(draftStream);

dispatchReplyWithBufferedBlockDispatcher.mockImplementation(

async ({ dispatcherOptions, replyOptions }) => {

await replyOptions?.onPartialReply?.({

text: "| A | B |\n| --- | --- |\n| 1 | 2 |",

});

await dispatcherOptions.deliver(

{ text: "| A | B |\n| --- | --- |\n| 1 | 2 |" },

{ kind: "final" },

);

return { queuedFinal: true };

},

);

deliverReplies.mockResolvedValue({ delivered: true });

await dispatchWithContext({

context: createContext(),

telegramCfg: { richMessages: true },

});

const params = expectDraftStreamParams({ richMessages: true });

const renderText = params.renderText as ((text: string) => Record<string, unknown>) | undefined;

const preview = renderText?.("| A | B |\n| --- | --- |\n| 1 | 2 |");

expect(preview?.richMessage).toEqual(

expect.objectContaining({

html: expect.stringContaining("<table>"),

}),

);

});

it("recovers forum thread context from a topic-scoped session key", async () => {

const recordInboundSession = vi.fn(async () => undefined);

const oldHistoryKey = "-1003774691294:topic:1";

telegramCfg: { streaming: { mode: "partial" } },

});

expectDraftStreamParams({ maxChars: 4096 });

expectDraftStreamParams({ maxChars: 4000 });

});

it("streams text-only finals into the answer message", async () => {

shouldSuppressTelegramError,

} from "./error-policy.js";

import { shouldSuppressLocalTelegramExecApprovalPrompt } from "./exec-approvals.js";

import { renderTelegramHtmlText } from "./format.js";

import { includesRecentTelegramGroupHistoryContext } from "./group-history-context.js";

import { beginTelegramInboundEventDeliveryCorrelation } from "./inbound-event-delivery.js";

import {

type LaneDeliveryResult,

type LaneName,

} from "./lane-delivery.js";

import { TELEGRAM_TEXT_CHUNK_LIMIT } from "./outbound-adapter.js";

import { recordOutboundMessageForPromptContext } from "./outbound-message-context.js";

import {

createTelegramReasoningStepState,

const draftMaxChars =

streamMode === "block"

? Math.min(resolveTelegramDraftStreamingChunking(cfg, route.accountId).maxChars, textLimit)

: Math.min(textLimit, TELEGRAM_RICH_TEXT_LIMIT);

: Math.min(

textLimit,

telegramCfg.richMessages === true ? TELEGRAM_RICH_TEXT_LIMIT : TELEGRAM_TEXT_CHUNK_LIMIT,

);

const tableMode = resolveMarkdownTableMode({

cfg,

channel: "telegram",

accountId: route.accountId,

supportsBlockTables: true,

});

const renderStreamText = (text: string) => ({

text,

richMessage: buildTelegramRichMarkdown(text, {

tableMode,

skipEntityDetection: telegramCfg.linkPreview === false,

}),

supportsBlockTables: telegramCfg.richMessages === true,

});

const renderStreamText = (text: string): TelegramDraftPreview =>

telegramCfg.richMessages === true

? {

text,

richMessage: buildTelegramRichMarkdown(text, {

tableMode,

skipEntityDetection: telegramCfg.linkPreview === false,

}),

}

: {

text: renderTelegramHtmlText(text, { tableMode }),

parseMode: "HTML",

};

const accountBlockStreamingEnabled =

resolveChannelStreamingBlockEnabled(telegramCfg) ??

cfg.agents?.defaults?.blockStreamingDefault === "on";

maxChars: draftMaxChars,

thread: threadSpec,

replyToMessageId: draftReplyToMessageId,

richMessages: telegramCfg.richMessages,

minInitialChars: draftMinInitialChars,

renderText: renderStreamText,

onSupersededPreview: (superseded) => {

thread: threadSpec,

tableMode,

chunkMode,

richMessages: telegramCfg.richMessages,

linkPreview: telegramCfg.linkPreview,

replyQuoteMessageId,

replyQuoteText,

expect(replyAt(deliverParams).isError).toBe(true);

});

it("uses rich messages for plugin command replies when enabled", async () => {

const { handler } = registerPlugCommand({

cfg: {

channels: {

telegram: {

richMessages: true,

},

},

},

registerOverrides: {

telegramCfg: { richMessages: true } as TelegramAccountConfig,

},

});

await handler(createPrivateCommandContext());

expect(firstDeliverRepliesParams().richMessages).toBe(true);

});

it("forwards topic-scoped binding context to Telegram plugin commands", async () => {

const { handler } = registerPlugCommand();

tableMode: ReturnType<typeof resolveMarkdownTableMode>;

chunkMode: TelegramChunkMode;

linkPreview?: boolean;

richMessages?: boolean;

}) => ({

cfg: params.cfg,

chatId: String(params.chatId),

tableMode: params.tableMode,

chunkMode: params.chunkMode,

linkPreview: params.linkPreview,

richMessages: params.richMessages,

});

const resolveCommandTargetSessionKey = (params: {

runtimeCfg: OpenClawConfig;

tableMode,

chunkMode,

linkPreview: runtimeTelegramCfg.linkPreview,

richMessages: runtimeTelegramCfg.richMessages,

});

let topicName: string | undefined;

if (isForum && resolvedThreadId != null) {

tableMode,

chunkMode,

linkPreview: runtimeTelegramCfg.linkPreview,

richMessages: runtimeTelegramCfg.richMessages,

});

const from = isGroup ? buildTelegramGroupFrom(chatId, threadSpec.id) : `telegram:${chatId}`;

const to = `telegram:${chatId}`;