@overpod/mcp-telegram 1.24.1 → 1.25.0

package/dist/tools/account.js

@@ -258,6 +258,98 @@ export function registerAccountTools(server, telegram) {
             return fail(e);
         }
     });
+    server.registerTool("telegram-save-draft", {
+        description: "Save or clear a message draft for a chat. Pass empty text to clear the draft. Optional replyTo sets the message being replied to",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username"),
+            text: z.string().describe("Draft text. Empty string clears the draft"),
+            replyTo: z.number().int().positive().optional().describe("Message ID this draft replies to"),
+        },
+        annotations: WRITE,
+    }, async ({ chatId, text, replyTo }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            await telegram.saveDraft(chatId, text, replyTo);
+            return ok(text === "" ? `Draft cleared for ${chatId}` : `Draft saved for ${chatId}`);
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-get-drafts", {
+        description: "Get all saved message drafts across chats",
+        inputSchema: {},
+        annotations: READ_ONLY,
+    }, async () => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            const drafts = await telegram.getAllDrafts();
+            if (drafts.length === 0)
+                return ok("No drafts");
+            const text = drafts.map((d) => `[${d.chatId}] ${d.chatTitle} (${d.date})\n  ${d.text}`).join("\n\n");
+            return ok(sanitize(text));
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-clear-drafts", {
+        description: "Delete saved message drafts. Pass chatId to clear the draft for a single chat. Without chatId, clears drafts in ALL chats — requires confirmAllChats: true",
+        inputSchema: {
+            chatId: z.string().optional().describe("Chat ID or username. If provided, clears draft only for this chat"),
+            confirmAllChats: z
+                .boolean()
+                .optional()
+                .describe("Must be true to wipe drafts across ALL chats when chatId is omitted"),
+        },
+        annotations: DESTRUCTIVE,
+    }, async ({ chatId, confirmAllChats }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            if (chatId !== undefined) {
+                if (confirmAllChats) {
+                    return fail(new Error("Pass either chatId or confirmAllChats=true, not both"));
+                }
+                await telegram.saveDraft(chatId, "");
+                return ok(`Draft cleared for ${chatId}`);
+            }
+            if (!confirmAllChats) {
+                return fail(new Error("Refusing to clear drafts in ALL chats without explicit confirmation. Pass chatId for a single chat, or confirmAllChats=true to wipe all drafts"));
+            }
+            await telegram.clearAllDrafts();
+            return ok("All drafts cleared");
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-get-saved-dialogs", {
+        description: "Get Saved Messages dialogs (Telegram's per-sender grouping of messages forwarded to your Saved Messages)",
+        inputSchema: {
+            limit: z.number().int().positive().default(20).describe("Max dialogs to return"),
+        },
+        annotations: READ_ONLY,
+    }, async ({ limit }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            const dialogs = await telegram.getSavedDialogs(limit);
+            if (dialogs.length === 0)
+                return ok("No saved dialogs");
+            const text = dialogs.map((d) => `[${d.peerId}] ${d.peerTitle} — last msg #${d.lastMsgId}`).join("\n");
+            return ok(sanitize(text));
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
     server.registerTool("telegram-revoke-invite-link", {
         description: "Revoke an invite link for a group or channel",
         inputSchema: {

package/dist/tools/chats.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { fail, ok, READ_ONLY, requireConnection, sanitize, WRITE } from "./shared.js";
+import { DESTRUCTIVE, fail, ok, READ_ONLY, requireConnection, sanitize, WRITE } from "./shared.js";
 export function registerChatTools(server, telegram) {
     server.registerTool("telegram-list-chats", {
         description: "List Telegram chats with unread counts, type indicators, and contact status",
@@ -309,6 +309,89 @@ export function registerChatTools(server, telegram) {
             return fail(e);
         }
     });
+    server.registerTool("telegram-archive-chat", {
+        description: "Archive or unarchive a Telegram dialog (moves to/from the Archive folder)",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username"),
+            archive: z.boolean().describe("true to archive, false to unarchive"),
+        },
+        annotations: WRITE,
+    }, async ({ chatId, archive }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            await telegram.archiveChat(chatId, archive);
+            return ok(`${archive ? "Archived" : "Unarchived"} ${chatId}`);
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-pin-chat", {
+        description: "Pin or unpin a Telegram dialog in the dialog list",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username"),
+            pin: z.boolean().describe("true to pin, false to unpin"),
+        },
+        annotations: WRITE,
+    }, async ({ chatId, pin }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            await telegram.pinDialog(chatId, pin);
+            return ok(`${pin ? "Pinned" : "Unpinned"} ${chatId}`);
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-mark-dialog-unread", {
+        description: "Mark a Telegram dialog as unread (or clear the unread mark)",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username"),
+            unread: z.boolean().describe("true to mark as unread, false to clear the mark"),
+        },
+        annotations: WRITE,
+    }, async ({ chatId, unread }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            await telegram.markDialogUnread(chatId, unread);
+            return ok(`Marked ${chatId} as ${unread ? "unread" : "read"}`);
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-get-admin-log", {
+        description: "Get the admin action log (recent event history) of a supergroup or channel. Includes bans, edits, pins, and role changes",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username (supergroup or channel)"),
+            limit: z.number().int().min(1).max(100).default(20).describe("Number of events to return (1-100)"),
+            q: z.string().optional().describe("Optional text filter for events"),
+        },
+        annotations: READ_ONLY,
+    }, async ({ chatId, limit, q }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            const events = await telegram.getAdminLog(chatId, limit, q);
+            const text = events
+                .map((e) => {
+                const details = e.details ? ` — ${e.details}` : "";
+                return `[#${e.id}] [${e.date}] ${e.userName}: ${e.action}${details}`;
+            })
+                .join("\n");
+            return ok(sanitize(text) || "No admin log events");
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
     server.registerTool("telegram-remove-admin", {
         description: "Remove admin rights from a user in a supergroup or channel",
         inputSchema: {
@@ -328,4 +411,158 @@ export function registerChatTools(server, telegram) {
             return fail(e);
         }
     });
+    server.registerTool("telegram-set-chat-permissions", {
+        description: "Set the default permissions for all non-admin members of a group, supergroup, or channel. Omitted flags keep their current state; true = allowed, false = denied",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username"),
+            sendMessages: z.boolean().optional().describe("Allow sending text messages"),
+            sendMedia: z.boolean().optional().describe("Allow sending photos/videos/documents"),
+            sendStickers: z.boolean().optional().describe("Allow sending stickers"),
+            sendGifs: z.boolean().optional().describe("Allow sending GIFs"),
+            sendPolls: z.boolean().optional().describe("Allow sending polls"),
+            sendInline: z.boolean().optional().describe("Allow inline bot usage"),
+            embedLinks: z.boolean().optional().describe("Allow link previews"),
+            changeInfo: z.boolean().optional().describe("Allow changing chat info (title, photo, description)"),
+            inviteUsers: z.boolean().optional().describe("Allow inviting new members"),
+            pinMessages: z.boolean().optional().describe("Allow pinning messages"),
+        },
+        annotations: DESTRUCTIVE,
+    }, async ({ chatId, ...permissions }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            await telegram.setChatPermissions(chatId, permissions);
+            const changed = Object.entries(permissions)
+                .filter(([, v]) => v !== undefined)
+                .map(([k, v]) => `${k}=${v ? "allow" : "deny"}`);
+            return ok(changed.length > 0
+                ? `Updated default permissions for ${chatId}: ${changed.join(", ")}`
+                : `No permission changes for ${chatId}`);
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-set-slow-mode", {
+        description: "Set slow mode for a supergroup (minimum interval between messages per user). Allowed values: 0, 10, 30, 60, 300, 900, 3600 seconds (0 disables slow mode)",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username (supergroup)"),
+            seconds: z
+                .union([
+                z.literal(0),
+                z.literal(10),
+                z.literal(30),
+                z.literal(60),
+                z.literal(300),
+                z.literal(900),
+                z.literal(3600),
+            ])
+                .describe("Interval in seconds: 0 (off), 10, 30, 60, 300, 900, or 3600"),
+        },
+        annotations: WRITE,
+    }, async ({ chatId, seconds }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            await telegram.setSlowMode(chatId, seconds);
+            return ok(seconds === 0 ? `Disabled slow mode in ${chatId}` : `Set slow mode to ${seconds}s in ${chatId}`);
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-create-topic", {
+        description: "Create a new forum topic in a forum-enabled supergroup",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username of the forum supergroup"),
+            title: z.string().describe("Topic title"),
+            iconColor: z
+                .union([
+                z.literal(7322096),
+                z.literal(16766590),
+                z.literal(13338331),
+                z.literal(9367192),
+                z.literal(16749490),
+                z.literal(16225862),
+            ])
+                .optional()
+                .describe("Optional icon color (one of 7322096, 16766590, 13338331, 9367192, 16749490, 16225862)"),
+            iconEmojiId: z
+                .string()
+                .regex(/^\d+$/, "iconEmojiId must be a numeric string")
+                .optional()
+                .describe("Optional custom emoji document ID for the icon (numeric string)"),
+        },
+        annotations: WRITE,
+    }, async ({ chatId, title, iconColor, iconEmojiId }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            const topic = await telegram.createForumTopic(chatId, title, iconColor, iconEmojiId);
+            return ok(sanitize(`Created topic "${topic.title}" (id=${topic.id}) in ${chatId}`));
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-edit-topic", {
+        description: "Edit a forum topic — rename, change icon emoji, open/close, or show/hide",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username of the forum supergroup"),
+            topicId: z.number().describe("Topic ID (get from telegram-list-topics)"),
+            title: z.string().optional().describe("New topic title"),
+            iconEmojiId: z
+                .string()
+                .regex(/^\d+$/, "iconEmojiId must be a numeric string")
+                .optional()
+                .describe("New custom emoji document ID for the icon (numeric string)"),
+            closed: z.boolean().optional().describe("Close (true) or reopen (false) the topic"),
+            hidden: z.boolean().optional().describe("Hide (true) or show (false) the General topic"),
+        },
+        annotations: WRITE,
+    }, async ({ chatId, topicId, title, iconEmojiId, closed, hidden }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            await telegram.editForumTopic(chatId, topicId, { title, iconEmojiId, closed, hidden });
+            const changes = [];
+            if (title !== undefined)
+                changes.push(`title="${title}"`);
+            if (iconEmojiId !== undefined)
+                changes.push(`iconEmojiId=${iconEmojiId}`);
+            if (closed !== undefined)
+                changes.push(closed ? "closed" : "reopened");
+            if (hidden !== undefined)
+                changes.push(hidden ? "hidden" : "shown");
+            return ok(sanitize(changes.length > 0
+                ? `Updated topic ${topicId} in ${chatId}: ${changes.join(", ")}`
+                : `No changes for topic ${topicId} in ${chatId}`));
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-delete-topic", {
+        description: "Delete a forum topic and all its message history",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username of the forum supergroup"),
+            topicId: z.number().describe("Topic ID to delete"),
+        },
+        annotations: DESTRUCTIVE,
+    }, async ({ chatId, topicId }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            await telegram.deleteForumTopic(chatId, topicId);
+            return ok(`Deleted topic ${topicId} in ${chatId}`);
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
 }

