clawgram 2.14.0 → 2.17.0

package/dist/helpers.js

@@ -10,6 +10,7 @@ exports.inferOutboundTargetKind = inferOutboundTargetKind;
 exports.routeKindFromChatType = routeKindFromChatType;
 exports.buildConversationTarget = buildConversationTarget;
 exports.buildScopedGroupPeerId = buildScopedGroupPeerId;
+exports.stripAccountScopedGroupId = stripAccountScopedGroupId;
 exports.stripReplyDirectiveTags = stripReplyDirectiveTags;
 exports.readLatestAssistantFallbackFromTranscript = readLatestAssistantFallbackFromTranscript;
 exports.resolveActionTarget = resolveActionTarget;
@@ -21,6 +22,7 @@ exports.resolveAllowFrom = resolveAllowFrom;
 exports.resolveGroupPolicy = resolveGroupPolicy;
 exports.resolveGroups = resolveGroups;
 exports.resolveGroupConfig = resolveGroupConfig;
+exports.resolveGroupPromptSettings = resolveGroupPromptSettings;
 exports.resolveActiveUsername = resolveActiveUsername;
 exports.normalizeAllowEntry = normalizeAllowEntry;
 exports.isSenderAllowed = isSenderAllowed;
@@ -89,6 +91,20 @@ function buildScopedGroupPeerId(accountId, chatId) {
     const scopedAccountId = (accountId ?? "default").trim() || "default";
     return `${scopedAccountId}:${chatId}`;
 }
+/**
+ * Inverse of `buildScopedGroupPeerId`. Core derives group ids from the session
+ * key, so a channel hook receives `<accountId>:<chatId>` while `groups` in the
+ * config is keyed by the bare chat id. Only this account's prefix is stripped;
+ * anything else passes through untouched.
+ */
+function stripAccountScopedGroupId(groupId, accountId) {
+    const raw = typeof groupId === "string" ? groupId.trim() : "";
+    if (!raw) {
+        return undefined;
+    }
+    const prefix = `${(accountId ?? "default").trim() || "default"}:`;
+    return raw.startsWith(prefix) ? raw.slice(prefix.length) : raw;
+}
 function stripReplyDirectiveTags(text) {
     return text
         .replace(/\[\[\s*reply_to_current\s*\]\]/gi, " ")
@@ -258,6 +274,28 @@ function resolveAllowFrom(value) {
 function resolveGroupPolicy(value) {
     return value === "open" ? "open" : "mention";
 }
+/**
+ * Per-group `skills` → core `replyOptions.skillFilter`, `systemPrompt` →
+ * `GroupSystemPrompt`. An empty `skills` array is kept as `[]` — "no skills
+ * in this chat" is an answer, the same one core gives `agents.list[].skills: []`
+ * — while a blank `systemPrompt` is unset rather than an empty trusted block.
+ */
+function resolveGroupPromptSettings(groupConfig) {
+    const settings = {};
+    if (!groupConfig) {
+        return settings;
+    }
+    if (Array.isArray(groupConfig.skills)) {
+        settings.skillFilter = groupConfig.skills
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+    if (typeof groupConfig.systemPrompt === "string" && groupConfig.systemPrompt.trim()) {
+        settings.systemPrompt = groupConfig.systemPrompt.trim();
+    }
+    return settings;
+}
 function resolveGroups(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return {};
@@ -273,6 +311,7 @@ function resolveGroups(value) {
                 enabled: groupConfig.enabled !== false,
                 groupPolicy: resolveGroupPolicy(groupConfig.groupPolicy),
                 allowFrom: resolveAllowFrom(groupConfig.allowFrom),
+                ...resolveGroupPromptSettings(groupConfig),
             },
         ];
     }).filter(([groupId]) => Boolean(groupId)));
@@ -564,15 +603,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 +663,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/history.js

@@ -16,6 +16,7 @@ exports.parseTimeBoundary = parseTimeBoundary;
 exports.parseLimit = parseLimit;
 exports.parseMessageId = parseMessageId;
 exports.parseListMessagesParams = parseListMessagesParams;
+exports.normalizeParticipants = normalizeParticipants;
 exports.parseListParticipantsParams = parseListParticipantsParams;
 exports.buildHistoryQuery = buildHistoryQuery;
 exports.normalizeChatKey = normalizeChatKey;
@@ -26,6 +27,7 @@ exports.collectHistoryWindow = collectHistoryWindow;
 exports.HISTORY_DEFAULT_LIMIT = 100;
 exports.HISTORY_MAX_LIMIT = 500;
 const media_1 = require("./media");
