@overpod/mcp-telegram 1.24.1 → 1.26.0

package/dist/__tests__/inline-query.test.js

@@ -0,0 +1,115 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import bigInt from "big-integer";
+import { Api } from "telegram/tl/index.js";
+import { TelegramService } from "../telegram-client.js";
+function makeService(chatEntity, botEntity, invocations, response) {
+    const fakeClient = {
+        invoke: async (req) => {
+            invocations.push(req);
+            return response;
+        },
+        getEntity: async (_id) => botEntity,
+    };
+    const service = new TelegramService(1, "hash");
+    const internals = service;
+    internals.client = fakeClient;
+    internals.connected = true;
+    internals.resolveChat = async () => chatEntity;
+    return service;
+}
+function makeBotUser(id, isBot) {
+    return new Api.User({
+        id: bigInt(id),
+        accessHash: bigInt(42),
+        firstName: "InlineBot",
+        bot: isBot,
+    });
+}
+function makeChannel(id) {
+    return new Api.Channel({
+        id: bigInt(id),
+        title: "test",
+        photo: new Api.ChatPhotoEmpty(),
+        date: 0,
+        accessHash: bigInt(1),
+        megagroup: true,
+    });
+}
+function makeBotResults() {
+    return new Api.messages.BotResults({
+        queryId: bigInt("9876543210"),
+        nextOffset: "20",
+        cacheTime: 300,
+        gallery: false,
+        users: [],
+        results: [
+            new Api.BotInlineResult({
+                id: "r1",
+                type: "article",
+                title: "First",
+                description: "desc1",
+                url: "https://example.com/1",
+                sendMessage: new Api.BotInlineMessageText({ message: "pick me" }),
+            }),
+            new Api.BotInlineMediaResult({
+                id: "r2",
+                type: "gif",
+                title: "Media",
+                description: "a gif",
+                sendMessage: new Api.BotInlineMessageText({ message: "gif" }),
+            }),
+        ],
+    });
+}
+describe("TelegramService.getInlineBotResults", () => {
+    it("invokes GetInlineBotResults with resolved bot InputUser and returns compact results", async () => {
+        const invocations = [];
+        const service = makeService(makeChannel(12345), makeBotUser(777, true), invocations, makeBotResults());
+        const out = await service.getInlineBotResults("@gif", "12345", "cat", undefined);
+        const call = invocations.find((r) => r instanceof Api.messages.GetInlineBotResults);
+        assert.ok(call, "GetInlineBotResults was invoked");
+        assert.ok(call.bot instanceof Api.InputUser);
+        assert.strictEqual(call.bot.userId.toString(), "777");
+        assert.strictEqual(call.query, "cat");
+        assert.strictEqual(call.offset, "");
+        assert.strictEqual(out.queryId, "9876543210");
+        assert.strictEqual(out.nextOffset, "20");
+        assert.strictEqual(out.cacheTime, 300);
+        assert.strictEqual(out.gallery, false);
+        assert.strictEqual(out.results.length, 2);
+        assert.deepStrictEqual(out.results[0], {
+            id: "r1",
+            type: "article",
+            title: "First",
+            description: "desc1",
+            url: "https://example.com/1",
+        });
+        assert.deepStrictEqual(out.results[1], {
+            id: "r2",
+            type: "gif",
+            title: "Media",
+            description: "a gif",
+        });
+    });
+    it("passes through offset when provided", async () => {
+        const invocations = [];
+        const service = makeService(makeChannel(10), makeBotUser(1, true), invocations, makeBotResults());
+        await service.getInlineBotResults("@b", "10", "q", "20");
+        const call = invocations.find((r) => r instanceof Api.messages.GetInlineBotResults);
+        assert.ok(call);
+        assert.strictEqual(call.offset, "20");
+    });
+    it("rejects when bot is not a bot account", async () => {
+        const invocations = [];
+        const service = makeService(makeChannel(10), makeBotUser(1, false), invocations, makeBotResults());
+        await assert.rejects(service.getInlineBotResults("@notbot", "10", "q"), /not a bot/i);
+        assert.strictEqual(invocations.find((r) => r instanceof Api.messages.GetInlineBotResults), undefined, "no API call when target is not a bot");
+    });
+    it("rejects when bot entity is not a User", async () => {
+        const invocations = [];
+        const notUser = makeChannel(99);
+        const service = makeService(makeChannel(10), notUser, invocations, makeBotResults());
+        await assert.rejects(service.getInlineBotResults("@chan", "10", "q"), /not a user/i);
+    });
+});

