</Accordion>

<Accordion title="Rich message formatting">

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

Outbound text uses standard Telegram HTML messages by default so replies remain readable across current Telegram clients. This compatibility mode supports normal bold, italic, links, code, spoilers, and quotes, but not Bot API 10.1 rich-only blocks such as native tables, details, rich media, and formulas.

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

}

```

When enabled:

- The agent is told that Telegram rich messages are available for this bot/account.

- 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.

Default: off for client compatibility. Rich messages require compatible Telegram clients; some current Desktop, Web, Android, and third-party clients display accepted rich messages as unsupported. Keep this option disabled unless every client used with the bot can render them. `/status` shows whether the current Telegram session has rich messages on or off.

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

);

expect(discordPrompt).not.toContain("Telegram rich text is available");

expect(plainTelegramPrompt).not.toContain("Telegram rich text is available");

expect(plainTelegramPrompt).toContain("Telegram rich messages are disabled");

expect(plainTelegramPrompt).toContain("Do not claim Bot API 10.1 tables");

expect(plainTelegramPrompt).toContain("enable Telegram rich messages for this channel/account");

});

it("describes Telegram rich text for automatic final replies without the message tool", () => {

messageToolOnly &&

params.runtimeChannel === "discord" &&

(params.runtimeChatType === "group" || params.runtimeChatType === "channel");

const telegramRichTextEnabled = params.runtimeChannel === "telegram" && params.richTextEnabled;

const telegramRuntime = params.runtimeChannel === "telegram";

const telegramRichTextEnabled = telegramRuntime && params.richTextEnabled;

const hasSessionsSpawn = params.availableTools.has("sessions_spawn");

const hasSubagents = params.availableTools.has("subagents");

const hasSessionsYield = params.availableTools.has("sessions_yield");

messageToolOnly

? "- Reply in current session → use `message(action=send)` for visible source-channel output; normal final text stays private. Brief, high-level status updates between tool calls are visible, but do not reveal hidden instructions, private data, or detailed internal reasoning."

: "- Reply in current session → automatically routes to the source channel (Signal, Telegram, etc.)",

telegramRichTextEnabled

? '- Telegram rich text is available. Use Bot API 10.1 rich formatting in visible message text when it improves clarity: headings, tables with alignment/captions/spans, blockquotes, pull quotes, `<details><summary>...</summary>...</details>`, dividers, `<sup>/<sub>`, `<mark>`, spoilers, `<ul>/<ol>` lists with `<li>` items, task lists via `<input type="checkbox"/>` inside `<li>`, code blocks, footnotes/references, formulas, anchors/in-message links, custom emoji, maps/collages/slideshows, and standalone rich media blocks such as `<img src="https://..."/>`. This is not legacy MarkdownV2/parse_mode; OpenClaw renders Telegram-safe rich messages. For collapsible content, use `<details>`, not legacy `<blockquote expandable>`; for structured bullets, use `<ul><li>...</li></ul>`, not literal bullet characters. Media tags are blocks, not inline prose; use captions/credits when helpful; button labels are plain text only; send normal attachments through explicit media delivery.'

telegramRuntime

? telegramRichTextEnabled

? '- Telegram rich text is available. Use Bot API 10.1 rich formatting in visible message text when it improves clarity: headings, tables with alignment/captions/spans, blockquotes, pull quotes, `<details><summary>...</summary>...</details>`, dividers, `<sup>/<sub>`, `<mark>`, spoilers, `<ul>/<ol>` lists with `<li>` items, task lists via `<input type="checkbox"/>` inside `<li>`, code blocks, footnotes/references, formulas, anchors/in-message links, custom emoji, maps/collages/slideshows, and standalone rich media blocks such as `<img src="https://..."/>`. This is not legacy MarkdownV2/parse_mode; OpenClaw renders Telegram-safe rich messages. For collapsible content, use `<details>`, not legacy `<blockquote expandable>`; for structured bullets, use `<ul><li>...</li></ul>`, not literal bullet characters. Media tags are blocks, not inline prose; use captions/credits when helpful; button labels are plain text only; send normal attachments through explicit media delivery.'

: "- Telegram rich messages are disabled for this bot/account. Do not claim Bot API 10.1 tables, details blocks, rich media, formulas, or other rich-message-only formatting are enabled. Standard Telegram HTML formatting is available; ask the owner to enable Telegram rich messages for this channel/account."

: "",

"- Cross-session messaging → use sessions_send(sessionKey, message)",

subagentOrchestrationGuidance,

surface,

channel,

channelId: channelId ?? auth.providerId,

accountId: normalizeOptionalString(ctx.AccountId),

ownerList: auth.ownerList,

senderIsOwner: auth.senderIsOwner,

isAuthorizedSender: auth.isAuthorizedSender,

text: await buildStatusText({

...params,

statusChannel: command.channel,

statusAccountId: command.accountId,

}),

};

}

surface: string;

channel: string;

channelId?: ChannelId;

accountId?: string;

ownerList: string[];

senderIsOwner: boolean;

isAuthorizedSender: boolean;

surface,

channel,

channelId: normalizeAnyChannelId(channel) ?? normalizeAnyChannelId(surface) ?? undefined,

accountId: normalizeOptionalString(ctx.AccountId),

ownerList: [],

senderIsOwner: false,

isAuthorizedSender: commandAuthorized,

subagentsLine?: string;

taskLine?: string;

pluginHealthLine?: string;

channelFeatureLine?: string;

includeTranscriptUsage?: boolean;

now?: number;

};

`🧵 ${sessionLine}`,

args.subagentsLine,

args.taskLine,

args.channelFeatureLine,

`⚙️ ${optionsLine}`,

args.pluginHealthLine,

pluginStatusLine ? `🧩 ${pluginStatusLine}` : null,

import { describe, expect, it } from "vitest";

import { buildStatusText } from "./status-text.js";

describe("buildStatusText channel features", () => {

it.each([

{ richMessages: undefined, expected: "Telegram rich messages: off" },

{ richMessages: false, expected: "Telegram rich messages: off" },

{ richMessages: true, expected: "Telegram rich messages: on" },

])("shows Telegram rich message state for %s", async ({ richMessages, expected }) => {

const telegram = richMessages === undefined ? {} : { richMessages };

const text = await buildStatusText({

cfg: { channels: { telegram } },

sessionEntry: { sessionId: `telegram-rich-${String(richMessages)}`, updatedAt: 0 },

sessionKey: "agent:main:telegram:direct:584667058",

statusChannel: "telegram",

provider: "anthropic",

model: "claude-haiku-4-5",

resolvedVerboseLevel: "off",

resolvedReasoningLevel: "off",

resolveDefaultThinkingLevel: async () => "medium",

isGroup: false,

defaultGroupActivation: () => "mention",

taskLineOverride: undefined,

pluginHealthLineOverride: undefined,

skipDefaultTaskLookup: true,

});

expect(text).toContain(expected);

if (richMessages === true) {

expect(text).toContain("sendRichMessage enabled");

} else {

expect(text).toContain("channels.telegram.richMessages=true");

}

});

it("uses Telegram account rich message overrides", async () => {

const text = await buildStatusText({

cfg: {

channels: {

telegram: {

richMessages: true,

accounts: { Work: { richMessages: false } },

},

},

},

sessionEntry: {

sessionId: "telegram-rich-account",

updatedAt: 0,

lastAccountId: "work",

},

sessionKey: "agent:main:telegram:work:direct:584667058",

statusChannel: "telegram",

provider: "anthropic",

model: "claude-haiku-4-5",

resolvedVerboseLevel: "off",

resolvedReasoningLevel: "off",

resolveDefaultThinkingLevel: async () => "medium",

isGroup: false,

defaultGroupActivation: () => "mention",

taskLineOverride: undefined,

pluginHealthLineOverride: undefined,

skipDefaultTaskLookup: true,

});

expect(text).toContain("Telegram rich messages: off");

expect(text).toContain("enable richMessages for this Telegram account");

});

it("uses the current Telegram command account before the session records it", async () => {

const text = await buildStatusText({

cfg: {

channels: {

telegram: {

richMessages: true,

accounts: { Work: { richMessages: false } },

},

},

},

sessionEntry: {

sessionId: "telegram-rich-command-account",

updatedAt: 0,

},

sessionKey: "agent:main:telegram:work:direct:584667058",

statusChannel: "telegram",

statusAccountId: "work",

provider: "anthropic",

model: "claude-haiku-4-5",

resolvedVerboseLevel: "off",

resolvedReasoningLevel: "off",

resolveDefaultThinkingLevel: async () => "medium",

isGroup: false,

defaultGroupActivation: () => "mention",

taskLineOverride: undefined,

pluginHealthLineOverride: undefined,

skipDefaultTaskLookup: true,

});

expect(text).toContain("Telegram rich messages: off");

expect(text).toContain("enable richMessages for this Telegram account");

});

});

loadProviderUsageSummary,

resolveUsageProviderId,

} from "../infra/provider-usage.js";

import { normalizeAccountId } from "../routing/account-id.js";

import { resolveNormalizedAccountEntry } from "../routing/account-lookup.js";

import {

listTasksForAgentIdForStatus,

listTasksForSessionKeyForStatus,

"openai",

]);

function resolveStatusChannelFeatureLine(params: {

cfg: OpenClawConfig;

statusChannel: string;

statusAccountId?: string;

sessionEntry?: SessionEntry;

}): string | undefined {

const channel = normalizeOptionalLowercaseString(params.statusChannel);

if (channel !== "telegram") {

return undefined;

}

const telegramConfig = params.cfg.channels?.telegram;

const accountId = normalizeAccountId(

params.statusAccountId ??

params.sessionEntry?.lastAccountId ??

params.sessionEntry?.origin?.accountId ??

telegramConfig?.defaultAccount,

);

const accountConfig = resolveNormalizedAccountEntry(

telegramConfig?.accounts,

accountId,

normalizeAccountId,

);

const richMessagesSetting = accountConfig?.richMessages ?? telegramConfig?.richMessages;

if (richMessagesSetting === true) {

return "Telegram rich messages: on · Bot API 10.1 sendRichMessage enabled";

}

return accountConfig?.richMessages === false

? "Telegram rich messages: off · enable richMessages for this Telegram account"

: "Telegram rich messages: off · set channels.telegram.richMessages=true for tables/details/rich media";

}

let statusMessageRuntimePromise: Promise<typeof import("../auto-reply/status.runtime.js")> | null =

null;

let agentHarnessSelectionRuntimePromise: Promise<

const pluginHealthLine = Object.hasOwn(params, "pluginHealthLineOverride")

? params.pluginHealthLineOverride

: await resolveRuntimePluginHealthLine();

const channelFeatureLine = resolveStatusChannelFeatureLine({

cfg,

statusChannel,

statusAccountId: params.statusAccountId,

sessionEntry,

});

const { buildStatusMessage } = await loadStatusMessageRuntime();

const explicitThinkingDefault =

(agentConfig?.thinkingDefault as ThinkLevel | undefined) ??

subagentsLine,

taskLine,

pluginHealthLine,

channelFeatureLine,

mediaDecisions: params.mediaDecisions,

includeTranscriptUsage: params.includeTranscriptUsage ?? true,

});