+const helpers_1 = require("./helpers");
 /**
  * Matches `normalize.ts` and `gramjs-client.ts` deliberately.
  *
@@ -119,6 +121,7 @@ function parseListMessagesParams(params) {
     if (since !== undefined && until !== undefined && since > until) {
         throw new Error("clawgram: since must not be later than until");
     }
+    const rawThreadId = params.threadId ?? params.topicId ?? params.messageThreadId ?? params.topic;
     return {
         target,
         limit: parseLimit(params.limit),
@@ -126,10 +129,61 @@ function parseListMessagesParams(params) {
         until,
         minId: parseMessageId(params.after, "after"),
         maxId: parseMessageId(params.before, "before"),
+        messageThreadId: parseMessageId(rawThreadId, "threadId"),
     };
 }
 exports.PARTICIPANTS_DEFAULT_LIMIT = 200;
 exports.PARTICIPANTS_MAX_LIMIT = 1000;
+/**
+ * Membership as the caller sees it.
+ *
+ * The handle comes through `resolveActiveUsername`, not off the raw field:
+ * once an account holds more than one username — several handles, or a
+ * collectible one — Telegram moves them into `usernames[]` and leaves the
+ * legacy `username` EMPTY. Reading the raw field is why the owner of this
+ * deployment appeared in every generated table as "(без тэга)" beside a bare
+ * numeric id, the only person without a handle in chats of 23, 9, 7 and 3.
+ */
+function normalizeParticipants(raw, options) {
+    if (!Array.isArray(raw))
+        return [];
+    const participants = [];
+    for (const entry of raw) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const candidate = entry;
+        const userId = toStringId(candidate.id);
+        if (!userId)
+            continue;
+        const member = {
+            userId,
+            username: (0, helpers_1.resolveActiveUsername)(candidate),
+            isBot: candidate.bot === true,
+        };
+        // Display names are personal data, so they are opt-in: only the identity
+        // linking flow asks for them, and it discards them once a link is made.
+        if (options.includeNames) {
+            if (typeof candidate.firstName === "string" && candidate.firstName.length > 0) {
+                member.firstName = candidate.firstName;
+            }
+            if (typeof candidate.lastName === "string" && candidate.lastName.length > 0) {
+                member.lastName = candidate.lastName;
+            }
+        }
+        participants.push(member);
+    }
+    return participants;
+}
+function parseParticipantsFilter(params) {
+    if (params.admins === true)
+        return "admins";
+    const raw = params.filter;
+    if (raw === undefined || raw === null || raw === "")
+        return "all";
+    if (raw === "all" || raw === "admins")
+        return raw;
+    throw new Error('clawgram: participants filter must be "all" or "admins"');
+}
 /**
  * Membership is asked for by chat, so a target is required. `limit` is clamped
  * for the same reason it is clamped when reading history: a large group must
@@ -142,15 +196,16 @@ function parseListParticipantsParams(params) {
         throw new Error("clawgram: participants requires a chatId");
     }
     const includeNames = params.includeNames === true || params.includeNames === "true";
+    const filter = parseParticipantsFilter(params);
     const rawLimit = params.limit;
     if (rawLimit === undefined || rawLimit === null || rawLimit === "") {
-        return { target, limit: exports.PARTICIPANTS_DEFAULT_LIMIT, includeNames };
+        return { target, limit: exports.PARTICIPANTS_DEFAULT_LIMIT, includeNames, filter };
     }
     const parsed = Number(rawLimit);
     if (!Number.isFinite(parsed) || parsed <= 0) {
         throw new Error("clawgram: participants limit must be a positive number");
     }
-    return { target, limit: Math.min(Math.floor(parsed), exports.PARTICIPANTS_MAX_LIMIT), includeNames };
+    return { target, limit: Math.min(Math.floor(parsed), exports.PARTICIPANTS_MAX_LIMIT), includeNames, filter };
 }
 /**
  * Builds the GramJS query for a window.
@@ -164,6 +219,11 @@ function parseListParticipantsParams(params) {
  */
 function buildHistoryQuery(args) {
     const query = { limit: args.limit };
+    // GramJS turns `replyTo` into messages.GetReplies, which is Telegram's way of
+    // asking for one forum topic rather than the whole chat.
+    if (args.messageThreadId !== undefined) {
+        query.replyTo = args.messageThreadId;
+    }
     if (args.until !== undefined) {
         query.offsetDate = args.until + 1;
     }

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");
+}