package/dist/__tests__/megagroup-stats.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/megagroup-stats.test.js

@@ -0,0 +1,166 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import bigInt from "big-integer";
+import { Api } from "telegram/tl/index.js";
+import { summarizeMegagroupStats, TelegramService } from "../telegram-client.js";
+function makeService(entity, invokeImpl, invocations) {
+    const fakeClient = {
+        invoke: async (req) => {
+            invocations.push(req);
+            return invokeImpl(req);
+        },
+    };
+    const service = new TelegramService(1, "hash");
+    const internals = service;
+    internals.client = fakeClient;
+    internals.connected = true;
+    internals.resolveChat = async () => entity;
+    return service;
+}
+function fakeStats() {
+    return {
+        period: { minDate: 1000, maxDate: 2000 },
+        members: { current: 500, previous: 450 },
+        messages: { current: 1200, previous: 1100 },
+        viewers: { current: 300, previous: 280 },
+        posters: { current: 80, previous: 75 },
+        growthGraph: new Api.StatsGraphAsync({ token: "growth-token" }),
+        membersGraph: new Api.StatsGraphAsync({ token: "members-token" }),
+        newMembersBySourceGraph: new Api.StatsGraphAsync({ token: "new-members-token" }),
+        languagesGraph: new Api.StatsGraphError({ error: "unavailable" }),
+        messagesGraph: new Api.StatsGraph({
+            json: new Api.DataJSON({ data: '{"x":[1,2,3]}' }),
+            zoomToken: "zoom",
+        }),
+        actionsGraph: new Api.StatsGraphAsync({ token: "actions-token" }),
+        topHoursGraph: new Api.StatsGraphAsync({ token: "top-hours-token" }),
+        weekdaysGraph: new Api.StatsGraphAsync({ token: "weekdays-token" }),
+        topPosters: [
+            new Api.StatsGroupTopPoster({ userId: bigInt(111), messages: 42, avgChars: 120 }),
+            new Api.StatsGroupTopPoster({ userId: bigInt(222), messages: 21, avgChars: 80 }),
+        ],
+        topAdmins: [new Api.StatsGroupTopAdmin({ userId: bigInt(333), deleted: 5, kicked: 2, banned: 1 })],
+        topInviters: [new Api.StatsGroupTopInviter({ userId: bigInt(444), invitations: 10 })],
+        users: [],
+    };
+}
+describe("summarizeMegagroupStats", () => {
+    it("produces compact summary without graphs by default", () => {
+        const summary = summarizeMegagroupStats(fakeStats(), false);
+        assert.strictEqual(summary.graphs, undefined);
+        assert.deepStrictEqual(summary.period, { minDate: 1000, maxDate: 2000 });
+        assert.deepStrictEqual(summary.members, { current: 500, previous: 450 });
+        assert.deepStrictEqual(summary.messages, { current: 1200, previous: 1100 });
+        assert.deepStrictEqual(summary.viewers, { current: 300, previous: 280 });
+        assert.deepStrictEqual(summary.posters, { current: 80, previous: 75 });
+        assert.strictEqual(summary.topPosters.length, 2);
+        assert.deepStrictEqual(summary.topPosters[0], {
+            userId: "111",
+            messages: 42,
+            avgChars: 120,
+        });
+        assert.deepStrictEqual(summary.topAdmins[0], {
+            userId: "333",
+            deleted: 5,
+            kicked: 2,
+            banned: 1,
+        });
+        assert.deepStrictEqual(summary.topInviters[0], { userId: "444", invitations: 10 });
+    });
+    it("includes and decodes graphs when requested", () => {
+        const summary = summarizeMegagroupStats(fakeStats(), true);
+        assert.ok(summary.graphs);
+        const graphs = summary.graphs ?? {};
+        assert.deepStrictEqual(graphs.growth, { type: "async", token: "growth-token" });
+        assert.deepStrictEqual(graphs.languages, { type: "error", error: "unavailable" });
+        assert.deepStrictEqual(graphs.messages, { type: "data", data: { x: [1, 2, 3] }, zoomToken: "zoom" });
+        assert.deepStrictEqual(graphs.weekdays, { type: "async", token: "weekdays-token" });
+    });
+    it("handles empty top lists gracefully", () => {
+        const stats = fakeStats();
+        stats.topPosters = [];
+        stats.topAdmins = [];
+        stats.topInviters = [];
+        const summary = summarizeMegagroupStats(stats, false);
+        assert.deepStrictEqual(summary.topPosters, []);
+        assert.deepStrictEqual(summary.topAdmins, []);
+        assert.deepStrictEqual(summary.topInviters, []);
+    });
+});
+describe("TelegramService.getMegagroupStats", () => {
+    function megagroup() {
+        return new Api.Channel({
+            id: bigInt(33333),
+            title: "supergroup",
+            photo: new Api.ChatPhotoEmpty(),
+            date: 0,
+            accessHash: bigInt(1),
+            megagroup: true,
+        });
+    }
+    it("invokes stats.GetMegagroupStats and returns compact summary", async () => {
+        const invocations = [];
+        const service = makeService(megagroup(), async () => fakeStats(), invocations);
+        const summary = await service.getMegagroupStats("33333");
+        const call = invocations.find((r) => r instanceof Api.stats.GetMegagroupStats);
+        assert.ok(call, "GetMegagroupStats was invoked");
+        assert.strictEqual(summary.members.current, 500);
+        assert.strictEqual(summary.graphs, undefined);
+    });
+    it("passes dark=true when requested", async () => {
+        const invocations = [];
+        const service = makeService(megagroup(), async () => fakeStats(), invocations);
+        await service.getMegagroupStats("33333", { dark: true });
+        const call = invocations.find((r) => r instanceof Api.stats.GetMegagroupStats);
+        assert.ok(call);
+        assert.strictEqual(call.dark, true);
+    });
+    it("includes graphs when includeGraphs=true", async () => {
+        const invocations = [];
+        const service = makeService(megagroup(), async () => fakeStats(), invocations);
+        const summary = await service.getMegagroupStats("33333", { includeGraphs: true });
+        assert.ok(summary.graphs);
+        assert.strictEqual(summary.graphs?.growth.type, "async");
+    });
+    it("rejects broadcast channels with hint to use broadcast stats", async () => {
+        const broadcast = new Api.Channel({
+            id: bigInt(12345),
+            title: "broadcast",
+            photo: new Api.ChatPhotoEmpty(),
+            date: 0,
+            accessHash: bigInt(1),
+            broadcast: true,
+        });
+        const invocations = [];
+        const service = makeService(broadcast, async () => fakeStats(), invocations);
+        await assert.rejects(service.getMegagroupStats("12345"), /telegram-get-broadcast-stats/);
+        assert.strictEqual(invocations.find((r) => r instanceof Api.stats.GetMegagroupStats), undefined);
+    });
+    it("rejects non-channel entities", async () => {
+        const chat = new Api.Chat({
+            id: bigInt(44444),
+            title: "basic group",
+            photo: new Api.ChatPhotoEmpty(),
+            participantsCount: 5,
+            date: 0,
+            version: 0,
+        });
+        const invocations = [];
+        const service = makeService(chat, async () => fakeStats(), invocations);
+        await assert.rejects(service.getMegagroupStats("44444"), /supergroups/);
+    });
+    it("surfaces admin-required errors with a clearer message", async () => {
+        const invocations = [];
+        const service = makeService(megagroup(), async () => {
+            throw new Error("CHAT_ADMIN_REQUIRED");
+        }, invocations);
+        await assert.rejects(service.getMegagroupStats("33333"), /admin rights/i);
+    });
+    it("surfaces stats-unavailable errors with hint", async () => {
+        const invocations = [];
+        const service = makeService(megagroup(), async () => {
+            throw new Error("STATS_UNAVAILABLE");
+        }, invocations);
+        await assert.rejects(service.getMegagroupStats("33333"), /no stats/i);
+    });
+});

