clawgram 2.13.1 → 2.15.0

package/README.md

@@ -228,6 +228,7 @@ openclaw gateway restart
 | `groups` | object | `{}` | Allowed groups map keyed by explicit group id or `*` |
 | `proxy` | object | unset | Optional SOCKS4/SOCKS5 proxy for this account — see [Proxy (SOCKS4/SOCKS5)](#proxy-socks4socks5) |
 | `manageChats` | string[] | unset | Chats the assistant may **manage** — see [Chat management](#chat-management). Absent or empty = management off; `["*"]` = every chat |
+| `replyParseMode` | `"html"` \| `"markdown"` \| `"none"` | unset | Outbound format for replies, core-delivered text, captions and `send` calls that omit `parseMode` — see [Message formatting](#message-formatting) |
 | `twoFaPassword` | string \| SecretRef | unset | The account's Telegram 2FA password; read only by `transferOwnership` |
 
 Group config fields:
@@ -238,6 +239,22 @@ Group config fields:
 | `groupPolicy` | `"open"` \| `"mention"` | `"mention"` | `open` replies to any group message, `mention` only on @mention or reply-to-self |
 | `allowFrom` | string[] | `["*"]` | Allowed sender IDs/usernames inside that group |
 
+### Message formatting
+
+`replyParseMode` sets the outbound format for every path that does not name
+one explicitly: replies, core-delivered text, media captions, and `send`
+actions without a `parseMode` parameter. A per-call `parseMode` still wins.
+
+| Mode | Behavior |
+|---|---|
+| `"html"` | **Recommended for agents.** The text is rendered before sending (2.15.0): markdown (`**bold**`, `*italic*`, `` `code` ``, ``` fences, `[text](url)`, `# headings`, `> quotes`, `~~strike~~`, `\|\|spoiler\|\|`) becomes Telegram entities, hand-written Telegram HTML (`<b>`, `<a href>`, `<code>`, …) passes through, structural HTML (`<ul>`, `<p>`, …) is dropped, and stray `<`, `>`, `&` arrive as literal text instead of vanishing into a failed tag. Markdown inside code is never converted. |
+| `"markdown"` | GramJS's own markdown parser: `**`, `__`, `~~`, `` ` ``, ``` ``` ``` only — no links, no single-asterisk emphasis. |
+| `"none"` | No parsing at all: the text is delivered exactly as typed. |
+| unset | GramJS's historical default, which is its markdown parser — **not** plain text. Set `"none"` if you want plain. |
+
+Agent-authored messages mix markdown and HTML freely, so `"html"` is the mode
+that renders both. There is no reliable way to prompt a model out of writing
+markdown; rendering it is the deterministic fix.
 
 ### Configuration variant for example
 

package/dist/channel.js

@@ -596,7 +596,8 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                         const sendTextToConversation = async (args) => {
                             const targets = [conversationTarget, ...conversationFallbackTargets];
                             // Replies have no per-call parseMode slot — the format is an
-                            // account setting (2.3.1); absent keeps plain text.
+                            // account setting (2.3.1); absent keeps the GramJS default
+                            // (its markdown parser — not plain text, see 2.15.0 notes).
                             const replyParseMode = gram.replyParseMode;
                             let lastError;
                             for (const target of targets) {
@@ -1762,6 +1763,10 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                         target: uploadTo,
                         file,
                         caption: caption || undefined,
+                        // Same resolution as the text `send`: per-call value wins, an
+                        // omitted one inherits the account format (2.15.0). A caption is
+                        // the same prose as a message and renders identically.
+                        parseMode: (0, helpers_1.resolveOutboundParseMode)(params, cfg, uploadAccountId),
                         replyToMessageId: (0, helpers_1.resolveReplyToMessageIdForTarget)(rawUploadTo, uploadReplyToId),
                         messageThreadId: parseOptionalThreadId(uploadThreadId),
                         asVoice,
@@ -1834,10 +1839,15 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                         accountId: resolvedAccountId,
                     });
                 }
+                // Whom to greet is decided by the message this turn is answering, not
+                // by whoever spoke last. An agent replying to a request rarely passes
+                // `replyToId`, and until 2026-08-10 that fell through to the most
+                // recent sender: in an interleaved chat the owner's report went out
+                // addressed to a colleague who had asked something else entirely.
                 const groupReplyAddress = (0, group_reply_address_1.consumeGroupReplyAddress)({
                     accountId: resolvedAccountId,
                     chatId: to,
-                    replyToId,
+                    replyToId: replyToId ?? currentMessageId,
                 });
                 const requestedText = (0, helpers_1.readMessageText)(params).replaceAll("\\n", "\n");
                 // `NO_REPLY` is OpenClaw's "say nothing" sentinel. The inbound pipeline
@@ -1896,6 +1906,17 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                         currentMessageId,
                     });
                 }
