@overpod/mcp-telegram 1.28.0 → 1.32.0

package/dist/telegram-client.js

@@ -10,8 +10,8 @@ import { CustomFile } from "telegram/client/uploads.js";
 import { StringSession } from "telegram/sessions/index.js";
 import { Api } from "telegram/tl/index.js";
 import { RateLimiter } from "./rate-limiter.js";
-import { describeAdminLogAction, describeAdminLogDetails, describeKeyboardButton, mergeBannedRights, reactionToEmoji, summarizeAllStories, summarizeBoostsList, summarizeBoostsStatus, summarizeBroadcastStats, summarizeBusinessChatLinks, summarizeChannelDifference, summarizeGroupCall, summarizeGroupCallParticipants, summarizeMegagroupStats, summarizeMyBoosts, summarizePeerStories, summarizeQuickReplies, summarizeQuickReplyMessages, summarizeStarsStatus, summarizeStoriesById, summarizeStoryViewsList, summarizeUpdatesDifference, } from "./telegram-helpers.js";
-export { describeAdminLogAction, describeAdminLogDetails, describeKeyboardButton, mergeBannedRights, peerToCompact, reactionToEmoji, summarizeAllStories, summarizeBoost, summarizeBoostsList, summarizeBoostsStatus, summarizeBroadcastStats, summarizeBusinessChatLink, summarizeBusinessChatLinks, summarizeChannelDifference, summarizeGroupCall, summarizeGroupCallInfo, summarizeGroupCallParticipant, summarizeGroupCallParticipants, summarizeMegagroupStats, summarizeMyBoost, summarizeMyBoosts, summarizePeerStories, summarizePrepaidGiveaway, summarizeQuickReplies, summarizeQuickReply, summarizeQuickReplyMessage, summarizeQuickReplyMessages, summarizeStarsAmount, summarizeStarsStatus, summarizeStarsSubscription, summarizeStarsTransaction, summarizeStarsTransactionPeer, summarizeStoriesById, summarizeStoryItem, summarizeStoryView, summarizeStoryViewsList, summarizeUpdatesDifference, } from "./telegram-helpers.js";
+import { buildReplyTo, buildStoryPrivacyRules, describeAdminLogAction, describeAdminLogDetails, describeKeyboardButton, detectMediaType, extractDiceResult, extractMessageId, extractPeerId, extractPollMediaFromUpdates, extractStoryIdFromUpdates, generateRandomBigInt, mergeBannedRights, reactionToEmoji, summarizeAllStories, summarizeBoostsList, summarizeBoostsStatus, summarizeBroadcastStats, summarizeBusinessChatLink, summarizeBusinessChatLinks, summarizeChannelDifference, summarizeDiscussionMessage, summarizeEmojiStatus, summarizeGroupCall, summarizeGroupCallParticipants, summarizeGroupsForDiscussion, summarizeMegagroupStats, summarizeMyBoosts, summarizePeer, summarizePeerStories, summarizePoll, summarizeQuickReplies, summarizeQuickReplyMessages, summarizeReadParticipants, summarizeReportResult, summarizeStarsStatus, summarizeStoriesById, summarizeStoryViewsList, summarizeUpdatesDifference, } from "./telegram-helpers.js";
+export { buildStoryPrivacyRules, describeAdminLogAction, describeAdminLogDetails, describeKeyboardButton, detectMediaType, extractPeerId, extractPollMediaFromUpdates, extractStoryIdFromUpdates, mergeBannedRights, peerToCompact, reactionToEmoji, summarizeAllStories, summarizeBoost, summarizeBoostsList, summarizeBoostsStatus, summarizeBroadcastStats, summarizeBusinessChatLink, summarizeBusinessChatLinks, summarizeChannelDifference, summarizeDiscussionMessage, summarizeEmojiStatus, summarizeGroupCall, summarizeGroupCallInfo, summarizeGroupCallParticipant, summarizeGroupCallParticipants, summarizeGroupsForDiscussion, summarizeMegagroupStats, summarizeMyBoost, summarizeMyBoosts, summarizePeer, summarizePeerStories, summarizePoll, summarizePrepaidGiveaway, summarizeQuickReplies, summarizeQuickReply, summarizeQuickReplyMessage, summarizeQuickReplyMessages, summarizeReadParticipants, summarizeReportResult, summarizeStarsAmount, summarizeStarsStatus, summarizeStarsSubscription, summarizeStarsTransaction, summarizeStarsTransactionPeer, summarizeStoriesById, summarizeStoryItem, summarizeStoryView, summarizeStoryViewsList, summarizeUpdatesDifference, } from "./telegram-helpers.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const LEGACY_SESSION_FILE = join(__dirname, "..", ".telegram-session");
 const DEFAULT_SESSION_DIR = join(homedir(), ".mcp-telegram");