package/dist/__tests__/press-button.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/press-button.test.js

@@ -0,0 +1,123 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import bigInt from "big-integer";
+import { Api } from "telegram/tl/index.js";
+import { TelegramService } from "../telegram-client.js";
+function makeService(chatEntity, invocations, messages, responder) {
+    const fakeClient = {
+        invoke: async (req) => {
+            invocations.push(req);
+            return responder(req);
+        },
+        getMessages: async (_entity, _opts) => messages,
+    };
+    const service = new TelegramService(1, "hash");
+    const internals = service;
+    internals.client = fakeClient;
+    internals.connected = true;
+    internals.resolveChat = async () => chatEntity;
+    return service;
+}
+function makeChannel(id) {
+    return new Api.Channel({
+        id: bigInt(id),
+        title: "t",
+        photo: new Api.ChatPhotoEmpty(),
+        date: 0,
+        accessHash: bigInt(1),
+        megagroup: true,
+    });
+}
+function makeMessage(id, markup) {
+    return new Api.Message({
+        id,
+        peerId: new Api.PeerChannel({ channelId: bigInt(100) }),
+        date: 0,
+        message: "hi",
+        replyMarkup: markup,
+    });
+}
+function callbackButton(text, data, requiresPassword = false) {
+    return new Api.KeyboardButtonCallback({ text, data, requiresPassword });
+}
+function urlButton(text, url) {
+    return new Api.KeyboardButtonUrl({ text, url });
+}
+function inlineMarkup(buttons) {
+    return new Api.ReplyInlineMarkup({
+        rows: buttons.map((row) => new Api.KeyboardButtonRow({ buttons: row })),
+    });
+}
+function callbackAnswer() {
+    return new Api.messages.BotCallbackAnswer({
+        alert: true,
+        message: "Clicked",
+        cacheTime: 60,
+    });
+}
+describe("TelegramService.pressButton", () => {
+    it("presses a callback button by (row, column) and returns the answer", async () => {
+        const invocations = [];
+        const data = Buffer.from("vote_yes");
+        const msg = makeMessage(42, inlineMarkup([[callbackButton("Yes", data)]]));
+        const service = makeService(makeChannel(100), invocations, [msg], () => callbackAnswer());
+        const out = await service.pressButton("100", 42, { buttonIndex: { row: 0, column: 0 } });
+        const call = invocations.find((r) => r instanceof Api.messages.GetBotCallbackAnswer);
+        assert.ok(call, "GetBotCallbackAnswer was invoked");
+        assert.strictEqual(call.msgId, 42);
+        assert.ok(call.data, "data is set");
+        assert.strictEqual(Buffer.from(call.data).toString(), "vote_yes");
+        assert.strictEqual(out.alert, true);
+        assert.strictEqual(out.message, "Clicked");
+        assert.strictEqual(out.cacheTime, 60);
+    });
+    it("accepts raw data as base64 without fetching the message", async () => {
+        const invocations = [];
+        const service = makeService(makeChannel(100), invocations, [], () => callbackAnswer());
+        const payload = Buffer.from([0x01, 0x02, 0xff]);
+        await service.pressButton("100", 7, { data: payload.toString("base64") });
+        const call = invocations.find((r) => r instanceof Api.messages.GetBotCallbackAnswer);
+        assert.ok(call);
+        assert.deepStrictEqual(Buffer.from(call.data), payload);
+    });
+    it("rejects when button type is not Callback", async () => {
+        const invocations = [];
+        const msg = makeMessage(1, inlineMarkup([[urlButton("Open", "https://x.test")]]));
+        const service = makeService(makeChannel(100), invocations, [msg], () => callbackAnswer());
+        await assert.rejects(service.pressButton("100", 1, { buttonIndex: { row: 0, column: 0 } }), /not callable/i);
+        assert.strictEqual(invocations.find((r) => r instanceof Api.messages.GetBotCallbackAnswer), undefined, "no API call when button is not callable");
+    });
+    it("rejects when message has no reply markup", async () => {
+        const invocations = [];
+        const msg = makeMessage(1, undefined);
+        const service = makeService(makeChannel(100), invocations, [msg], () => callbackAnswer());
+        await assert.rejects(service.pressButton("100", 1, { buttonIndex: { row: 0, column: 0 } }), /no reply markup/i);
+    });
+    it("rejects when reply markup is ReplyKeyboardMarkup (not inline)", async () => {
+        const invocations = [];
+        const markup = new Api.ReplyKeyboardMarkup({
+            rows: [new Api.KeyboardButtonRow({ buttons: [new Api.KeyboardButton({ text: "x" })] })],
+        });
+        const msg = makeMessage(1, markup);
+        const service = makeService(makeChannel(100), invocations, [msg], () => callbackAnswer());
+        await assert.rejects(service.pressButton("100", 1, { buttonIndex: { row: 0, column: 0 } }), /ReplyInlineMarkup/);
+    });
+    it("rejects when row/column is out of bounds", async () => {
+        const invocations = [];
+        const msg = makeMessage(1, inlineMarkup([[callbackButton("A", Buffer.from("a"))]]));
+        const service = makeService(makeChannel(100), invocations, [msg], () => callbackAnswer());
+        await assert.rejects(service.pressButton("100", 1, { buttonIndex: { row: 5, column: 0 } }), /out of bounds/i);
+        await assert.rejects(service.pressButton("100", 1, { buttonIndex: { row: 0, column: 9 } }), /out of bounds/i);
+    });
+    it("rejects when button requires 2FA password", async () => {
+        const invocations = [];
+        const msg = makeMessage(1, inlineMarkup([[callbackButton("Admin", Buffer.from("x"), true)]]));
+        const service = makeService(makeChannel(100), invocations, [msg], () => callbackAnswer());
+        await assert.rejects(service.pressButton("100", 1, { buttonIndex: { row: 0, column: 0 } }), /2FA password/i);
+    });
+    it("rejects when neither buttonIndex nor data is provided", async () => {
+        const invocations = [];
+        const service = makeService(makeChannel(100), invocations, [], () => callbackAnswer());
+        await assert.rejects(service.pressButton("100", 1, {}), /buttonIndex or data/i);
+    });
+});

