@overpod/mcp-telegram 1.17.0 → 1.18.0

package/dist/telegram-client.d.ts

@@ -182,7 +182,15 @@ export declare class TelegramService {
         id: string;
         name: string;
         username?: string;
+        role: string;
     }>>;
+    getMyRole(chatId: string): Promise<{
+        role: string;
+        chatId: string;
+        chatName: string;
+    }>;
+    private getParticipantUserId;
+    private getParticipantRole;
     getProfile(userId: string): Promise<{
         id: string;
         name: string;

package/dist/telegram-client.js

@@ -879,19 +879,99 @@ export class TelegramService {
     async getChatMembers(chatId, limit = 50) {
         if (!this.client || !this.connected)
             throw new Error("Not connected");
-        const participants = await this.client.getParticipants(chatId, { limit });
-        const members = [];
-        for (const p of participants) {
-            if (p instanceof Api.User) {
-                const parts = [p.firstName, p.lastName].filter(Boolean);
-                members.push({
-                    id: p.id.toString(),
+        const entity = await this.resolveChat(chatId);
+        if (entity instanceof Api.Channel) {
+            const result = await this.client.invoke(new Api.channels.GetParticipants({
+                channel: entity,
+                filter: new Api.ChannelParticipantsRecent(),
+                offset: 0,
+                limit,
+                hash: bigInt.zero,
+            }));
+            if (!(result instanceof Api.channels.ChannelParticipants))
+                return [];
+            const userMap = new Map();
+            for (const u of result.users) {
+                if (u instanceof Api.User)
+                    userMap.set(u.id.toString(), u);
+            }
+            return result.participants.map((p) => {
+                const userId = this.getParticipantUserId(p);
+                const user = userMap.get(userId);
+                const parts = user ? [user.firstName, user.lastName].filter(Boolean) : [];
+                return {
+                    id: userId,
                     name: parts.join(" ") || "Unknown",
-                    username: p.username ?? undefined,
-                });
+                    username: user?.username ?? undefined,
+                    role: this.getParticipantRole(p),
+                };
+            });
+        }
+        // Basic group — use getParticipants (no role info available)
+        const participants = await this.client.getParticipants(entity, { limit });
+        return participants
+            .filter((p) => p instanceof Api.User)
+            .map((p) => {
+            const parts = [p.firstName, p.lastName].filter(Boolean);
+            return {
+                id: p.id.toString(),
+                name: parts.join(" ") || "Unknown",
+                username: p.username ?? undefined,
+                role: "member",
+            };
+        });
+    }
+    async getMyRole(chatId) {
+        if (!this.client || !this.connected)
+            throw new Error("Not connected");
+        const entity = await this.resolveChat(chatId);
+        const me = await this.getMe();
+        if (entity instanceof Api.Channel) {
+            const result = await this.client.invoke(new Api.channels.GetParticipant({ channel: entity, participant: new Api.InputUserSelf() }));
+            return {
+                role: this.getParticipantRole(result.participant),
+                chatId: entity.id.toString(),
+                chatName: entity.title ?? "Unknown",
+            };
+        }
+        if (entity instanceof Api.Chat) {
+            // Basic group — check if creator
+            if (entity.creator) {
+                return { role: "creator", chatId: entity.id.toString(), chatName: entity.title ?? "Unknown" };
             }
+            if (entity.adminRights) {
+                return { role: "admin", chatId: entity.id.toString(), chatName: entity.title ?? "Unknown" };
+            }
+            return { role: "member", chatId: entity.id.toString(), chatName: entity.title ?? "Unknown" };
         }
-        return members;
+        if (entity instanceof Api.User) {
+            return { role: "user", chatId: entity.id.toString(), chatName: me.username ?? "self" };
+        }
+        return { role: "unknown", chatId: chatId, chatName: "Unknown" };
+    }
+    getParticipantUserId(p) {
+        if (p instanceof Api.ChannelParticipantCreator)
+            return p.userId.toString();
+        if (p instanceof Api.ChannelParticipantAdmin)
+            return p.userId.toString();
+        if (p instanceof Api.ChannelParticipantSelf)
+            return p.userId.toString();
+        if (p instanceof Api.ChannelParticipantBanned)
+            return p.peer?.userId?.toString() ?? "0";
+        if (p instanceof Api.ChannelParticipant)
+            return p.userId.toString();
+        return "0";
+    }
+    getParticipantRole(p) {
+        if (p instanceof Api.ChannelParticipantCreator)
+            return "creator";
+        if (p instanceof Api.ChannelParticipantAdmin)
+            return "admin";
+        if (p instanceof Api.ChannelParticipantBanned)
+            return "banned";
+        if (p instanceof Api.ChannelParticipantLeft)
+            return "left";
+        return "member";
     }
     async getProfile(userId) {
         if (!this.client || !this.connected)

package/dist/tools/chats.js

@@ -93,13 +93,36 @@ export function registerChatTools(server, telegram) {
             return fail(new Error(err));
         try {
             const members = await telegram.getChatMembers(chatId, limit);
-            const text = members.map((m) => `${m.name}${m.username ? ` (@${m.username})` : ""} (${m.id})`).join("\n");
+            const text = members
+                .map((m) => {
+                const role = m.role !== "member" ? ` [${m.role}]` : "";
+                return `${m.name}${m.username ? ` (@${m.username})` : ""} (${m.id})${role}`;
+            })
+                .join("\n");
             return ok(sanitize(text) || "No members found");
         }
         catch (e) {
             return fail(e);
         }
     });
+    server.registerTool("telegram-get-my-role", {
+        description: "Get the current user's role in a chat (creator, admin, or member)",
+        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 result = await telegram.getMyRole(chatId);
+            return ok(`Role: ${result.role}\nChat: ${result.chatName} (${result.chatId})`);
+        }
+        catch (e) {
+            return fail(e);
+        }
+    });
     server.registerTool("telegram-create-group", {
         description: "Create a new Telegram group or supergroup",
         inputSchema: {

package/package.json

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