@@ -60,6 +60,9 @@ export class TelegramService {
     get sessionDir() {
         return dirname(this.sessionPath);
     }
+    hasLocalSession() {
+        return existsSync(this.sessionPath);
+    }
     // ─── Session & Auth ────────────────────────────────────────────────────────
     getClient() {
         return this.client;
@@ -195,25 +198,42 @@ export class TelegramService {
         }
     }
     /**
-     * Log out from Telegram completely — terminates the session on Telegram servers.
-     * After this, the session string becomes invalid and won't appear in "Active Sessions".
+     * Terminates the session on Telegram servers, destroys the client, and clears
+     * local session (in-memory + file). Returns true only when server-side revoke
+     * confirmed. False means server revoke could not be confirmed — local wipe
+     * was still attempted. Throws if local file removal failed so callers can
+     * surface the partial state instead of silently misreporting success.
      */
     async logOut() {
-        if (!this.client || !this.connected)
+        const wipeLocalOrThrow = async () => {
+            await this.clearSession();
+            if (existsSync(this.sessionPath)) {
+                throw new Error(`Local session file still present after clearSession: ${this.sessionPath}`);
+            }
+        };
+        if (!this.client || !this.connected) {
+            if (existsSync(this.sessionPath))
+                await wipeLocalOrThrow();
             return false;
+        }
+        const client = this.client;
+        let revoked = false;
         try {
-            await this.client.invoke(new Api.auth.LogOut());
-            await this.client.destroy();
-            this.connected = false;
-            this.sessionString = "";
-            this.client = null;
-            return true;
+            await client.invoke(new Api.auth.LogOut());
+            revoked = true;
         }
         catch (error) {
-            console.error("[telegram] logOut error:", error);
-            await this.disconnect();
-            return false;
+            console.error("[telegram] auth.LogOut failed:", error);
+        }
+        // destroy() failure must NOT mask a successful server revoke — log and continue.
+        try {
+            await client.destroy();
+        }
+        catch (err) {
+            console.error("[telegram] client.destroy failed during logOut:", err);
         }
+        await wipeLocalOrThrow();
+        return revoked;
     }
     isConnected() {
         return this.connected;
@@ -353,20 +373,60 @@ export class TelegramService {
             firstName: user.firstName ?? undefined,
         };
     }
-    async sendMessage(chatId, text, replyTo, parseMode, topicId) {
+    async sendMessage(chatId, text, replyTo, parseMode, topicId, extra) {
         if (!this.client || !this.connected)
             throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
         return this.rateLimiter.execute(async () => {
             const resolved = await this.resolvePeer(chatId);
+            // Raw path: high-level client.sendMessage does not support quoteText/effect.
+            // Fall back to messages.SendMessage when either is requested.
+            if (extra?.quoteText || extra?.effect) {
+                if (extra.quoteText && !replyTo) {
+                    throw new Error("quoteText requires replyTo — provide the message ID of the message you are quoting");
+                }
+                const replyToObj = extra.quoteText
+                    ? new Api.InputReplyToMessage({
+                        replyToMsgId: replyTo,
+                        topMsgId: topicId,
+                        quoteText: extra.quoteText,
+                    })
+                    : buildReplyTo(replyTo, topicId);
+                // GramJS parses md/html via the internal `_parseMessageText` helper. We feature-detect
+                // it so a future GramJS rename surfaces a clear error instead of silently sending plain.
+                let parsedText = text;
+                let entities;
+                if (parseMode) {
+                    // biome-ignore lint/suspicious/noExplicitAny: GramJS internal helper, no public typing
+                    const parser = client._parseMessageText;
+                    if (typeof parser !== "function") {
+                        throw new Error("GramJS version incompatible: parseMode not supported in quoteText/effect code path. Omit parseMode or upgrade GramJS.");
+                    }
+                    [parsedText, entities] = await parser.call(client, text, parseMode === "html" ? "html" : "md");
+                }
+                const result = await client.invoke(new Api.messages.SendMessage({
+                    peer: resolved,
+                    message: parsedText,
+                    randomId: generateRandomBigInt(),
+                    ...(replyToObj ? { replyTo: replyToObj } : {}),
+                    ...(entities?.length ? { entities } : {}),
+                    ...(extra.effect ? { effect: bigInt(extra.effect) } : {}),
+                }));
+                const id = extractMessageId(result);
+                if (id === undefined)
+                    throw new Error("Telegram did not return a message ID for sendMessage");
+                // Return a minimal UpdateShortSentMessage — it only carries `id`, avoiding fake peerId/date.
+                return new Api.UpdateShortSentMessage({ id, pts: 0, ptsCount: 0, date: Math.floor(Date.now() / 1000) });
+            }
             if (topicId) {
-                return await this.client?.sendMessage(resolved, {
+                return await client.sendMessage(resolved, {
                     message: text,
                     topMsgId: topicId,
                     ...(replyTo ? { replyTo } : {}),
                     ...(parseMode ? { parseMode: parseMode === "html" ? "html" : "md" } : {}),
                 });
             }
-            return await this.client?.sendMessage(resolved, {
+            return await client.sendMessage(resolved, {
                 message: text,
                 ...(replyTo ? { replyTo } : {}),
                 ...(parseMode ? { parseMode: parseMode === "html" ? "html" : "md" } : {}),
@@ -381,6 +441,188 @@ export class TelegramService {
             await this.client?.sendFile(resolved, { file: filePath, caption });
         }, `sendFile to ${chatId}`);
     }
+    async sendVoice(chatId, filePath, opts = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            // Duration is intentionally auto-detected by GramJS from the audio file —
+            // letting the AI override it would mis-report playback length in the Telegram UI.
+            const message = await client.sendFile(resolved, {
+                file: filePath,
+                voiceNote: true,
+                caption: opts.caption,
+                parseMode: opts.parseMode,
+                ...(opts.replyTo ? { replyTo: opts.replyTo } : {}),
+                ...(opts.topicId ? { topMsgId: opts.topicId } : {}),
+            });
+            return { id: message.id };
+        }, `sendVoice to ${chatId}`);
+    }
+    async sendVideoNote(chatId, filePath, opts = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const attributes = opts.duration || opts.length
+                ? [
+                    new Api.DocumentAttributeVideo({
+                        roundMessage: true,
+                        duration: opts.duration ?? 0,
+                        w: opts.length ?? 0,
+                        h: opts.length ?? 0,
+                    }),
+                ]
+                : undefined;
+            const message = await client.sendFile(resolved, {
+                file: filePath,
+                videoNote: true,
+                ...(opts.replyTo ? { replyTo: opts.replyTo } : {}),
+                ...(opts.topicId ? { topMsgId: opts.topicId } : {}),
+                ...(attributes ? { attributes } : {}),
+            });
+            return { id: message.id };
+        }, `sendVideoNote to ${chatId}`);
+    }
+    async sendContact(chatId, phone, firstName, opts = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const media = new Api.InputMediaContact({
+                phoneNumber: phone,
+                firstName,
+                lastName: opts.lastName ?? "",
+                vcard: opts.vcard ?? "",
+            });
+            const result = await client.invoke(new Api.messages.SendMedia({
+                peer: resolved,
+                media,
+                message: "",
+                randomId: generateRandomBigInt(),
+                replyTo: buildReplyTo(opts.replyTo, opts.topicId),
+            }));
+            const id = extractMessageId(result);
+            if (id === undefined)
+                throw new Error("Telegram did not return a message ID for sendContact");
+            return { id };
+        }, `sendContact to ${chatId}`);
+    }
+    async sendDice(chatId, emoji, opts = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const result = await client.invoke(new Api.messages.SendMedia({
+                peer: resolved,
+                media: new Api.InputMediaDice({ emoticon: emoji }),
+                message: "",
+                randomId: generateRandomBigInt(),
+                replyTo: buildReplyTo(opts.replyTo, opts.topicId),
+            }));
+            const dice = extractDiceResult(result);
+            if (!dice) {
+                const id = extractMessageId(result);
+                if (id === undefined)
+                    throw new Error("Telegram did not return a message ID for sendDice");
+                return { id };
+            }
+            return dice;
+        }, `sendDice to ${chatId}`);
+    }
+    async sendLocation(chatId, latitude, longitude, opts = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const geoPoint = new Api.InputGeoPoint({
+                lat: latitude,
+                long: longitude,
+                ...(opts.accuracyRadius !== undefined ? { accuracyRadius: opts.accuracyRadius } : {}),
+            });
+            const media = opts.livePeriod
+                ? new Api.InputMediaGeoLive({
+                    geoPoint,
+                    period: opts.livePeriod,
+                    ...(opts.heading !== undefined ? { heading: opts.heading } : {}),
+                    ...(opts.proximityRadius !== undefined ? { proximityNotificationRadius: opts.proximityRadius } : {}),
+                })
+                : new Api.InputMediaGeoPoint({ geoPoint });
+            const result = await client.invoke(new Api.messages.SendMedia({
+                peer: resolved,
+                media,
+                message: "",
+                randomId: generateRandomBigInt(),
+                replyTo: buildReplyTo(opts.replyTo, opts.topicId),
+            }));
+            const id = extractMessageId(result);
+            if (id === undefined)
+                throw new Error("Telegram did not return a message ID for sendLocation");
+            return { id };
+        }, `sendLocation to ${chatId}`);
+    }
+    async sendVenue(chatId, latitude, longitude, title, address, opts = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            const media = new Api.InputMediaVenue({
+                geoPoint: new Api.InputGeoPoint({ lat: latitude, long: longitude }),
+                title,
+                address,
+                provider: opts.provider ?? "foursquare",
+                venueId: opts.venueId ?? "",
+                venueType: opts.venueType ?? "",
+            });
+            const result = await client.invoke(new Api.messages.SendMedia({
+                peer: resolved,
+                media,
+                message: "",
+                randomId: generateRandomBigInt(),
+                replyTo: buildReplyTo(opts.replyTo, opts.topicId),
+            }));
+            const id = extractMessageId(result);
+            if (id === undefined)
+                throw new Error("Telegram did not return a message ID for sendVenue");
+            return { id };
+        }, `sendVenue to ${chatId}`);
+    }
+    async sendAlbum(chatId, items, opts = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        if (items.length < 2 || items.length > 10) {
+            throw new Error("Album requires 2-10 items");
+        }
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const resolved = await this.resolvePeer(chatId);
+            // Album-level caption lands on the first item; per-item captions stay as provided.
+            const captions = items.map((it, i) => (i === 0 ? (opts.caption ?? it.caption ?? "") : (it.caption ?? "")));
+            // GramJS sendFile auto-detects `file: string[]` and takes the _sendAlbum path,
+            // which invokes messages.UploadMedia per item + messages.SendMultiMedia.
+            const result = (await client.sendFile(resolved, {
+                file: items.map((it) => it.filePath),
+                caption: captions,
+                parseMode: opts.parseMode,
+                ...(opts.replyTo ? { replyTo: opts.replyTo } : {}),
+                ...(opts.topicId ? { topMsgId: opts.topicId } : {}),
+            }));
+            const ids = Array.isArray(result)
+                ? result.filter((m) => m instanceof Api.Message).map((m) => m.id)
+                : result instanceof Api.Message
+                    ? [result.id]
+                    : [];
+            if (ids.length === 0)
+                throw new Error("Telegram did not return any message IDs for sendAlbum");
+            return { ids };
+        }, `sendAlbum to ${chatId}`);
+    }
     async downloadMedia(chatId, messageId, downloadPath) {
         if (!this.client || !this.connected)
             throw new Error(NOT_CONNECTED_ERROR);
@@ -1593,6 +1835,246 @@ export class TelegramService {
         }
         return 0;
     }
