@overpod/mcp-telegram 1.10.1 → 1.11.0

package/dist/index.js

@@ -18,6 +18,13 @@ if (!API_ID || !API_HASH) {
     process.exit(1);
 }
 const telegram = new TelegramService(API_ID, API_HASH);
+/** Format reactions array into compact text like: [👍×5 ❤️×3(me) 🔥×1] */
+function formatReactions(reactions) {
+    if (!reactions?.length)
+        return "";
+    const parts = reactions.map((r) => `${r.emoji}×${r.count}${r.me ? "(me)" : ""}`);
+    return ` [${parts.join(" ")}]`;
+}
 const server = new McpServer({
     name: "mcp-telegram",
     version: "1.0.0",
@@ -165,7 +172,7 @@ server.tool("telegram-read-messages", "Read recent messages from a Telegram chat
     try {
         const messages = await telegram.getMessages(chatId, limit, offsetId, minDate, maxDate);
         const text = messages
-            .map((m) => `[#${m.id}] [${m.date}] ${m.sender}: ${m.text}${m.media ? ` [${m.media.type}${m.media.fileName ? `: ${m.media.fileName}` : ""}]` : ""}`)
+            .map((m) => `[#${m.id}] [${m.date}] ${m.sender}: ${m.text}${m.media ? ` [${m.media.type}${m.media.fileName ? `: ${m.media.fileName}` : ""}]` : ""}${formatReactions(m.reactions)}`)
             .join("\n\n");
         return { content: [{ type: "text", text: text || "No messages" }] };
     }
@@ -203,7 +210,7 @@ server.tool("telegram-search-global", "Search messages globally across all publi
     try {
         const messages = await telegram.searchGlobal(query, limit, minDate, maxDate);
         const text = messages
-            .map((m) => `[#${m.id}] [${m.date}] [${m.chat.type === "channel" ? "C" : m.chat.type === "group" ? "G" : "P"} ${m.chat.name}${m.chat.username ? ` @${m.chat.username}` : ""}] ${m.sender}: ${m.text}${m.media ? ` [${m.media.type}${m.media.fileName ? `: ${m.media.fileName}` : ""}]` : ""}`)
+            .map((m) => `[#${m.id}] [${m.date}] [${m.chat.type === "channel" ? "C" : m.chat.type === "group" ? "G" : "P"} ${m.chat.name}${m.chat.username ? ` @${m.chat.username}` : ""}] ${m.sender}: ${m.text}${m.media ? ` [${m.media.type}${m.media.fileName ? `: ${m.media.fileName}` : ""}]` : ""}${formatReactions(m.reactions)}`)
             .join("\n\n");
         return { content: [{ type: "text", text: text || "No messages found" }] };
     }
@@ -224,7 +231,7 @@ server.tool("telegram-search-messages", "Search messages in a Telegram chat by t
     try {
         const messages = await telegram.searchMessages(chatId, query, limit, minDate, maxDate);
         const text = messages
-            .map((m) => `[#${m.id}] [${m.date}] ${m.sender}: ${m.text}${m.media ? ` [${m.media.type}${m.media.fileName ? `: ${m.media.fileName}` : ""}]` : ""}`)
+            .map((m) => `[#${m.id}] [${m.date}] ${m.sender}: ${m.text}${m.media ? ` [${m.media.type}${m.media.fileName ? `: ${m.media.fileName}` : ""}]` : ""}${formatReactions(m.reactions)}`)
             .join("\n\n");
         return { content: [{ type: "text", text: text || "No messages found" }] };
     }
@@ -529,23 +536,57 @@ server.tool("telegram-join-chat", "Join a Telegram group or channel by username
         };
     }
 });
-server.tool("telegram-send-reaction", "Send an emoji reaction to a message. Pass emoji to react, omit to remove reaction", {
+server.tool("telegram-send-reaction", "Send emoji reaction(s) to a message. Supports multiple reactions and adding to existing ones. Omit emoji to remove all reactions", {
     chatId: z.string().describe("Chat ID or username"),
     messageId: z.number().describe("Message ID to react to"),
-    emoji: z.string().optional().describe("Reaction emoji (e.g. 👍❤️🔥😂🎉). Omit to remove reaction"),
-}, async ({ chatId, messageId, emoji }) => {
+    emoji: z
+        .union([z.string(), z.array(z.string())])
+        .optional()
+        .describe("Reaction emoji(s): single '👍' or array ['👍','🔥']. Omit to remove all reactions"),
+    addToExisting: z
+        .boolean()
+        .default(false)
+        .describe("If true, add reaction(s) to existing ones instead of replacing"),
+}, async ({ chatId, messageId, emoji, addToExisting }) => {
     const err = await requireConnection();
     if (err)
         return { content: [{ type: "text", text: err }] };
     try {
-        await telegram.sendReaction(chatId, messageId, emoji);
-        const action = emoji ? `Reacted ${emoji} to` : "Removed reaction from";
-        return { content: [{ type: "text", text: `${action} message ${messageId} in ${chatId}` }] };
+        const updated = await telegram.sendReaction(chatId, messageId, emoji, addToExisting);
+        const emojiStr = Array.isArray(emoji) ? emoji.join("") : emoji;
+        const action = emoji ? `Reacted ${emojiStr} to` : "Removed reactions from";
+        const reactionsInfo = updated
+            ? ` | Reactions: ${updated.map((r) => `${r.emoji}×${r.count}${r.me ? "(me)" : ""}`).join(" ")}`
+            : "";
+        return { content: [{ type: "text", text: `${action} message ${messageId} in ${chatId}${reactionsInfo}` }] };
     }
     catch (e) {
         return { content: [{ type: "text", text: `Reaction error: ${e.message}` }] };
     }
 });
+server.tool("telegram-get-reactions", "Get detailed reaction info for a message: which reactions, counts, and who reacted (when visible)", {
+    chatId: z.string().describe("Chat ID or username"),
+    messageId: z.number().describe("Message ID to get reactions for"),
+}, async ({ chatId, messageId }) => {
+    const err = await requireConnection();
+    if (err)
+        return { content: [{ type: "text", text: err }] };
+    try {
+        const result = await telegram.getMessageReactions(chatId, messageId);
+        if (result.reactions.length === 0) {
+            return { content: [{ type: "text", text: `No reactions on message ${messageId}` }] };
+        }
+        const lines = result.reactions.map((r) => {
+            const usersStr = r.users.length > 0 ? `: ${r.users.map((u) => u.name).join(", ")}` : "";
+            return `${r.emoji} × ${r.count}${usersStr}`;
+        });
+        lines.push(`\nTotal: ${result.total} reactions`);
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+    }
+});
 server.tool("telegram-send-scheduled", "Send a scheduled message to a Telegram chat. The message will be delivered at the specified time by Telegram servers", {
     chatId: z.string().describe("Chat ID or username (use 'me' or 'self' for Saved Messages)"),
     text: z.string().describe("Message text"),
@@ -703,7 +744,7 @@ server.tool("telegram-read-topic-messages", "Read messages from a specific forum
     try {
         const messages = await telegram.getTopicMessages(chatId, topicId, limit, offsetId);
         const text = messages
-            .map((m) => `[#${m.id}] [${m.date}] ${m.sender}: ${m.text}${m.media ? ` [${m.media.type}${m.media.fileName ? `: ${m.media.fileName}` : ""}]` : ""}`)
+            .map((m) => `[#${m.id}] [${m.date}] ${m.sender}: ${m.text}${m.media ? ` [${m.media.type}${m.media.fileName ? `: ${m.media.fileName}` : ""}]` : ""}${formatReactions(m.reactions)}`)
             .join("\n\n");
         return { content: [{ type: "text", text: text || "No messages in this topic" }] };
     }

package/dist/telegram-client.d.ts

@@ -110,6 +110,11 @@ export declare class TelegramService {
             fileName?: string;
             size?: number;
         };
+        reactions?: {
+            emoji: string;
+            count: number;
+            me: boolean;
+        }[];
     }>>;
     searchChats(query: string, limit?: number): Promise<Array<{
         id: string;
@@ -135,6 +140,11 @@ export declare class TelegramService {
             fileName?: string;
             size?: number;
         };
+        reactions?: {
+            emoji: string;
+            count: number;
+            me: boolean;
+        }[];
     }>>;
     searchMessages(chatId: string, query: string, limit?: number, minDate?: number, maxDate?: number): Promise<Array<{
         id: number;
@@ -146,6 +156,11 @@ export declare class TelegramService {
             fileName?: string;
             size?: number;
         };
+        reactions?: {
+            emoji: string;
+            count: number;
+            me: boolean;
+        }[];
     }>>;
     getContacts(limit?: number): Promise<Array<{
         id: string;
@@ -184,7 +199,24 @@ export declare class TelegramService {
     } | null>;
     /** Detect MIME type from buffer magic bytes */
     private detectMimeFromBuffer;
-    sendReaction(chatId: string, messageId: number, emoji?: string): Promise<void>;
+    /** Extract reactions from a message into a simple format */
+    private extractReactions;
+    sendReaction(chatId: string, messageId: number, emoji?: string | string[], addToExisting?: boolean): Promise<{
+        emoji: string;
+        count: number;
+        me: boolean;
+    }[] | undefined>;
+    getMessageReactions(chatId: string, messageId: number): Promise<{
+        reactions: {
+            emoji: string;
+            count: number;
+            users: {
+                id: string;
+                name: string;
+            }[];
+        }[];
+        total: number;
+    }>;
     sendScheduledMessage(chatId: string, text: string, scheduleDate: number, replyTo?: number, parseMode?: "md" | "html"): Promise<void>;
     createPoll(chatId: string, question: string, answers: string[], options?: {
         multipleChoice?: boolean;
@@ -210,6 +242,11 @@ export declare class TelegramService {
             fileName?: string;
             size?: number;
         };
+        reactions?: {
+            emoji: string;
+            count: number;
+            me: boolean;
+        }[];
     }>>;
     /** Check if a chat entity is a forum (has topics enabled) */
     isForum(chatId: string): Promise<boolean>;

package/dist/telegram-client.js

@@ -621,6 +621,7 @@ export class TelegramService {
             sender: await this.resolveSenderName(m.senderId),
             date: new Date((m.date ?? 0) * 1000).toISOString(),
             media: this.extractMediaInfo(m.media),
+            reactions: this.extractReactions(m.reactions),
         })));
         return results;
     }
@@ -749,6 +750,7 @@ export class TelegramService {
                 date: new Date((m.date ?? 0) * 1000).toISOString(),
                 chat: chatsMap.get(chatId) || { id: chatId, name: "Unknown", type: "unknown" },
                 media: this.extractMediaInfo(m.media),
+                reactions: this.extractReactions(m.reactions),
             };
         }));
         return results;
@@ -771,6 +773,7 @@ export class TelegramService {
             sender: await this.resolveSenderName(m.senderId),
             date: new Date((m.date ?? 0) * 1000).toISOString(),
             media: this.extractMediaInfo(m.media),
+            reactions: this.extractReactions(m.reactions),
         })));
         return results;
     }