package/dist/tools/media.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { fail, ok, READ_ONLY, requireConnection, WRITE } from "./shared.js";
+import { fail, ok, READ_ONLY, requireConnection, sanitize, WRITE } from "./shared.js";
 export function registerMediaTools(server, telegram) {
     server.registerTool("telegram-send-file", {
         description: "Send a file (photo, document, video, etc.) to a Telegram chat",
@@ -81,4 +81,123 @@ export function registerMediaTools(server, telegram) {
             return fail(e);
         }
     });
+    server.registerTool("telegram-get-web-preview", {
+        description: "Fetch Telegram's web-page preview metadata (type, title, description, site name) for a URL",
+        inputSchema: {
+            url: z
+                .string()
+                .url()
+                .refine((u) => {
+                try {
+                    const p = new URL(u);
+                    if (p.protocol !== "http:" && p.protocol !== "https:")
+                        return false;
+                    const host = p.hostname
+                        .toLowerCase()
+                        .replace(/^\[|\]$/g, "")
+                        .replace(/\.$/, "");
+                    if (host === "localhost" ||
+                        // Trailing-dot and subdomain forms of localhost (e.g. "localhost.", "foo.localhost")
+                        host.endsWith(".localhost") ||
+                        // Unspecified: 0.0.0.0/8
+                        /^0\./.test(host) ||
+                        // IPv4 loopback
+                        /^127\./.test(host) ||
+                        // IPv6 loopback and unspecified address
+                        host === "::1" ||
+                        host === "::" ||
+                        // Link-local (AWS metadata, etc.)
+                        /^169\.254\./.test(host) ||
+                        // RFC1918 private ranges
+                        /^10\./.test(host) ||
+                        /^172\.(1[6-9]|2\d|3[01])\./.test(host) ||
+                        /^192\.168\./.test(host) ||
+                        // IETF Protocol Assignments: 192.0.0.0/24
+                        /^192\.0\.0\./.test(host) ||
+                        // Documentation ranges (TEST-NET-1/2/3, RFC 5737): 192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24
+                        /^192\.0\.2\./.test(host) ||
+                        /^198\.51\.100\./.test(host) ||
+                        /^203\.0\.113\./.test(host) ||
+                        // CGNAT (RFC 6598): 100.64.0.0/10
+                        /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./.test(host) ||
+                        // Benchmark testing (RFC 2544): 198.18.0.0/15
+                        /^198\.1[89]\./.test(host) ||
+                        // IPv4 multicast: 224.0.0.0/4
+                        /^2(2[4-9]|3\d)\./.test(host) ||
+                        // Reserved (future use): 240.0.0.0/4 and broadcast
+                        /^(24[0-9]|25[0-5])\./.test(host)) {
+                        return false;
+                    }
+                    // IPv4-mapped IPv6 (e.g. ::ffff:127.0.0.1 or Node-normalized ::ffff:7f00:1)
+                    if (/^::ffff:/i.test(host)) {
+                        let v4 = host.replace(/^::ffff:/i, "");
+                        // Node.js normalizes ::ffff:a.b.c.d to ::ffff:XXYY:ZZWW (hex pairs).
+                        // Convert hex-pair form back to dotted decimal before range checks.
+                        const hexPair = /^([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i.exec(v4);
+                        if (hexPair) {
+                            const hi = hexPair[1].padStart(4, "0");
+                            const lo = hexPair[2].padStart(4, "0");
+                            v4 = [
+                                parseInt(hi.slice(0, 2), 16),
+                                parseInt(hi.slice(2, 4), 16),
+                                parseInt(lo.slice(0, 2), 16),
+                                parseInt(lo.slice(2, 4), 16),
+                            ].join(".");
+                        }
+                        if (/^0\./.test(v4) ||
+                            /^127\./.test(v4) ||
+                            /^10\./.test(v4) ||
+                            /^172\.(1[6-9]|2\d|3[01])\./.test(v4) ||
+                            /^192\.168\./.test(v4) ||
+                            /^192\.0\.0\./.test(v4) ||
+                            /^192\.0\.2\./.test(v4) ||
+                            /^198\.51\.100\./.test(v4) ||
+                            /^203\.0\.113\./.test(v4) ||
+                            /^169\.254\./.test(v4) ||
+                            /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./.test(v4) ||
+                            /^198\.1[89]\./.test(v4) ||
+                            /^2(2[4-9]|3\d)\./.test(v4) ||
+                            /^(24[0-9]|25[0-5])\./.test(v4)) {
+                            return false;
+                        }
+                    }
+                    // Private IPv6: ULA fc00::/7, link-local fe80::/10, multicast ff00::/8, documentation 2001:db8::/32
+                    if (/^f[cd][0-9a-f]/i.test(host) ||
+                        /^fe[89ab][0-9a-f]/i.test(host) ||
+                        /^ff[0-9a-f]{2}/i.test(host) ||
+                        /^2001:0?db8:/i.test(host)) {
+                        return false;
+                    }
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            }, "Only http:// and https:// URLs are allowed; literal loopback, private, link-local, and reserved IP addresses are blocked (DNS-backed hostnames that resolve to private ranges are not checked)")
+                .describe("URL to preview (http:// or https://; literal private/loopback/reserved IPs rejected)"),
+        },
+        annotations: READ_ONLY,
+    }, async ({ url }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            const preview = await telegram.getWebPreview(url);
+            if (!preview)
+                return ok("No preview available");
+            const lines = [`type: ${preview.type}`];
+            if (preview.url)
+                lines.push(`url: ${preview.url}`);
+            if (preview.siteName)
+                lines.push(`site: ${sanitize(preview.siteName)}`);
+            if (preview.title)
+                lines.push(`title: ${sanitize(preview.title)}`);
+            if (preview.description)
+                lines.push(`description: ${sanitize(preview.description)}`);
+            return ok(lines.join("\n"));
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
 }

package/dist/tools/messages.js

@@ -191,6 +191,193 @@ export function registerMessageTools(server, telegram) {
             return fail(e);
         }
     });
+    server.registerTool("telegram-get-scheduled", {
+        description: "List scheduled messages in a Telegram chat",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username"),
+        },
+        annotations: READ_ONLY,
+    }, async ({ chatId }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            const messages = await telegram.getScheduledMessages(chatId);
+            const text = messages
+                .map((m) => `[#${m.id}] [${m.date}] ${m.text}${m.media ? ` [${m.media.type}${m.media.fileName ? `: ${m.media.fileName}` : ""}]` : ""}`)
+                .join("\n\n");
+            return ok(sanitize(text) || "No scheduled messages");
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-delete-scheduled", {
+        description: "Delete scheduled messages in a Telegram chat",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username"),
+            messageIds: z
+                .array(z.number().int().positive())
+                .min(1)
+                .max(100)
+                .describe("Array of scheduled message IDs to delete (1-100)"),
+        },
+        annotations: DESTRUCTIVE,
+    }, async ({ chatId, messageIds }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            await telegram.deleteScheduledMessages(chatId, messageIds);
+            return ok(`Deleted ${messageIds.length} scheduled message(s) in ${chatId}`);
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-get-replies", {
+        description: "Get replies/comments under a Telegram channel post or discussion message",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username (channel or linked discussion group)"),
+            messageId: z.number().describe("ID of the message whose replies to fetch"),
+            limit: z.number().default(20).describe("Number of replies to return"),
+        },
+        annotations: READ_ONLY,
+    }, async ({ chatId, messageId, limit }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            const messages = await telegram.getReplies(chatId, messageId, limit);
+            const text = messages
+                .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 ok(sanitize(text) || "No replies");
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-get-message-link", {
+        description: "Get a t.me link to a specific message in a Telegram channel or supergroup",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username (channel or supergroup)"),
+            messageId: z.number().describe("ID of the message to link to"),
+            thread: z.boolean().default(false).describe("Link to the message thread instead of the message itself"),
+        },
+        annotations: READ_ONLY,
+    }, async ({ chatId, messageId, thread }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            const link = await telegram.getMessageLink(chatId, messageId, thread);
+            return ok(sanitize(link));
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-get-unread-mentions", {
+        description: "Get unread @mentions addressed to you in a Telegram chat. Marks all mentions as read on the server when all unread mentions fit within the requested limit.",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username"),
+            limit: z.number().default(20).describe("Max number of mentions to return"),
+        },
+        annotations: WRITE,
+    }, async ({ chatId, limit }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            const messages = await telegram.getUnreadMentions(chatId, limit);
+            const text = messages
+                .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 ok(sanitize(text) || "No unread mentions");
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-get-unread-reactions", {
+        description: "Get messages with unread reactions on your posts in a Telegram chat. Marks all reactions as read on the server when all unread reactions fit within the requested limit.",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username"),
+            limit: z.number().default(20).describe("Max number of messages to return"),
+        },
+        annotations: WRITE,
+    }, async ({ chatId, limit }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            const messages = await telegram.getUnreadReactions(chatId, limit);
+            const text = messages
+                .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 ok(sanitize(text) || "No unread reactions");
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-translate-message", {
+        description: "Translate one or more Telegram messages to a target language (requires Telegram Premium). Consumes account translation quota.",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username"),
+            messageIds: z
+                .array(z.number().int().positive())
+                .min(1)
+                .max(100)
+                .describe("Array of message IDs to translate (1-100)"),
+            toLang: z
+                .string()
+                .regex(/^[a-z]{2,3}(-[A-Z]{2})?$/)
+                .describe("ISO 639-1 (e.g. 'en', 'ru') or locale (e.g. 'en-US')"),
+        },
+        annotations: WRITE,
+    }, async ({ chatId, messageIds, toLang }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            const translations = await telegram.translateText(chatId, messageIds, toLang);
+            const text = translations.length === messageIds.length
+                ? translations.map((t, i) => `[#${messageIds[i]}] ${t}`).join("\n\n")
+                : translations.join("\n\n");
+            return ok(sanitize(text) || "No translations");
+        }
+        catch (e) {
+            const msg = e.message ?? "";
+            if (/PREMIUM|PAYMENT_REQUIRED|TRANSLATE_REQ/i.test(msg)) {
+                return fail(new Error("Message translation requires Telegram Premium on this account"));
+            }
+            return fail(e);
+        }
+    });
+    server.registerTool("telegram-send-typing", {
+        description: "Send a typing/upload indicator to a Telegram chat (or cancel it)",
+        inputSchema: {
+            chatId: z.string().describe("Chat ID or username"),
+            action: z
+                .enum(["typing", "upload_photo", "upload_document", "cancel"])
+                .default("typing")
+                .describe("Typing action to broadcast"),
+        },
+        annotations: WRITE,
+    }, async ({ chatId, action }) => {
+        const err = await requireConnection(telegram);
+        if (err)
+            return fail(new Error(err));
+        try {
+            await telegram.sendTyping(chatId, action);
+            return ok(`Typing indicator (${action}) sent to ${chatId}`);
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
     server.registerTool("telegram-mark-as-read", {
         description: "Mark a Telegram chat as read",
         inputSchema: { chatId: z.string().describe("Chat ID or username") },