+    // ─── Poll interaction ──────────────────────────────────────────────────────
+    async sendPollVote(chatId, messageId, optionIndexes) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const options = optionIndexes.map((i) => Buffer.from([i]));
+            const result = await client.invoke(new Api.messages.SendVote({ peer, msgId: messageId, options }));
+            const pollMedia = extractPollMediaFromUpdates(result);
+            const results = pollMedia?.results;
+            const poll = pollMedia?.poll;
+            return {
+                totalVoters: results?.totalVoters ?? 0,
+                chosenLabels: optionIndexes.map((i) => {
+                    const answer = poll?.answers?.[i];
+                    return answer ? answer.text.text : `#${i}`;
+                }),
+                isRetracted: optionIndexes.length === 0,
+            };
+        }, `sendPollVote ${chatId}/${messageId}`);
+    }
+    async getPollResults(chatId, messageId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const msgs = await client.getMessages(peer, { ids: [messageId] });
+            if (!(msgs[0]?.media instanceof Api.MessageMediaPoll)) {
+                throw new Error("Message is not a poll");
+            }
+            const pollMedia = msgs[0].media;
+            // Refresh results from server
+            try {
+                await client.invoke(new Api.messages.GetPollResults({ peer, msgId: messageId }));
+            }
+            catch {
+                // ignore — use whatever is in the message
+            }
+            return summarizePoll(pollMedia.poll, pollMedia.results);
+        }, `getPollResults ${chatId}/${messageId}`);
+    }
+    async getPollVoters(chatId, messageId, opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const optionIndex = opts?.optionIndex;
+            const result = (await client.invoke(new Api.messages.GetPollVotes({
+                peer,
+                id: messageId,
+                option: optionIndex !== undefined ? Buffer.from([optionIndex]) : undefined,
+                offset: opts?.offset,
+                limit: opts?.limit ?? 20,
+            })));
+            // Build user map
+            const userMap = new Map();
+            for (const u of result.users ?? []) {
+                const user = u;
+                const id = user.id?.toString() ?? "";
+                userMap.set(id, {
+                    name: [user.firstName, user.lastName].filter(Boolean).join(" ") || undefined,
+                    username: user.username ?? undefined,
+                });
+            }
+            const voters = (result.votes ?? []).map((v) => {
+                const vote = v;
+                const peerId = extractPeerId(vote.peer);
+                const info = userMap.get(peerId) ?? {};
+                let options = [];
+                if ("option" in vote && vote.option) {
+                    options = [Buffer.from(vote.option).toString("hex")];
+                }
+                else if ("options" in vote && vote.options) {
+                    options = vote.options.map((o) => Buffer.from(o).toString("hex"));
+                }
+                return {
+                    peerId,
+                    name: info.name,
+                    username: info.username,
+                    options,
+                    date: vote.date,
+                };
+            });
+            return { total: result.count, nextOffset: result.nextOffset, voters };
+        }, `getPollVoters ${chatId}/${messageId}`);
+    }
+    async closePoll(chatId, messageId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            // Step 1: fetch existing poll
+            const msgs = await client.getMessages(peer, { ids: [messageId] });
+            if (!(msgs[0]?.media instanceof Api.MessageMediaPoll)) {
+                throw new Error("Message is not a poll");
+            }
+            const pollMedia = msgs[0].media;
+            const originalPoll = pollMedia.poll;
+            // Step 2: build closed poll (preserve all flags)
+            const closedPoll = new Api.Poll({
+                id: originalPoll.id,
+                question: originalPoll.question,
+                answers: originalPoll.answers,
+                closed: true,
+                publicVoters: originalPoll.publicVoters,
+                multipleChoice: originalPoll.multipleChoice,
+                quiz: originalPoll.quiz,
+                closePeriod: originalPoll.closePeriod,
+                closeDate: originalPoll.closeDate,
+            });
+            // Step 3: edit message to close poll
+            const result = await client.invoke(new Api.messages.EditMessage({
+                peer,
+                id: messageId,
+                media: new Api.InputMediaPoll({ poll: closedPoll }),
+            }));
+            // Extract updated voter count from result updates
+            const pollInfo = extractPollMediaFromUpdates(result);
+            const totalVoters = pollInfo?.results?.totalVoters ?? pollMedia.results?.totalVoters ?? 0;
+            return { totalVoters };
+        }, `closePoll ${chatId}/${messageId}`);
+    }
+    // ─── Audio transcription ───────────────────────────────────────────────────
+    async transcribeAudio(chatId, messageId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const result = (await client.invoke(new Api.messages.TranscribeAudio({ peer, msgId: messageId })));
+            return {
+                transcriptionId: result.transcriptionId.toString(),
+                text: result.text ?? "",
+                pending: result.pending ?? false,
+                trialRemainsNum: result.trialRemainsNum,
+                trialRemainsUntilDate: result.trialRemainsUntilDate,
+            };
+        }, `transcribeAudio ${chatId}/${messageId}`);
+    }
+    async rateTranscription(chatId, messageId, transcriptionId, good) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        const client = this.client;
+        await this.rateLimiter.execute(async () => {
+            await client.invoke(new Api.messages.RateTranscribedAudio({
+                peer,
+                msgId: messageId,
+                transcriptionId: bigInt(transcriptionId),
+                good,
+            }));
+        }, `rateTranscription ${chatId}/${messageId}`);
+    }
+    // ─── Fact-check ────────────────────────────────────────────────────────────
+    async getFactCheck(chatId, messageIds) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const result = (await client.invoke(new Api.messages.GetFactCheck({ peer, msgId: messageIds })));
+            return result.map((fc, i) => ({
+                messageId: messageIds[i],
+                needCheck: fc.needCheck ?? false,
+                country: fc.country,
+                text: fc.text?.text,
+                hash: fc.hash.toString(),
+            }));
+        }, `getFactCheck ${chatId}`);
+    }
+    async editFactCheck(chatId, messageId, text, _opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        const client = this.client;
+        await this.rateLimiter.execute(async () => {
+            // Build TextWithEntities — basic plain text (no entity parsing for fact-checks)
+            const textObj = new Api.TextWithEntities({ text, entities: [] });
+            await client.invoke(new Api.messages.EditFactCheck({ peer, msgId: messageId, text: textObj }));
+        }, `editFactCheck ${chatId}/${messageId}`);
+    }
+    async deleteFactCheck(chatId, messageId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        const client = this.client;
+        await this.rateLimiter.execute(async () => {
+            await client.invoke(new Api.messages.DeleteFactCheck({ peer, msgId: messageId }));
+        }, `deleteFactCheck ${chatId}/${messageId}`);
+    }
+    // ─── Paid reactions ────────────────────────────────────────────────────────
+    async sendPaidReaction(chatId, messageId, count, opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const randomId = generateRandomBigInt();
+            const params = { peer, msgId: messageId, count, randomId };
+            if (opts?.private !== undefined)
+                params.private = opts.private;
+            // biome-ignore lint/suspicious/noExplicitAny: dynamic params for optional `private` field
+            await client.invoke(new Api.messages.SendPaidReaction(params));
+            return { count };
+        }, `sendPaidReaction ${chatId}/${messageId}`);
+    }
+    async togglePaidReactionPrivacy(chatId, messageId, privateFlag) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        const client = this.client;
+        await this.rateLimiter.execute(async () => {
+            await client.invoke(new Api.messages.TogglePaidReactionPrivacy({ peer, msgId: messageId, private: privateFlag }));
+        }, `togglePaidReactionPrivacy ${chatId}/${messageId}`);
+    }
+    async getPaidReactionPrivacy() {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const result = await client.invoke(new Api.messages.GetPaidReactionPrivacy());
+            let list = [];
+            if (result instanceof Api.Updates || result instanceof Api.UpdatesCombined) {
+                list = result.updates;
+            }
+            else if (result instanceof Api.UpdateShort) {
+                list = [result.update];
+            }
+            for (const u of list) {
+                if (u instanceof Api.UpdatePaidReactionPrivacy) {
+                    return { private: Boolean(u.private) };
+                }
+            }
+            return { private: false };
+        }, "getPaidReactionPrivacy");
+    }
     async getForumTopics(chatId, limit = 100) {
         if (!this.client || !this.connected)
             throw new Error(NOT_CONNECTED_ERROR);
@@ -3105,6 +3587,412 @@ export class TelegramService {
             return summarizeBusinessChatLinks(response);
         }, "getBusinessChatLinks");
     }