@@ -899,16 +902,121 @@ export class TelegramService {
             return "image/webp";
         return "image/jpeg"; // Telegram profile photos are almost always JPEG
     }
-    async sendReaction(chatId, messageId, emoji) {
+    /** Extract reactions from a message into a simple format */
+    extractReactions(reactions) {
+        if (!reactions?.results?.length)
+            return undefined;
+        const items = [];
+        for (const r of reactions.results) {
+            let emoji;
+            if (r.reaction instanceof Api.ReactionEmoji) {
+                emoji = r.reaction.emoticon;
+            }
+            else if (r.reaction instanceof Api.ReactionCustomEmoji) {
+                emoji = `custom:${r.reaction.documentId}`;
+            }
+            else if (r.reaction instanceof Api.ReactionPaid) {
+                emoji = "⭐";
+            }
+            else {
+                continue;
+            }
+            items.push({ emoji, count: r.count, me: r.chosenOrder != null });
+        }
+        return items.length > 0 ? items : undefined;
+    }
+    async sendReaction(chatId, messageId, emoji, addToExisting = false) {
         if (!this.client || !this.connected)
             throw new Error("Not connected");
         const peer = await this.client.getInputEntity(chatId);
-        const reaction = emoji ? [new Api.ReactionEmoji({ emoticon: emoji })] : []; // empty = remove reaction
-        await this.client.invoke(new Api.messages.SendReaction({
+        const reactionList = [];
+        if (emoji) {
+            const emojis = Array.isArray(emoji) ? emoji : [emoji];
+            if (addToExisting) {
+                // Fetch current reactions to preserve them
+                const msgs = await this.client.getMessages(chatId, { ids: [messageId] });
+                const msg = msgs[0];
+                if (msg?.reactions?.results) {
+                    for (const r of msg.reactions.results) {
+                        if (r.chosenOrder != null) {
+                            reactionList.push(r.reaction);
+                        }
+                    }
+                }
+            }
+            for (const e of emojis) {
+                reactionList.push(new Api.ReactionEmoji({ emoticon: e }));
+            }
+        }
+        // empty array = remove all reactions
+        const result = await this.client.invoke(new Api.messages.SendReaction({
             peer,
             msgId: messageId,
-            reaction,
+            reaction: reactionList,
         }));
+        // Extract updated reactions from the response
+        if ("updates" in result) {
+            for (const upd of result.updates) {
+                if (upd instanceof Api.UpdateMessageReactions) {
+                    return this.extractReactions(upd.reactions);
+                }
+            }
+        }
+        return undefined;
+    }
+    async getMessageReactions(chatId, messageId) {
+        if (!this.client || !this.connected)
+            throw new Error("Not connected");
+        const peer = await this.client.getInputEntity(chatId);
+        // First get the message to know which reactions exist
+        const msgs = await this.client.getMessages(chatId, { ids: [messageId] });
+        const msg = msgs[0];
+        if (!msg?.reactions?.results?.length) {
+            return { reactions: [], total: 0 };
+        }
+        const reactionsOut = [];
+        for (const rc of msg.reactions.results) {
+            let emoji;
+            if (rc.reaction instanceof Api.ReactionEmoji) {
+                emoji = rc.reaction.emoticon;
+            }
+            else if (rc.reaction instanceof Api.ReactionCustomEmoji) {
+                emoji = `custom:${rc.reaction.documentId}`;
+            }
+            else if (rc.reaction instanceof Api.ReactionPaid) {
+                emoji = "⭐";
+            }
+            else {
+                continue;
+            }
+            const users = [];
+            // Try to get the list of users who reacted (may fail if canSeeList is false)
+            if (msg.reactions.canSeeList) {
+                try {
+                    const list = await this.client.invoke(new Api.messages.GetMessageReactionsList({
+                        peer,
+                        id: messageId,
+                        reaction: rc.reaction,
+                        limit: 50,
+                    }));
+                    if (list instanceof Api.messages.MessageReactionsList) {
+                        for (const r of list.reactions) {
+                            const userId = r.peerId instanceof Api.PeerUser ? r.peerId.userId.toString() : "";
+                            if (userId) {
+                                const name = await this.resolveSenderName(bigInt(Number.parseInt(userId)));
+                                users.push({ id: userId, name });
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // canSeeList may be false or request may fail for channels
+                }
+            }
+            reactionsOut.push({ emoji, count: rc.count, users });
+        }
+        const total = reactionsOut.reduce((sum, r) => sum + r.count, 0);
+        return { reactions: reactionsOut, total };
     }
     async sendScheduledMessage(chatId, text, scheduleDate, replyTo, parseMode) {
         if (!this.client || !this.connected)
@@ -1009,6 +1117,7 @@ export class TelegramService {
             sender: await this.resolveSenderName(m.senderId),
             date: new Date((m.date ?? 0) * 1000).toISOString(),
             media: this.extractMediaInfo(m.media),
+            reactions: this.extractReactions(m.reactions),
         })));
         return results;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@overpod/mcp-telegram",
-  "version": "1.10.1",
+  "version": "1.11.0",
   "description": "MCP server for Telegram userbot — messages, media, reactions, polls & more. Built on GramJS/MTProto.",
   "type": "module",
   "main": "dist/index.js",