+                // The turn has now spoken for itself. Recorded for every send into the
+                // chat this turn came from — with or without an explicit replyToId —
+                // so that core delivering the turn's final text a few seconds later
+                // can be recognised as an echo of this same answer.
+                if (currentMessageId !== null && currentMessageId !== undefined) {
+                    (0, group_visible_reply_guard_1.rememberTurnSend)({
+                        accountId: resolvedAccountId,
+                        chatId: to,
+                        currentMessageId,
+                    });
+                }
                 actionLog.info("clawgram handleAction send completed", {
                     accountId: resolvedAccountId,
                     to,
@@ -1969,6 +1990,28 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                 if (!gram) {
                     throw new Error(`clawgram: runtime not found for account ${ctx.accountId}`);
                 }
+                // The agent already answered this message with its own `send`, and this
+                // is core delivering the same turn's final text. Two messages for one
+                // answer is how 2026-08-10 read in a work chat: every request reported
+                // twice, in slightly different words, seconds apart.
+                //
+                // Core's own convention is that an agent which has sent a message
+                // returns NO_REPLY; this catches the turns that forget. The window is
+                // seconds wide, so a result the assistant comes back with later is
+                // still delivered.
+                if (ctx.replyToId !== null && ctx.replyToId !== undefined && (0, group_visible_reply_guard_1.hadTurnSendJustNow)({
+                    accountId: ctx.accountId,
+                    chatId: (0, helpers_1.normalizeOutboundTarget)(ctx.to),
+                    currentMessageId: ctx.replyToId,
+                })) {
+                    actionLog.warn("clawgram suppressing echo of a turn that already sent", {
+                        accountId: ctx.accountId,
+                        rawTo: ctx.to,
+                        replyToId: ctx.replyToId,
+                        textLength: ctx.text.length,
+                    });
+                    return { skipped: "duplicate" };
+                }
                 const groupReplyAddress = (0, group_reply_address_1.consumeGroupReplyAddress)({
                     accountId: ctx.accountId,
                     chatId: ctx.to,
@@ -2027,6 +2070,9 @@ const createChannelPlugin = (runtimes, pluginRuntime) => {
                     target,
                     file,
                     caption: ctx.caption ?? ctx.text,
+                    // Captions follow the account reply format like every other reply:
+                    // they are the same agent prose, just attached to a file (2.15.0).
+                    parseMode: gram.replyParseMode,
                     replyToMessageId: (0, helpers_1.resolveReplyToMessageIdForTarget)(ctx.to, ctx.replyToId),
                     messageThreadId,
                     asVoice: ctx.audioAsVoice === true,

package/dist/gramjs-client.js

@@ -8,6 +8,7 @@ const sessions_1 = require("telegram/sessions");
 // the package has no `exports` field to forbid it.
 const Password_1 = require("telegram/Password");
 const helpers_1 = require("./helpers");
+const html_render_1 = require("./html-render");
 const proxy_config_1 = require("./proxy-config");
 const secret_refs_1 = require("./secret-refs");
 const history_1 = require("./history");
@@ -323,10 +324,20 @@ class GramJsClientManager {
         const messageThreadId = args.messageThreadId ?? resolved.messageThreadId;
         const replyParams = buildForumReplyParams(messageThreadId, args.replyToMessageId);
         return this.client.sendMessage(resolved.peer, {
-            message: args.text,
-            // GramJS accepts "md" | "html"; absent keeps plain text so every
-            // pre-2.3.0 caller behaves exactly as before.
-            ...(args.parseMode ? { parseMode: args.parseMode === "markdown" ? "md" : "html" } : {}),
+            // In html mode the text is rendered first: the agent writes markdown,
+            // Telegram HTML, or both, and GramJS's HTML parser alone would ship
+            // the markdown as literal asterisks (2026-08-12 00:13 UTC, a whole
+            // monthly report of them).
+            message: args.parseMode === "html" ? (0, html_render_1.renderTelegramHtml)(args.text) : args.text,
+            // GramJS accepts "md" | "html". `false` switches parsing off — needed
+            // because an *absent* mode is not plain text: GramJS then applies its
+            // own default markdown parser, and always has. "none" is the honest
+            // spelling of "exactly as typed".
+            ...(args.parseMode === "none"
+                ? { parseMode: false }
+                : args.parseMode
+                    ? { parseMode: args.parseMode === "markdown" ? "md" : "html" }
+                    : {}),
             ...replyParams,
         });
     }
@@ -561,7 +572,18 @@ class GramJsClientManager {
         const replyParams = buildForumReplyParams(messageThreadId, args.replyToMessageId);
         return this.client.sendFile(resolved.peer, {
             file: args.file,
-            caption: args.caption,
+            // Captions are agent prose too — the outbound path sends `caption ??
+            // text` — so they render exactly like sendText does. Before 2.15.0
+            // captions carried no mode at all, which meant GramJS's default
+            // markdown pass, a third rendering behavior nobody chose.
+            caption: args.parseMode === "html" && args.caption
+                ? (0, html_render_1.renderTelegramHtml)(args.caption)
+                : args.caption,
+            ...(args.parseMode === "none"
+                ? { parseMode: false }
+                : args.parseMode
+                    ? { parseMode: args.parseMode === "markdown" ? "md" : "html" }
+                    : {}),
             ...replyParams,
             ...buildVoiceNoteParams(args.asVoice),
         });

package/dist/group-reply-address.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rememberGroupReplyAddress = rememberGroupReplyAddress;
 exports.consumeGroupReplyAddress = consumeGroupReplyAddress;
+exports.resetGroupReplyAddresses = resetGroupReplyAddresses;
 exports.buildGroupReplyAddress = buildGroupReplyAddress;
 const helpers_1 = require("./helpers");
 const groupReplyAddresses = new Map();
 const GROUP_REPLY_ADDRESS_TTL_MS = 10 * 60 * 1000;
-const GROUP_REPLY_LATEST_ID = "__latest__";
 function normalizeGroupReplyTarget(rawTarget) {
     if (typeof rawTarget !== "string") {
         return String(rawTarget ?? "").trim();
@@ -33,23 +33,20 @@ function rememberGroupReplyAddress(input) {
         address: input.address,
         expiresAt: Date.now() + GROUP_REPLY_ADDRESS_TTL_MS,
     });
-    const latestKey = buildGroupReplyAddressKey({
-        ...input,
-        replyToId: GROUP_REPLY_LATEST_ID,
-    });
-    if (latestKey) {
-        groupReplyAddresses.set(latestKey, {
-            address: input.address,
-            expiresAt: Date.now() + GROUP_REPLY_ADDRESS_TTL_MS,
-        });
-    }
 }
+/**
+ * The address remembered for one specific incoming message.
+ *
+ * There used to be a `__latest__` entry as well, so that a send carrying no
+ * `replyToId` still greeted somebody. In a chat where requests interleave that
+ * "somebody" is whoever spoke last, which on 2026-08-10 put the owner's report
+ * out as "@colleague, готово": the colleague read a result they had not asked
+ * for, and the owner's own request looked unanswered. Recency is not an answer
+ * to "who am I replying to", so the fallback is gone — callers pass the message
+ * the turn is actually answering, and no message means no greeting.
+ */
 function consumeGroupReplyAddress(input) {
-    const latestKey = buildGroupReplyAddressKey({
-        ...input,
-        replyToId: GROUP_REPLY_LATEST_ID,
-    });
-    const key = buildGroupReplyAddressKey(input) ?? latestKey;
+    const key = buildGroupReplyAddressKey(input);
     if (!key) {
         return undefined;
     }
@@ -58,14 +55,15 @@ function consumeGroupReplyAddress(input) {
         return undefined;
     }
     groupReplyAddresses.delete(key);
-    if (latestKey) {
-        groupReplyAddresses.delete(latestKey);
-    }
     if (stored.expiresAt < Date.now()) {
         return undefined;
     }
     return stored.address;
 }
+/** Test seam: the map is module state, and suites must not leak into each other. */
+function resetGroupReplyAddresses() {
+    groupReplyAddresses.clear();
+}
 function buildGroupReplyAddress(input) {
     const username = input.senderUsername?.replace(/^@/, "").trim();
     if (username) {

package/dist/group-visible-reply-guard.js

@@ -2,9 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasRecentVisibleGroupReply = hasRecentVisibleGroupReply;
 exports.rememberVisibleGroupReply = rememberVisibleGroupReply;
+exports.rememberTurnSend = rememberTurnSend;
+exports.hadTurnSendJustNow = hadTurnSendJustNow;
+exports.resetVisibleGroupReplies = resetVisibleGroupReplies;
 const helpers_1 = require("./helpers");
+/** When each visible reply went out, keyed by account + chat + incoming message. */
 const recentVisibleGroupReplies = new Map();
 const GROUP_VISIBLE_REPLY_TTL_MS = 10 * 60 * 1000;
+/**
+ * How long after the agent's own send core's delivery of the same turn's final
+ * text still counts as an echo rather than as something new.
+ *
+ * Measured on the live incident: `handleAction send` at 12:39:02, core's
+ * delivery at 12:39:09 — seven seconds, twice in a row. Work that produces
+ * genuinely new information takes far longer, and the window has to stay well
+ * under that: dropping a real result is worse than letting a duplicate through.
+ */
+const GROUP_TURN_ECHO_WINDOW_MS = 20 * 1000;
 function buildVisibleGroupReplyKey(input) {
     const chatId = (0, helpers_1.normalizeOutboundTarget)(String(input.chatId ?? "").trim());
     const currentMessageId = input.currentMessageId === null || input.currentMessageId === undefined
@@ -39,10 +53,59 @@ function hasRecentVisibleGroupReply(input) {
     }
     return true;
 }
-function rememberVisibleGroupReply(input) {
+function rememberVisibleGroupReply(input, sentAt = Date.now()) {
     const key = buildVisibleGroupReplyKey(input);
     if (!key) {
         return;
     }
-    recentVisibleGroupReplies.set(key, Date.now() + GROUP_VISIBLE_REPLY_TTL_MS);
+    recentVisibleGroupReplies.set(key, sentAt + GROUP_VISIBLE_REPLY_TTL_MS);
+}
+/**
+ * When a turn last spoke for itself, keyed the same way.
+ *
+ * Kept apart from `recentVisibleGroupReplies` on purpose: that map drives a
+ * ten-minute suppression of repeated sends, and widening what feeds it would
+ * quietly make that rule stricter. This one answers a different question —
+ * did core just echo the turn that has only now finished.
+ */
+const lastTurnSends = new Map();
+/** Records that the agent itself put a message in the chat during this turn. */
+function rememberTurnSend(input, sentAt = Date.now()) {
+    const key = buildVisibleGroupReplyKey(input);
+    if (!key) {
+        return;
+    }
+    lastTurnSends.set(key, sentAt);
+}
+/**
+ * True when this turn already put a visible message in this chat moments ago.
+ *
+ * The case it exists for: the agent answers by calling `send`, then returns
+ * text as well, and core delivers that text as a second message. Both are the
+ * same answer — on 2026-08-10 every request in a work chat was reported twice,
+ * and the reader had to work out that the two messages were one event.
+ *
+ * Bounded by `GROUP_TURN_ECHO_WINDOW_MS` rather than by the ten-minute TTL:
+ * beyond a few seconds the assistant is coming back with something new, and
+ * dropping that would lose a real result.
+ */
+function hadTurnSendJustNow(input, now = Date.now()) {
+    const key = buildVisibleGroupReplyKey(input);
+    if (!key) {
+        return false;
+    }
+    const sentAt = lastTurnSends.get(key);
+    if (sentAt === undefined) {
+        return false;
+    }
+    if (now - sentAt > GROUP_TURN_ECHO_WINDOW_MS) {
+        lastTurnSends.delete(key);
+        return false;
+    }
+    return true;
+}
+/** Test seam: module state must not leak between suites. */
+function resetVisibleGroupReplies() {
+    recentVisibleGroupReplies.clear();
+    lastTurnSends.clear();
 }

package/dist/helpers.js

@@ -564,15 +564,22 @@ function normalizeParseMode(raw) {
         return "markdown";
     if (value === "html")
         return "html";
-    throw new Error(`clawgram: invalid parseMode "${String(raw)}" — use "markdown" or "html"`);
+    // "none" switches GramJS parsing off entirely. It exists because absent is
+    // NOT plain text: GramJS falls back to its own markdown parser by default,
+    // which quietly ate `**` from "plain" sends since the fork began.
+    if (value === "none")
+        return "none";
+    throw new Error(`clawgram: invalid parseMode "${String(raw)}" — use "markdown", "html" or "none"`);
 }
 /**
  * Reply parse mode for the inbound reply path (2.3.1). The action `send`
  * takes parseMode per-call, but replies to a mention run through the reply
  * pipeline, which has no per-call slot — so the format is a channel setting:
- * `channels.clawgram.accounts.<id>.replyParseMode: "markdown" | "html"`.
- * Absent means plain text, exactly as before 2.3.1. An invalid value throws
- * at config-read time, loud and early, rather than shipping raw markup.
+ * `channels.clawgram.accounts.<id>.replyParseMode: "markdown" | "html" |
+ * "none"`. Absent keeps GramJS's historical default — its markdown parser,
+ * not plain text, which 2.3.1 believed and 2.15.0 disproved. An invalid
+ * value throws at config-read time, loud and early, rather than shipping
+ * raw markup.
  */
 function resolveReplyParseMode(cfg, accountId) {
     const channel = cfg?.channels?.["clawgram"];
@@ -617,8 +624,11 @@ function resolveDryRun(dryRun, params) {
 function resolveOutboundParseMode(params, cfg, accountId) {
     const raw = params?.parseMode;
     // An explicitly empty value is a decision, not an omission: send it raw.
+    // "none" (not undefined) is what actually delivers on that: an absent
+    // parseMode at the GramJS boundary means GramJS's own default markdown
+    // parser, which would still eat `**` out of a message about markup.
     if (raw === "" || raw === null) {
-        return undefined;
+        return "none";
     }
     return raw === undefined
         ? resolveReplyParseMode(cfg, accountId)

package/dist/html-render.js

@@ -0,0 +1,461 @@
+"use strict";
+/**
+ * Markdown → Telegram HTML rendering for outbound text (2.15.0).
+ *
+ * The account's reply format is `html`, and the agent writes what language
+ * models write: markdown. GramJS's HTML parser does not touch markdown, so
+ * every `**bold**` reached a live work chat with its asterisks showing —
+ * 2026-08-12 00:13 UTC, a 2167-character monthly report worth of them. The
+ * converse configuration is no better: GramJS's markdown mode knows five
+ * delimiters and no links, so the HTML links the agent is told to use would
+ * arrive as tag soup. Neither mode alone can carry what the agent produces,
+ * which is markdown, Telegram HTML, or both in one message.
+ *
+ * This renderer runs in front of GramJS's HTML parser and emits HTML that
+ * parser maps onto Telegram entities:
+ *
+ * - Markdown becomes tags: `**b**`, `*i*`, `_i_`, `__b__`, `~~s~~`,
+ *   `||spoiler||`, `` `code` ``, ``` fences (with language), `[text](url)`,
+ *   `# heading` (a bold line), `> quote` (a blockquote).
+ * - HTML the parser understands passes through, its attributes reduced to
+ *   the meaningful set. Bot-API-only names are mapped to what GramJS knows
+ *   (`tg-spoiler` → `spoiler`, `ins` → `u`, `strike` → `s`, `h1..h6` → `b`);
+ *   `<br>` becomes a newline.
+ * - Structural HTML Telegram cannot render (`<p>`, `<ul>`, `<li>`…) is
+ *   dropped exactly as the parser silently drops it today, keeping the text.
+ * - Everything else — a stray `<`, a bare `&`, a `<плейсхолдер>` — is
+ *   escaped, so it survives the parser as literal text instead of being
+ *   half-eaten as a failed tag.
+ *
+ * Markdown inside code — spans, fences, `<code>`/`<pre>` bodies — is never
+ * converted; code arrives verbatim. Already-valid Telegram HTML passes
+ * through unchanged, which is what keeps the links that are authored as
+ * `<a href="…">` working.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTelegramHtml = renderTelegramHtml;
+/** Tags GramJS's HTML parser turns into entities, plus aliases it does not
+ * know mapped onto ones it does. `canonical` is what gets emitted; `attrs`
+ * is the full set of attributes worth keeping for that tag. */
+const TELEGRAM_TAGS = {
+    b: { canonical: "b" },
+    strong: { canonical: "strong" },
+    i: { canonical: "i" },
+    em: { canonical: "em" },
+    u: { canonical: "u" },
+    ins: { canonical: "u" },
+    s: { canonical: "s" },
+    del: { canonical: "del" },
+    strike: { canonical: "s" },
+    spoiler: { canonical: "spoiler" },
+    "tg-spoiler": { canonical: "spoiler" },
+    a: { canonical: "a", attrs: ["href"] },
+    code: { canonical: "code", attrs: ["class"] },
+    pre: { canonical: "pre" },
+    blockquote: { canonical: "blockquote", attrs: ["expandable"] },
+    "tg-emoji": { canonical: "tg-emoji", attrs: ["emoji-id"] },
+    h1: { canonical: "b" },
+    h2: { canonical: "b" },
+    h3: { canonical: "b" },
+    h4: { canonical: "b" },
+    h5: { canonical: "b" },
+    h6: { canonical: "b" },
+};
+/** Structural HTML the parser swallows today; keep swallowing it rather than
+ * turning a `<ul>` the agent wrote into visible angle brackets. */
+const DROP_TAGS = new Set([
+    "p", "div", "span", "ul", "ol", "li", "hr", "table", "thead", "tbody",
+    "tr", "td", "th", "details", "summary", "img", "small", "sup", "sub",
+    "font", "center", "section", "article", "header", "footer", "main", "nav",
+]);
+const TAG_RE = /^<(\/?)([a-zA-Z][a-zA-Z0-9-]*)((?:"[^"]*"|'[^']*'|[^>"'])*)>/;
+const ATTR_RE = /([a-zA-Z-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+/** A character reference the parser will decode; everything else is a bare `&`. */
+const ENTITY_RE = /^&(?:#\d{1,7}|#[xX][0-9a-fA-F]{1,6}|[a-zA-Z][a-zA-Z0-9]{1,31});/;
+const WORD_RE = /[\p{L}\p{N}_]/u;
+/** GFM backslash-escapable punctuation, so `\*` means a literal asterisk. */
+const ESCAPABLE = new Set([..."\\`*_{}[]()#+-.!|~<>"]);
+const EMPHASIS = {
+    "*": [
+        { len: 3, open: "<b><i>", close: "</i></b>" },
+        { len: 2, open: "<b>", close: "</b>" },
+        { len: 1, open: "<i>", close: "</i>" },
+    ],
+    "_": [
+        { len: 3, open: "<b><i>", close: "</i></b>" },
+        { len: 2, open: "<b>", close: "</b>" },
+        { len: 1, open: "<i>", close: "</i>" },
+    ],
+    "~": [{ len: 2, open: "<s>", close: "</s>" }],
+    "|": [{ len: 2, open: "<spoiler>", close: "</spoiler>" }],
+};
+/** `&`/`<`/`>` escaped unconditionally — for code bodies generated from
+ * markdown, where a `&amp;` the author typed must arrive as `&amp;`. */
+function escapeAll(text) {
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+/** Like {@link escapeAll}, but an already-written character reference is kept,
+ * so hand-authored HTML (`a &lt; b`) is not double-escaped into `&amp;lt;`. */
+function escapeKeepEntities(text) {
+    let out = "";
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === "&") {
+            const m = ENTITY_RE.exec(text.slice(i));
+            if (m) {
+                out += m[0];
+                i += m[0].length - 1;
+            }
+            else {
+                out += "&amp;";
+            }
+        }
+        else if (c === "<") {
+            out += "&lt;";
+        }
+        else if (c === ">") {
+            out += "&gt;";
+        }
+        else {
+            out += c;
+        }
+    }
+    return out;
+}
+/** Attribute values may arrive raw (`?a=1&b=2`) or escaped (`&amp;`); decode
+ * the few references that matter, then encode once. Idempotent either way. */
+function escapeAttr(value) {
+    const decoded = value
+        .replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">")
+        .replace(/&quot;/g, "\"").replace(/&#0?39;/g, "'");
+    return decoded
+        .replace(/&/g, "&amp;").replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/** URL schemes worth turning into a link entity. Anything else stays text:
+ * a relative path or a bare word in `[x](y)` position is not a Telegram link. */
+const URL_RE = /^(https?:\/\/|tg:\/\/|mailto:)/i;
+function parseAttrs(raw) {
+    const attrs = new Map();
+    for (const m of raw.matchAll(ATTR_RE)) {
+        attrs.set(m[1].toLowerCase(), m[2] ?? m[3] ?? m[4] ?? "");
+    }
+    return attrs;
+}
+function buildOpenTag(canonical, allowed, attrs) {
+    let out = `<${canonical}`;
+    for (const name of allowed ?? []) {
+        if (!attrs.has(name))
+            continue;
+        const value = attrs.get(name) ?? "";
+        if (name === "href" && !URL_RE.test(value.trim()))
+            continue;
+        if (name === "class" && !/^language-[\w+#.-]+$/.test(value))
+            continue;
+        if (name === "emoji-id" && !/^\d+$/.test(value))
+            continue;
+        out += value === "" && name === "expandable" ? ` ${name}` : ` ${name}="${escapeAttr(value)}"`;
+    }
+    return out + ">";
+}
+function tryCodeSpan(s, i) {
+    let run = 0;
+    while (s[i + run] === "`")
+        run++;
+    let k = i + run;
+    while (k < s.length) {
+        if (s[k] !== "`") {
+            k++;
+            continue;
+        }
+        let end = k;
+        while (s[end] === "`")
+            end++;
+        if (end - k === run) {
+            let inner = s.slice(i + run, k);
+            if (inner.includes("\n\n"))
+                return null;
+            // GFM: one space is stripped from each side when both are present,
+            // so `` ` code ` `` can hold a leading backtick.
+            if (inner.length >= 2 && inner.startsWith(" ") && inner.endsWith(" ") && inner.trim() !== "") {
+                inner = inner.slice(1, -1);
+            }
+            return { html: `<code>${escapeAll(inner)}</code>`, next: end };
+        }
+        k = end;
+    }
+    return null;
+}
+function tryLink(s, i) {
+    let depth = 1;
+    let j = i + 1;
+    for (; j < s.length; j++) {
+        const c = s[j];
+        if (c === "\n")
+            return null;
+        if (c === "\\")
+            j++;
+        else if (c === "[")
+            depth++;
+        else if (c === "]" && --depth === 0)
+            break;
+    }
+    if (depth !== 0 || s[j + 1] !== "(")
+        return null;
+    let pdepth = 1;
+    let k = j + 2;
+    for (; k < s.length; k++) {
+        const c = s[k];
+        if (c === "\n")
+            return null;
+        if (c === "\\")
+            k++;
+        else if (c === "(")
+            pdepth++;
+        else if (c === ")" && --pdepth === 0)
+            break;
+    }
+    if (pdepth !== 0)
+        return null;
+    const label = s.slice(i + 1, j);
+    let dest = s.slice(j + 2, k).trim();
+    if (dest.startsWith("<") && dest.endsWith(">"))
+        dest = dest.slice(1, -1);
+    const ws = dest.search(/\s/);
+    if (ws !== -1)
+        dest = dest.slice(0, ws); // an optional "title" is dropped
+    if (label.length === 0 || !URL_RE.test(dest))
+        return null;
+    return { html: `<a href="${escapeAttr(dest)}">${renderInline(label)}</a>`, next: k + 1 };
+}
+function tryEmphasis(s, i) {
+    const ch = s[i];
+    const variants = EMPHASIS[ch];
+    if (!variants)
+        return null;
+    let run = 0;
+    while (s[i + run] === ch)
+        run++;
+    for (const v of variants) {
+        if (run < v.len)
+            continue;
+        const after = s[i + v.len];
+        // Left flank: the run must hug its content. `2 * 3` stays arithmetic.
+        if (after === undefined || /\s/.test(after))
+            continue;
+        // `_` must not open inside a word, or snake_case_names grow italics.
+        if (ch === "_" && i > 0 && WORD_RE.test(s[i - 1]))
+            continue;
+        const delim = ch.repeat(v.len);
+        let j = s.indexOf(delim, i + v.len);
+        while (j !== -1) {
+            const between = s.slice(i + v.len, j);
+            if (between.includes("\n\n"))
+                break; // an emphasis does not cross a blank line
+            const before = s[j - 1];
+            const afterClose = s[j + v.len];
+            const closes = before !== undefined && !/\s/.test(before)
+                && (ch !== "_" || afterClose === undefined || !WORD_RE.test(afterClose));
+            if (closes && between.length > 0) {
+                return { html: v.open + renderInline(between) + v.close, next: j + v.len };
+            }
+            j = s.indexOf(delim, j + 1);
+        }
+    }
+    return null;
+}
+/** Inline pass: markdown spans, allowed HTML, and escaping, over text that
+ * the block pass already cleared of fences, headings and quotes. */
+function renderInline(s) {
+    let out = "";
+    let i = 0;
+    while (i < s.length) {
+        const c = s[i];
+        if (c === "\\" && i + 1 < s.length && ESCAPABLE.has(s[i + 1])) {
+            const next = s[i + 1];
+            out += next === "<" ? "&lt;" : next === ">" ? "&gt;" : next;
+            i += 2;
+            continue;
+        }
+        if (c === "<") {
+            const m = TAG_RE.exec(s.slice(i));
+            if (m) {
+                const closing = m[1] === "/";
+                const name = m[2].toLowerCase();
+                if (name === "br") {
+                    if (!closing)
+                        out += "\n";
+                    i += m[0].length;
+                    continue;
+                }
+                const spec = TELEGRAM_TAGS[name];
+                if (spec) {
+                    if (closing) {
+                        out += `</${spec.canonical}>`;
+                        i += m[0].length;
+                        continue;
+                    }
+                    if (spec.canonical === "code" || spec.canonical === "pre") {
+                        // Code bodies pass through untouched by markdown: `**` inside
+                        // <code> is content, not emphasis.
+                        const close = s.toLowerCase().indexOf(`</${name}>`, i + m[0].length);
+                        if (close !== -1) {
+                            out += buildOpenTag(spec.canonical, spec.attrs, parseAttrs(m[3]))
+                                + escapeKeepEntities(s.slice(i + m[0].length, close))
+                                + `</${spec.canonical}>`;
+                            i = close + name.length + 3;
+                            continue;
+                        }
+                        // An unclosed <code> is not markup; fall through to a literal `<`.
+                    }
+                    else {
+                        out += buildOpenTag(spec.canonical, spec.attrs, parseAttrs(m[3]));
+                        i += m[0].length;
+                        continue;
+                    }
+                }
+                else if (DROP_TAGS.has(name)) {
+                    i += m[0].length;
+                    continue;
+                }
+            }
+            out += "&lt;";
+            i++;
+            continue;
+        }
+        if (c === "&") {
+            const m = ENTITY_RE.exec(s.slice(i));
+            if (m) {
+                out += m[0];
+                i += m[0].length;
+            }
+            else {
+                out += "&amp;";
+                i++;
+            }
+            continue;
+        }
+        if (c === ">") {
+            out += "&gt;";
+            i++;
+            continue;
+        }
+        if (c === "`") {
+            const span = tryCodeSpan(s, i);
+            if (span) {
+                out += span.html;
+                i = span.next;
+                continue;
+            }
+            let run = 0;
+            while (s[i + run] === "`")
+                run++;
+            out += s.slice(i, i + run);
+            i += run;
+            continue;
+        }
+        if (c === "[") {
+            const link = tryLink(s, i);
+            if (link) {
+                out += link.html;
+                i = link.next;
+                continue;
+            }
+            out += c;
+            i++;
+            continue;
+        }
+        if (c === "*" || c === "_" || c === "~" || c === "|") {
+            const em = tryEmphasis(s, i);
+            if (em) {
+                out += em.html;
+                i = em.next;
+                continue;
+            }
+            let run = 0;
+            while (s[i + run] === c)
+                run++;
+            out += s.slice(i, i + run);
+            i += run;
+            continue;
+        }
+        out += c;
+        i++;
+    }
+    return out;
+}
+const FENCE_OPEN_RE = /^\s{0,3}(`{3,}|~{3,})\s*(.*)$/;
+const FENCE_CLOSE_RE = /^\s{0,3}(`{3,}|~{3,})\s*$/;
+const HEADING_RE = /^\s{0,3}(#{1,6})\s+(.*)$/;
+const QUOTE_RE = /^\s{0,3}>\s?(.*)$/;
+/**
+ * Render agent-authored text — markdown, Telegram HTML, or a mix — into
+ * HTML for GramJS's `html` parse mode. Block constructs are handled here;
+ * everything between them goes through {@link renderInline} as one chunk,
+ * so an emphasis may span a soft line break but never a blank line.
+ */
+function renderTelegramHtml(input) {
+    const lines = input.split("\n");
+    const out = [];
+    let plain = [];
+    const flush = () => {
+        if (plain.length > 0) {
+            out.push(renderInline(plain.join("\n")));
+            plain = [];
+        }
+    };
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const fence = FENCE_OPEN_RE.exec(line);
+        if (fence) {
+            const marker = fence[1][0];
+            const minLen = fence[1].length;
+            const info = (fence[2].trim().split(/\s+/)[0] ?? "");
+            const lang = /^[\w+#.-]+$/.test(info) ? info : "";
+            const body = [];
+            let j = i + 1;
+            let closed = false;
+            for (; j < lines.length; j++) {
+                const close = FENCE_CLOSE_RE.exec(lines[j]);
+                if (close && close[1][0] === marker && close[1].length >= minLen) {
+                    closed = true;
+                    break;
+                }
+                body.push(lines[j]);
+            }
+            flush();
+            const code = escapeAll(body.join("\n"));
+            out.push(lang
+                ? `<pre><code class="language-${lang}">${code}</code></pre>`
+                : `<pre>${code}</pre>`);
+            i = closed ? j + 1 : lines.length;
+            continue;
+        }
+        const heading = HEADING_RE.exec(line);
+        if (heading) {
+            flush();
+            out.push(`<b>${renderInline(heading[2].trim())}</b>`);
+            i++;
+            continue;
+        }
+        if (QUOTE_RE.test(line)) {
+            flush();
+            const quoted = [];
+            let j = i;
+            for (; j < lines.length; j++) {
+                const q = QUOTE_RE.exec(lines[j]);
+                if (!q)
+                    break;
+                quoted.push(q[1]);
+            }
+            out.push(`<blockquote>${renderInline(quoted.join("\n"))}</blockquote>`);
+            i = j;
+            continue;
+        }
+        plain.push(line);
+        i++;
+    }
+    flush();
+    return out.join("\n");
+}

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "clawgram",
   "name": "Clawgram",
   "description": "Clawgram — personal Telegram (MTProto userbot) channel for OpenClaw. Your AI assistant reads and responds as you.",
-  "version": "2.13.1",
+  "version": "2.15.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
@@ -382,9 +382,10 @@
                   "enum": [
                     "markdown",
                     "md",
-                    "html"
+                    "html",
+                    "none"
                   ],
-                  "description": "Parse mode for replies (2.3.1). The send action takes parseMode per call; the reply pipeline has no per-call slot, so the reply format is configured here. Absent means plain text."
+                  "description": "Outbound format for replies, core-delivered text, captions and send calls that omit parseMode. html (2.15.0) renders agent markdown and Telegram HTML into entities; markdown is GramJS's five-delimiter parser; none disables parsing entirely. Absent keeps GramJS's historical default, which is its markdown parser — not plain text."
                 }
               },
               "required": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawgram",
-  "version": "2.13.1",
+  "version": "2.15.0",
   "description": "Clawgram — personal Telegram (MTProto userbot) channel for OpenClaw. Your AI assistant reads and responds as you.",
   "main": "./dist/index.js",
   "scripts": {