+    // ─── Profile write (v1.32.0) ───────────────────────────────────────────────
+    async setEmojiStatus(opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            let emojiStatus;
+            if (opts.collectibleId) {
+                emojiStatus = new Api.InputEmojiStatusCollectible({
+                    collectibleId: bigInt(opts.collectibleId),
+                    until: opts.untilUnix,
+                });
+            }
+            else if (opts.documentId) {
+                emojiStatus = new Api.EmojiStatus({
+                    documentId: bigInt(opts.documentId),
+                    until: opts.untilUnix,
+                });
+            }
+            else {
+                emojiStatus = new Api.EmojiStatusEmpty();
+            }
+            await client.invoke(new Api.account.UpdateEmojiStatus({ emojiStatus }));
+        }, "setEmojiStatus");
+    }
+    async listEmojiStatuses(kind, limit) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const hash = bigInt(0);
+            let resp;
+            if (kind === "recent") {
+                resp = await client.invoke(new Api.account.GetRecentEmojiStatuses({ hash }));
+            }
+            else if (kind === "channel_default") {
+                resp = await client.invoke(new Api.account.GetChannelDefaultEmojiStatuses({ hash }));
+            }
+            else if (kind === "collectible") {
+                resp = await client.invoke(new Api.account.GetCollectibleEmojiStatuses({ hash }));
+            }
+            else {
+                resp = await client.invoke(new Api.account.GetDefaultEmojiStatuses({ hash }));
+            }
+            if (resp.className === "account.EmojiStatusesNotModified")
+                return [];
+            const statuses = resp.statuses ?? [];
+            return statuses.slice(0, limit).map(summarizeEmojiStatus);
+        }, `listEmojiStatuses ${kind}`);
+    }
+    async clearRecentEmojiStatuses() {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            await client.invoke(new Api.account.ClearRecentEmojiStatuses());
+        }, "clearRecentEmojiStatuses");
+    }
+    async setProfileColor(opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            await client.invoke(new Api.account.UpdateColor({
+                forProfile: opts.forProfile || undefined,
+                color: opts.color,
+                backgroundEmojiId: opts.backgroundEmojiId ? bigInt(opts.backgroundEmojiId) : undefined,
+            }));
+        }, "setProfileColor");
+    }
+    async setBirthday(opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const birthday = opts.clear || !opts.day || !opts.month
+                ? undefined
+                : new Api.Birthday({ day: opts.day, month: opts.month, year: opts.year });
+            await client.invoke(new Api.account.UpdateBirthday({ birthday }));
+        }, "setBirthday");
+    }
+    async setPersonalChannel(opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            if (opts.clear) {
+                await client.invoke(new Api.account.UpdatePersonalChannel({ channel: new Api.InputChannelEmpty() }));
+                return null;
+            }
+            const entity = await client.getInputEntity(opts.channelId ?? "");
+            if (!(entity instanceof Api.InputPeerChannel)) {
+                throw new Error(`Not a channel: ${opts.channelId}`);
+            }
+            const channel = new Api.InputChannel({
+                channelId: entity.channelId,
+                accessHash: entity.accessHash,
+            });
+            await client.invoke(new Api.account.UpdatePersonalChannel({ channel }));
+            const info = await client.getEntity(entity);
+            return "title" in info ? info.title : (opts.channelId ?? "");
+        }, `setPersonalChannel ${opts.channelId ?? "clear"}`);
+    }
+    async setProfilePhoto(opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const inputFile = await client.uploadFile({
+                file: new CustomFile(opts.filePath.split("/").pop() ?? "upload", (await import("node:fs")).statSync(opts.filePath).size, opts.filePath),
+                workers: 4,
+            });
+            const request = opts.isVideo
+                ? new Api.photos.UploadProfilePhoto({
+                    fallback: opts.fallback || undefined,
+                    video: inputFile,
+                    videoStartTs: opts.videoStartTs,
+                })
+                : new Api.photos.UploadProfilePhoto({
+                    fallback: opts.fallback || undefined,
+                    file: inputFile,
+                });
+            const result = await client.invoke(request);
+            const photo = result.photo;
+            return { id: photo.id.toString() };
+        }, "setProfilePhoto");
+    }
+    async deleteProfilePhotos(photoIds) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const me = await client.getMe();
+            const all = await client.invoke(new Api.photos.GetUserPhotos({
+                userId: me.id,
+                offset: 0,
+                maxId: bigInt(0),
+                limit: 100,
+            }));
+            const byId = new Map();
+            for (const p of all.photos) {
+                if (p instanceof Api.Photo)
+                    byId.set(p.id.toString(), p);
+            }
+            const inputs = [];
+            const missing = [];
+            for (const pid of photoIds) {
+                const photo = byId.get(pid);
+                if (!photo) {
+                    missing.push(pid);
+                    continue;
+                }
+                inputs.push(new Api.InputPhoto({
+                    id: photo.id,
+                    accessHash: photo.accessHash,
+                    fileReference: photo.fileReference,
+                }));
+            }
+            if (inputs.length === 0) {
+                throw new Error(`No matching photos found. Missing IDs: ${missing.join(", ")}`);
+            }
+            const deletedIds = await client.invoke(new Api.photos.DeletePhotos({ id: inputs }));
+            return { deleted: deletedIds.map((x) => x.toString()), missing };
+        }, "deleteProfilePhotos");
+    }
+    // ─── Business write (v1.32.0) ──────────────────────────────────────────────
+    async buildBusinessRecipients(opts) {
+        const flags = {};
+        switch (opts.audience) {
+            case "all_new":
+                flags.contacts = true;
+                flags.nonContacts = true;
+                break;
+            case "contacts_only":
+                flags.contacts = true;
+                break;
+            case "non_contacts":
+                flags.nonContacts = true;
+                break;
+            case "existing_only":
+                flags.existingChats = true;
+                break;
+        }
+        if (opts.includeUsers?.length) {
+            flags.users = await this.resolveInputUsers(opts.includeUsers);
+        }
+        else if (opts.excludeUsers?.length) {
+            flags.users = await this.resolveInputUsers(opts.excludeUsers);
+            flags.excludeSelected = true;
+        }
+        return new Api.InputBusinessRecipients({ ...flags });
+    }
+    async resolveInputUsers(ids) {
+        if (!this.client)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        const result = [];
+        for (const id of ids) {
+            const entity = await client.getInputEntity(id);
+            if (entity instanceof Api.InputPeerUser) {
+                result.push(new Api.InputUser({ userId: entity.userId, accessHash: entity.accessHash }));
+            }
+            else {
+                throw new Error(`Not a user: ${id}`);
+            }
+        }
+        return result;
+    }
+    async parseEntities(text, parseMode) {
+        if (!this.client || !parseMode)
+            return { text };
+        // biome-ignore lint/suspicious/noExplicitAny: internal GramJS API
+        const parser = this.client._parseMessageText?.bind(this.client);
+        if (!parser)
+            return { text };
+        const [parsedText, entities] = await parser(text, parseMode === "md" ? "markdown" : "html");
+        return { text: parsedText, entities: entities?.length ? entities : undefined };
+    }
+    async setBusinessWorkHours(opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            if (opts.clear) {
+                await client.invoke(new Api.account.UpdateBusinessWorkHours({}));
+                return;
+            }
+            const dayOffsets = {
+                mon: 0,
+                tue: 1,
+                wed: 2,
+                thu: 3,
+                fri: 4,
+                sat: 5,
+                sun: 6,
+            };
+            const weeklyOpen = (opts.schedule ?? []).map((s) => {
+                const [fh, fm] = s.openFrom.split(":").map(Number);
+                const [th, tm] = s.openTo.split(":").map(Number);
+                const base = (dayOffsets[s.day] ?? 0) * 1440;
+                return new Api.BusinessWeeklyOpen({
+                    startMinute: base + fh * 60 + fm,
+                    endMinute: base + th * 60 + tm,
+                });
+            });
+            await client.invoke(new Api.account.UpdateBusinessWorkHours({
+                businessWorkHours: new Api.BusinessWorkHours({
+                    openNow: opts.openNow,
+                    timezoneId: opts.timezone ?? "",
+                    weeklyOpen,
+                }),
+            }));
+        }, "setBusinessWorkHours");
+    }
+    async setBusinessLocation(opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            if (opts.clear) {
+                await client.invoke(new Api.account.UpdateBusinessLocation({}));
+                return;
+            }
+            const geoPoint = opts.latitude !== undefined && opts.longitude !== undefined
+                ? new Api.InputGeoPoint({ lat: opts.latitude, long: opts.longitude })
+                : undefined;
+            await client.invoke(new Api.account.UpdateBusinessLocation({ geoPoint, address: opts.address }));
+        }, "setBusinessLocation");
+    }
+    async setBusinessGreeting(opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            if (opts.clear) {
+                await client.invoke(new Api.account.UpdateBusinessGreetingMessage({}));
+                return;
+            }
+            const recipients = await this.buildBusinessRecipients({
+                audience: opts.audience,
+                includeUsers: opts.includeUsers,
+                excludeUsers: opts.excludeUsers,
+            });
+            await client.invoke(new Api.account.UpdateBusinessGreetingMessage({
+                message: new Api.InputBusinessGreetingMessage({
+                    shortcutId: opts.shortcutId ?? 0,
+                    recipients,
+                    noActivityDays: opts.noActivityDays,
+                }),
+            }));
+        }, "setBusinessGreeting");
+    }
+    async setBusinessAway(opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            if (opts.clear) {
+                await client.invoke(new Api.account.UpdateBusinessAwayMessage({}));
+                return;
+            }
+            const scheduleObj = opts.schedule === "always"
+                ? new Api.BusinessAwayMessageScheduleAlways()
+                : opts.schedule === "outside_hours"
+                    ? new Api.BusinessAwayMessageScheduleOutsideWorkHours()
+                    : new Api.BusinessAwayMessageScheduleCustom({
+                        startDate: opts.customFrom ?? 0,
+                        endDate: opts.customTo ?? 0,
+                    });
+            const recipients = await this.buildBusinessRecipients({
+                audience: opts.audience,
+                includeUsers: opts.includeUsers,
+                excludeUsers: opts.excludeUsers,
+            });
+            await client.invoke(new Api.account.UpdateBusinessAwayMessage({
+                message: new Api.InputBusinessAwayMessage({
+                    offlineOnly: opts.offlineOnly || undefined,
+                    shortcutId: opts.shortcutId ?? 0,
+                    schedule: scheduleObj,
+                    recipients,
+                }),
+            }));
+        }, "setBusinessAway");
+    }
+    async setBusinessIntro(opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            if (opts.clear) {
+                await client.invoke(new Api.account.UpdateBusinessIntro({}));
+                return;
+            }
+            const sticker = opts.stickerId && opts.stickerAccessHash && opts.stickerFileReference
+                ? new Api.InputDocument({
+                    id: bigInt(opts.stickerId),
+                    accessHash: bigInt(opts.stickerAccessHash),
+                    fileReference: Buffer.from(opts.stickerFileReference, "hex"),
+                })
+                : undefined;
+            await client.invoke(new Api.account.UpdateBusinessIntro({
+                intro: new Api.InputBusinessIntro({
+                    title: opts.title ?? "",
+                    description: opts.description ?? "",
+                    sticker,
+                }),
+            }));
+        }, "setBusinessIntro");
+    }
+    async createBusinessChatLink(opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const { text, entities } = await this.parseEntities(opts.message, opts.parseMode);
+            const result = await client.invoke(new Api.account.CreateBusinessChatLink({
+                link: new Api.InputBusinessChatLink({
+                    message: text,
+                    entities,
+                    title: opts.title,
+                }),
+            }));
+            const summary = summarizeBusinessChatLink(result);
+            const slug = result.link.split("/").pop() ?? "";
+            return { ...summary, slug };
+        }, "createBusinessChatLink");
+    }
+    async editBusinessChatLink(opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const { text, entities } = await this.parseEntities(opts.message, opts.parseMode);
+            const result = await client.invoke(new Api.account.EditBusinessChatLink({
+                slug: opts.slug,
+                link: new Api.InputBusinessChatLink({
+                    message: text,
+                    entities,
+                    title: opts.title,
+                }),
+            }));
+            return summarizeBusinessChatLink(result);
+        }, `editBusinessChatLink ${opts.slug}`);
+    }
+    async deleteBusinessChatLink(slug) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            await client.invoke(new Api.account.DeleteBusinessChatLink({ slug }));
+        }, `deleteBusinessChatLink ${slug}`);
+    }
+    async resolveBusinessChatLink(slug) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        return this.rateLimiter.execute(async () => {
+            const result = await client.invoke(new Api.account.ResolveBusinessChatLink({ slug }));
+            const r = result;
+            return {
+                peer: summarizePeer(r.peer),
+                message: r.message,
+                entityCount: r.entities?.length ?? 0,
+            };
+        }, `resolveBusinessChatLink ${slug}`);
+    }
     // ─── Group calls ───────────────────────────────────────────────────────────
     async getGroupCall(chatId, options = {}) {
         if (!this.client || !this.connected)
@@ -3194,6 +4082,244 @@ export class TelegramService {
             return summarizeQuickReplyMessages(response);
         }, `getQuickReplyMessages ${shortcutId}`);
     }
