@overpod/mcp-telegram 1.4.0 → 1.5.0

package/dist/index.js

@@ -419,9 +419,7 @@ server.tool("telegram-get-profile", "Get detailed profile info of a Telegram use
     }
 });
 server.tool("telegram-join-chat", "Join a Telegram group or channel by username or invite link", {
-    target: z
-        .string()
-        .describe("Username (@group), link (t.me/group), or invite link (t.me/+xxx)"),
+    target: z.string().describe("Username (@group), link (t.me/group), or invite link (t.me/+xxx)"),
 }, async ({ target }) => {
     const err = await requireConnection();
     if (err)
@@ -443,6 +441,72 @@ 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", {
+    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 }) => {
+    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}` }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Reaction 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"),
+    scheduleDate: z.number().describe("Unix timestamp when to send the message (must be in the future)"),
+    replyTo: z.number().optional().describe("Message ID to reply to"),
+    parseMode: z.enum(["md", "html"]).optional().describe("Message format: md (Markdown) or html"),
+}, async ({ chatId, text, scheduleDate, replyTo, parseMode }) => {
+    const err = await requireConnection();
+    if (err)
+        return { content: [{ type: "text", text: err }] };
+    // Resolve 'me'/'self' to Saved Messages
+    let target = chatId;
+    if (target === "me" || target === "self") {
+        try {
+            const me = await telegram.getMe();
+            target = me.id;
+        }
+        catch {
+            return { content: [{ type: "text", text: "Failed to resolve Saved Messages" }] };
+        }
+    }
+    try {
+        await telegram.sendScheduledMessage(target, text, scheduleDate, replyTo, parseMode);
+        const date = new Date(scheduleDate * 1000).toISOString();
+        return { content: [{ type: "text", text: `Message scheduled for ${date} in ${chatId}` }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Schedule error: ${e.message}` }] };
+    }
+});
+server.tool("telegram-create-poll", "Create a poll in a Telegram chat", {
+    chatId: z.string().describe("Chat ID or username"),
+    question: z.string().describe("Poll question"),
+    answers: z.array(z.string()).min(2).max(10).describe("Answer options (2-10)"),
+    multipleChoice: z.boolean().default(false).describe("Allow multiple answers"),
+    quiz: z.boolean().default(false).describe("Quiz mode (one correct answer)"),
+    correctAnswer: z.number().optional().describe("Index of correct answer (0-based, required for quiz mode)"),
+}, async ({ chatId, question, answers, multipleChoice, quiz, correctAnswer }) => {
+    const err = await requireConnection();
+    if (err)
+        return { content: [{ type: "text", text: err }] };
+    try {
+        const msgId = await telegram.createPoll(chatId, question, answers, { multipleChoice, quiz, correctAnswer });
+        return { content: [{ type: "text", text: `Poll created in ${chatId}${msgId ? ` (message #${msgId})` : ""}` }] };
+    }
+    catch (e) {
+        return { content: [{ type: "text", text: `Poll error: ${e.message}` }] };
+    }
+});
 // --- Start ---
 async function main() {
     // Try to auto-connect with saved session

package/dist/telegram-client.d.ts

@@ -119,6 +119,13 @@ export declare class TelegramService {
         photo: boolean;
         lastSeen?: string;
     }>;
+    sendReaction(chatId: string, messageId: number, emoji?: string): Promise<void>;
+    sendScheduledMessage(chatId: string, text: string, scheduleDate: number, replyTo?: number, parseMode?: "md" | "html"): Promise<void>;
+    createPoll(chatId: string, question: string, answers: string[], options?: {
+        multipleChoice?: boolean;
+        quiz?: boolean;
+        correctAnswer?: number;
+    }): Promise<number>;
     joinChat(target: string): Promise<{
         id: string;
         title: string;

package/dist/telegram-client.js

@@ -603,6 +603,63 @@ export class TelegramService {
             lastSeen,
         };
     }
+    async sendReaction(chatId, messageId, emoji) {
+        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({
+            peer,
+            msgId: messageId,
+            reaction,
+        }));
+    }
+    async sendScheduledMessage(chatId, text, scheduleDate, replyTo, parseMode) {
+        if (!this.client || !this.connected)
+            throw new Error("Not connected");
+        await this.client.sendMessage(chatId, {
+            message: text,
+            schedule: scheduleDate,
+            ...(replyTo ? { replyTo } : {}),
+            ...(parseMode ? { parseMode: parseMode === "html" ? "html" : "md" } : {}),
+        });
+    }
+    async createPoll(chatId, question, answers, options) {
+        if (!this.client || !this.connected)
+            throw new Error("Not connected");
+        const peer = await this.client.getInputEntity(chatId);
+        const pollAnswers = answers.map((text, i) => new Api.PollAnswer({
+            text: new Api.TextWithEntities({ text, entities: [] }),
+            option: Buffer.from([i]),
+        }));
+        const poll = new Api.Poll({
+            id: bigInt(Date.now()),
+            question: new Api.TextWithEntities({ text: question, entities: [] }),
+            answers: pollAnswers,
+            multipleChoice: options?.multipleChoice ?? false,
+            quiz: options?.quiz ?? false,
+        });
+        const result = await this.client.invoke(new Api.messages.SendMedia({
+            peer,
+            media: new Api.InputMediaPoll({
+                poll,
+                ...(options?.quiz && options.correctAnswer != null
+                    ? { correctAnswers: [Buffer.from([options.correctAnswer])] }
+                    : {}),
+            }),
+            message: "",
+            randomId: bigInt(Math.floor(Math.random() * 1e15)),
+        }));
+        // Extract message ID from result
+        if (result instanceof Api.Updates || result instanceof Api.UpdatesCombined) {
+            for (const update of result.updates) {
+                if (update instanceof Api.UpdateMessageID) {
+                    return update.id;
+                }
+            }
+        }
+        return 0;
+    }
     async joinChat(target) {
         if (!this.client)
             throw new Error("Not connected");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@overpod/mcp-telegram",
-  "version": "1.4.0",
-  "description": "MCP server for Telegram userbot — 20 tools for messages, media, contacts & more. Built on GramJS/MTProto.",
+  "version": "1.5.0",
+  "description": "MCP server for Telegram userbot — 24 tools for messages, media, contacts & more. Built on GramJS/MTProto.",
   "type": "module",
   "main": "dist/index.js",
   "exports": {