package/dist/__tests__/quick-replies.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/quick-replies.test.js

@@ -0,0 +1,245 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import bigInt from "big-integer";
+import { Api } from "telegram/tl/index.js";
+import { summarizeQuickReplies, summarizeQuickReply, summarizeQuickReplyMessage, summarizeQuickReplyMessages, TelegramService, } from "../telegram-client.js";
+import { isQuickRepliesEnabled } from "../tools/quick-replies.js";
+function makeService(invocations, responder) {
+    const fakeClient = {
+        invoke: async (req) => {
+            invocations.push(req);
+            return responder(req);
+        },
+    };
+    const service = new TelegramService(1, "hash");
+    const internals = service;
+    internals.client = fakeClient;
+    internals.connected = true;
+    return service;
+}
+describe("summarizeQuickReply", () => {
+    it("maps shortcutId, shortcut, topMessage, count", () => {
+        const out = summarizeQuickReply(new Api.QuickReply({ shortcutId: 5, shortcut: "hello", topMessage: 100, count: 3 }));
+        assert.deepStrictEqual(out, { shortcutId: 5, shortcut: "hello", topMessage: 100, count: 3 });
+    });
+});
+describe("summarizeQuickReplies", () => {
+    it("returns notModified flag for QuickRepliesNotModified", () => {
+        const out = summarizeQuickReplies(new Api.messages.QuickRepliesNotModified());
+        assert.deepStrictEqual(out, { notModified: true });
+    });
+    it("maps quickReplies array, ignoring messages/chats/users", () => {
+        const resp = new Api.messages.QuickReplies({
+            quickReplies: [
+                new Api.QuickReply({ shortcutId: 1, shortcut: "hi", topMessage: 10, count: 1 }),
+                new Api.QuickReply({ shortcutId: 2, shortcut: "bye", topMessage: 20, count: 2 }),
+            ],
+            messages: [],
+            chats: [],
+            users: [],
+        });
+        const out = summarizeQuickReplies(resp);
+        assert.strictEqual(out.notModified, undefined);
+        assert.strictEqual(out.quickReplies?.length, 2);
+        assert.deepStrictEqual(out.quickReplies?.[0], { shortcutId: 1, shortcut: "hi", topMessage: 10, count: 1 });
+        assert.deepStrictEqual(out.quickReplies?.[1], { shortcutId: 2, shortcut: "bye", topMessage: 20, count: 2 });
+    });
+});
+describe("TelegramService.getQuickReplies", () => {
+    it("invokes messages.GetQuickReplies with hash=0 by default", async () => {
+        const invocations = [];
+        const service = makeService(invocations, () => new Api.messages.QuickReplies({
+            quickReplies: [new Api.QuickReply({ shortcutId: 7, shortcut: "gm", topMessage: 4, count: 1 })],
+            messages: [],
+            chats: [],
+            users: [],
+        }));
+        const out = await service.getQuickReplies();
+        const call = invocations.find((r) => r instanceof Api.messages.GetQuickReplies);
+        assert.ok(call, "GetQuickReplies must be invoked");
+        assert.ok(call.hash.equals(bigInt(0)), "default hash should be 0");
+        assert.strictEqual(out.quickReplies?.length, 1);
+        assert.strictEqual(out.quickReplies?.[0].shortcut, "gm");
+    });
+    it("passes the provided hash through (bigInt parsed from decimal string)", async () => {
+        const invocations = [];
+        const service = makeService(invocations, () => new Api.messages.QuickRepliesNotModified());
+        const out = await service.getQuickReplies("123456789012345");
+        const call = invocations.find((r) => r instanceof Api.messages.GetQuickReplies);
+        assert.ok(call);
+        assert.ok(call.hash.equals(bigInt("123456789012345")));
+        assert.strictEqual(out.notModified, true);
+    });
+    it("throws when not connected", async () => {
+        const service = new TelegramService(1, "hash");
+        await assert.rejects(() => service.getQuickReplies(), /Not connected/i);
+    });
+});
+describe("summarizeQuickReplyMessage", () => {
+    it("returns null for MessageEmpty", () => {
+        const out = summarizeQuickReplyMessage(new Api.MessageEmpty({ id: 1 }));
+        assert.strictEqual(out, null);
+    });
+    it("maps regular message with reply header", () => {
+        const msg = new Api.Message({
+            id: 42,
+            peerId: new Api.PeerUser({ userId: bigInt(123) }),
+            date: 1_700_000_000,
+            message: "hello quick reply",
+            fromId: new Api.PeerUser({ userId: bigInt(55) }),
+            replyTo: new Api.MessageReplyHeader({ replyToMsgId: 40 }),
+        });
+        const out = summarizeQuickReplyMessage(msg);
+        assert.deepStrictEqual(out, {
+            id: 42,
+            date: 1_700_000_000,
+            text: "hello quick reply",
+            isService: false,
+            fromId: { kind: "user", id: "55" },
+            replyToMsgId: 40,
+        });
+    });
+    it("marks service messages with isService=true and bracketed action className", () => {
+        const action = new Api.MessageActionChatCreate({ title: "t", users: [] });
+        const msg = new Api.MessageService({
+            id: 7,
+            peerId: new Api.PeerChat({ chatId: bigInt(9) }),
+            date: 1_700_000_001,
+            action,
+        });
+        const out = summarizeQuickReplyMessage(msg);
+        assert.strictEqual(out?.isService, true);
+        assert.strictEqual(out?.id, 7);
+        assert.ok(out?.text.startsWith("[") && out?.text.endsWith("]"));
+    });
+});
+describe("summarizeQuickReplyMessages", () => {
+    it("returns notModified flag with count for MessagesNotModified", () => {
+        const out = summarizeQuickReplyMessages(new Api.messages.MessagesNotModified({ count: 3 }));
+        assert.deepStrictEqual(out, { notModified: true, count: 3 });
+    });
+    it("maps messages.Messages and drops empties", () => {
+        const resp = new Api.messages.Messages({
+            messages: [
+                new Api.Message({
+                    id: 1,
+                    peerId: new Api.PeerUser({ userId: bigInt(11) }),
+                    date: 100,
+                    message: "one",
+                }),
+                new Api.MessageEmpty({ id: 2 }),
+                new Api.Message({
+                    id: 3,
+                    peerId: new Api.PeerUser({ userId: bigInt(11) }),
+                    date: 101,
+                    message: "three",
+                }),
+            ],
+            chats: [],
+            users: [],
+        });
+        const out = summarizeQuickReplyMessages(resp);
+        assert.strictEqual(out.notModified, undefined);
+        assert.strictEqual(out.count, 2);
+        assert.strictEqual(out.messages?.length, 2);
+        assert.strictEqual(out.messages?.[0].id, 1);
+        assert.strictEqual(out.messages?.[1].id, 3);
+    });
+    it("maps messages.MessagesSlice using slice.count (not array length)", () => {
+        const resp = new Api.messages.MessagesSlice({
+            count: 42,
+            messages: [
+                new Api.Message({
+                    id: 5,
+                    peerId: new Api.PeerUser({ userId: bigInt(11) }),
+                    date: 100,
+                    message: "five",
+                }),
+            ],
+            chats: [],
+            users: [],
+        });
+        const out = summarizeQuickReplyMessages(resp);
+        assert.strictEqual(out.count, 42);
+        assert.strictEqual(out.messages?.length, 1);
+    });
+});
+describe("TelegramService.getQuickReplyMessages", () => {
+    it("invokes messages.GetQuickReplyMessages with shortcutId and default hash=0", async () => {
+        const invocations = [];
+        const service = makeService(invocations, () => new Api.messages.Messages({
+            messages: [
+                new Api.Message({
+                    id: 10,
+                    peerId: new Api.PeerUser({ userId: bigInt(1) }),
+                    date: 1,
+                    message: "x",
+                }),
+            ],
+            chats: [],
+            users: [],
+        }));
+        const out = await service.getQuickReplyMessages(7);
+        const call = invocations.find((r) => r instanceof Api.messages.GetQuickReplyMessages);
+        assert.ok(call, "GetQuickReplyMessages must be invoked");
+        assert.strictEqual(call.shortcutId, 7);
+        assert.strictEqual(call.id, undefined);
+        assert.ok(call.hash.equals(bigInt(0)));
+        assert.strictEqual(out.messages?.length, 1);
+    });
+    it("passes ids and hash through", async () => {
+        const invocations = [];
+        const service = makeService(invocations, () => new Api.messages.MessagesNotModified({ count: 5 }));
+        const out = await service.getQuickReplyMessages(9, { ids: [1, 2, 3], hash: "987654321" });
+        const call = invocations.find((r) => r instanceof Api.messages.GetQuickReplyMessages);
+        assert.ok(call);
+        assert.strictEqual(call.shortcutId, 9);
+        assert.deepStrictEqual(call.id, [1, 2, 3]);
+        assert.ok(call.hash.equals(bigInt("987654321")));
+        assert.strictEqual(out.notModified, true);
+        assert.strictEqual(out.count, 5);
+    });
+    it("throws when not connected", async () => {
+        const service = new TelegramService(1, "hash");
+        await assert.rejects(() => service.getQuickReplyMessages(1), /Not connected/i);
+    });
+});
+describe("isQuickRepliesEnabled gate", () => {
+    it("is off by default", () => {
+        const prev = process.env.MCP_TELEGRAM_ENABLE_QUICK_REPLIES;
+        delete process.env.MCP_TELEGRAM_ENABLE_QUICK_REPLIES;
+        try {
+            assert.strictEqual(isQuickRepliesEnabled(), false);
+        }
+        finally {
+            if (prev !== undefined)
+                process.env.MCP_TELEGRAM_ENABLE_QUICK_REPLIES = prev;
+        }
+    });
+    it("turns on when env is '1'", () => {
+        const prev = process.env.MCP_TELEGRAM_ENABLE_QUICK_REPLIES;
+        process.env.MCP_TELEGRAM_ENABLE_QUICK_REPLIES = "1";
+        try {
+            assert.strictEqual(isQuickRepliesEnabled(), true);
+        }
+        finally {
+            if (prev === undefined)
+                delete process.env.MCP_TELEGRAM_ENABLE_QUICK_REPLIES;
+            else
+                process.env.MCP_TELEGRAM_ENABLE_QUICK_REPLIES = prev;
+        }
+    });
+    it("stays off for any non-'1' value", () => {
+        const prev = process.env.MCP_TELEGRAM_ENABLE_QUICK_REPLIES;
+        process.env.MCP_TELEGRAM_ENABLE_QUICK_REPLIES = "true";
+        try {
+            assert.strictEqual(isQuickRepliesEnabled(), false);
+        }
+        finally {
+            if (prev === undefined)
+                delete process.env.MCP_TELEGRAM_ENABLE_QUICK_REPLIES;
+            else
+                process.env.MCP_TELEGRAM_ENABLE_QUICK_REPLIES = prev;
+        }
+    });
+});

package/dist/__tests__/reactions.test.d.ts

@@ -0,0 +1 @@
+export {};