+    // ─── Stories Write ─────────────────────────────────────────────────────────
+    async sendStory(chatId, filePath, opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const inputPeer = await client.getInputEntity(peer);
+            const fileData = await readFile(filePath);
+            const uploaded = await client.uploadFile({
+                file: new CustomFile(filePath, fileData.length, filePath, fileData),
+                workers: 4,
+            });
+            const mediaType = opts.type ?? detectMediaType(filePath);
+            const media = mediaType === "photo"
+                ? new Api.InputMediaUploadedPhoto({ file: uploaded })
+                : new Api.InputMediaUploadedDocument({
+                    file: uploaded,
+                    mimeType: "video/mp4",
+                    attributes: [new Api.DocumentAttributeVideo({ duration: 0, w: 0, h: 0, supportsStreaming: true })],
+                });
+            const privacyRules = buildStoryPrivacyRules(opts.privacy, opts.allowUserIds, opts.disallowUserIds);
+            let caption = opts.caption;
+            let entities;
+            if (opts.caption && opts.parseMode) {
+                // biome-ignore lint/suspicious/noExplicitAny: GramJS internal helper, no public typing
+                const parser = client._parseMessageText;
+                if (typeof parser === "function") {
+                    [caption, entities] = await parser.call(client, opts.caption, opts.parseMode === "html" ? "html" : "md");
+                }
+            }
+            const result = await client.invoke(new Api.stories.SendStory({
+                peer: inputPeer,
+                media,
+                privacyRules,
+                caption,
+                ...(entities?.length ? { entities } : {}),
+                randomId: generateRandomBigInt(),
+                period: opts.period ?? 86400,
+                pinned: opts.pinned,
+                noforwards: opts.noforwards,
+            }));
+            const id = extractStoryIdFromUpdates(result) || undefined;
+            return { id, period: opts.period ?? 86400 };
+        }, `sendStory ${chatId}`);
+    }
+    async editStory(chatId, storyId, opts) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const client = this.client;
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const inputPeer = await client.getInputEntity(peer);
+            const changed = [];
+            let media;
+            if (opts.filePath) {
+                changed.push("media");
+                const fileData = await readFile(opts.filePath);
+                const uploaded = await client.uploadFile({
+                    file: new CustomFile(opts.filePath, fileData.length, opts.filePath, fileData),
+                    workers: 4,
+                });
+                const mediaType = opts.type ?? detectMediaType(opts.filePath);
+                media =
+                    mediaType === "photo"
+                        ? new Api.InputMediaUploadedPhoto({ file: uploaded })
+                        : new Api.InputMediaUploadedDocument({
+                            file: uploaded,
+                            mimeType: "video/mp4",
+                            attributes: [new Api.DocumentAttributeVideo({ duration: 0, w: 0, h: 0, supportsStreaming: true })],
+                        });
+            }
+            let caption = opts.caption;
+            let entities;
+            if (opts.caption !== undefined) {
+                changed.push("caption");
+                if (opts.caption && opts.parseMode) {
+                    // biome-ignore lint/suspicious/noExplicitAny: GramJS internal helper, no public typing
+                    const parser = client._parseMessageText;
+                    if (typeof parser === "function") {
+                        [caption, entities] = await parser.call(client, opts.caption, opts.parseMode === "html" ? "html" : "md");
+                    }
+                }
+            }
+            let privacyRules;
+            if (opts.privacy) {
+                changed.push("privacy");
+                privacyRules = buildStoryPrivacyRules(opts.privacy, opts.allowUserIds, opts.disallowUserIds);
+            }
+            await client.invoke(new Api.stories.EditStory({
+                peer: inputPeer,
+                id: storyId,
+                ...(media ? { media } : {}),
+                ...(caption !== undefined ? { caption } : {}),
+                ...(entities?.length ? { entities } : {}),
+                ...(privacyRules ? { privacyRules } : {}),
+            }));
+            return { changed };
+        }, `editStory ${chatId}/${storyId}`);
+    }
+    async deleteStories(chatId, ids) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const deleted = await this.client?.invoke(new Api.stories.DeleteStories({ peer, id: ids }));
+            return { deleted: deleted ?? [] };
+        }, `deleteStories ${chatId}`);
+    }
+    async sendStoryReaction(chatId, storyId, emoji, addToRecent) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const reaction = emoji === "" ? new Api.ReactionEmpty() : new Api.ReactionEmoji({ emoticon: emoji });
+            await this.client?.invoke(new Api.stories.SendReaction({ peer, storyId, reaction, addToRecent }));
+        }, `sendStoryReaction ${chatId}/${storyId}`);
+    }
+    async exportStoryLink(chatId, storyId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const result = await this.client?.invoke(new Api.stories.ExportStoryLink({ peer, id: storyId }));
+            if (!result)
+                throw new Error("stories.ExportStoryLink returned nothing");
+            return { link: result.link };
+        }, `exportStoryLink ${chatId}/${storyId}`);
+    }
+    async readStories(chatId, maxId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const ids = await this.client?.invoke(new Api.stories.ReadStories({ peer, maxId }));
+            return { ids: ids ?? [] };
+        }, `readStories ${chatId}/${maxId}`);
+    }
+    async toggleStoryPinned(chatId, ids, pinned) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const affected = await this.client?.invoke(new Api.stories.TogglePinned({ peer, id: ids, pinned }));
+            return { affected: affected ?? [] };
+        }, `toggleStoryPinned ${chatId}`);
+    }
+    async toggleStoryPinnedToTop(chatId, ids) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            await this.client?.invoke(new Api.stories.TogglePinnedToTop({ peer, id: ids }));
+            return { ok: true };
+        }, `toggleStoryPinnedToTop ${chatId}`);
+    }
+    async activateStealthMode(past, future) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            await this.client?.invoke(new Api.stories.ActivateStealthMode({ past: past ?? false, future: future ?? false }));
+        }, "activateStealthMode");
+    }
+    async getStoriesArchive(chatId, offsetId, limit) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const result = await this.client?.invoke(new Api.stories.GetStoriesArchive({ peer, offsetId, limit }));
+            if (!result)
+                throw new Error("stories.GetStoriesArchive returned nothing");
+            return summarizeStoriesById(result);
+        }, `getStoriesArchive ${chatId}`);
+    }
+    async reportStory(chatId, ids, option, message) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const optionBytes = Buffer.from(option, "base64");
+            const result = await this.client?.invoke(new Api.stories.Report({ peer, id: ids, option: optionBytes, message }));
+            if (!result)
+                throw new Error("stories.Report returned nothing");
+            return summarizeReportResult(result);
+        }, `reportStory ${chatId}`);
+    }
+    // ─── Discussion & Read Receipts ────────────────────────────────────────────
+    async getDiscussionMessage(chatId, messageId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const result = await this.client?.invoke(new Api.messages.GetDiscussionMessage({ peer, msgId: messageId }));
+            if (!result)
+                throw new Error("messages.GetDiscussionMessage returned nothing");
+            return summarizeDiscussionMessage(result);
+        }, `getDiscussionMessage ${chatId}/${messageId}`);
+    }
+    async getGroupsForDiscussion() {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const result = await this.client?.invoke(new Api.channels.GetGroupsForDiscussion());
+            if (!result)
+                throw new Error("channels.GetGroupsForDiscussion returned nothing");
+            return summarizeGroupsForDiscussion(result);
+        }, "getGroupsForDiscussion");
+    }
+    async getMessageReadParticipants(chatId, messageId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const result = await this.client?.invoke(new Api.messages.GetMessageReadParticipants({ peer, msgId: messageId }));
+            if (!result)
+                throw new Error("messages.GetMessageReadParticipants returned nothing");
+            return summarizeReadParticipants(result, messageId);
+        }, `getMessageReadParticipants ${chatId}/${messageId}`);
+    }
+    async getOutboxReadDate(chatId, messageId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            try {
+                const result = await this.client?.invoke(new Api.messages.GetOutboxReadDate({ peer, msgId: messageId }));
+                if (!result)
+                    return { readAt: null };
+                const date = result.date;
+                return { readAt: new Date(date * 1000).toISOString() };
+            }
+            catch (e) {
+                if (/NOT_READ_YET/i.test(e.message ?? ""))
+                    return { readAt: null };
+                throw e;
+            }
+        }, `getOutboxReadDate ${chatId}/${messageId}`);
+    }
     async resolveInputGroupCall(chatId) {
         const entity = await this.resolveChat(chatId);
         let call;