@overpod/mcp-telegram 1.26.0 → 1.26.1

package/dist/telegram-helpers.js

@@ -0,0 +1,870 @@
+import { Api } from "telegram/tl/index.js";
+export function describeAdminLogAction(action) {
+    const prefix = "ChannelAdminLogEventAction";
+    const raw = action.className.startsWith(prefix) ? action.className.slice(prefix.length) : action.className;
+    return raw
+        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
+        .replace(/([a-z])([A-Z])/g, "$1_$2")
+        .toLowerCase();
+}
+export function describeAdminLogDetails(action, describeUser) {
+    if (action instanceof Api.ChannelAdminLogEventActionChangeTitle) {
+        return `"${action.prevValue}" → "${action.newValue}"`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionChangeAbout) {
+        return `description changed`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionChangeUsername) {
+        return `@${action.prevValue || "-"} → @${action.newValue || "-"}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionUpdatePinned) {
+        return `message #${action.message instanceof Api.Message ? action.message.id : "?"}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionEditMessage) {
+        return `message #${action.newMessage instanceof Api.Message ? action.newMessage.id : "?"}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionDeleteMessage) {
+        return `message #${action.message instanceof Api.Message ? action.message.id : "?"}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionParticipantInvite) {
+        const p = action.participant;
+        return `invited user ${"userId" in p ? describeUser(p.userId) : "?"}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionParticipantToggleBan) {
+        const p = action.newParticipant;
+        if (p instanceof Api.ChannelParticipantBanned) {
+            const uid = p.peer instanceof Api.PeerUser ? p.peer.userId : undefined;
+            return `banned user ${uid ? describeUser(uid) : "?"}`;
+        }
+        return `unbanned user ${"userId" in p ? describeUser(p.userId) : "?"}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionParticipantToggleAdmin) {
+        const p = action.newParticipant;
+        return `admin rights changed for ${"userId" in p ? describeUser(p.userId) : "?"}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionToggleSlowMode) {
+        return `${action.prevValue}s → ${action.newValue}s`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionToggleInvites) {
+        return `invites ${action.newValue ? "enabled" : "disabled"}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionToggleSignatures) {
+        return `signatures ${action.newValue ? "enabled" : "disabled"}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionTogglePreHistoryHidden) {
+        return `pre-history hidden: ${action.newValue}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionChangeHistoryTTL) {
+        return `${action.prevValue}s → ${action.newValue}s`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionChangeStickerSet) {
+        return `sticker set changed`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionChangeLinkedChat) {
+        return `${action.prevValue.toString()} → ${action.newValue.toString()}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionStopPoll) {
+        return `poll in message #${action.message instanceof Api.Message ? action.message.id : "?"}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionSendMessage) {
+        return `message #${action.message instanceof Api.Message ? action.message.id : "?"}`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionCreateTopic) {
+        return `topic "${action.topic instanceof Api.ForumTopic ? action.topic.title : "?"}"`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionDeleteTopic) {
+        return `topic "${action.topic instanceof Api.ForumTopic ? action.topic.title : "?"}"`;
+    }
+    if (action instanceof Api.ChannelAdminLogEventActionEditTopic) {
+        return `topic "${action.newTopic instanceof Api.ForumTopic ? action.newTopic.title : "?"}"`;
+    }
+    return "";
+}
+export function reactionToEmoji(reaction) {
+    if (reaction instanceof Api.ReactionEmoji)
+        return reaction.emoticon;
+    if (reaction instanceof Api.ReactionCustomEmoji)
+        return `custom:${reaction.documentId.toString()}`;
+    if (reaction instanceof Api.ReactionPaid)
+        return "⭐";
+    return null;
+}
+function absValue(v) {
+    return { current: v?.current ?? 0, previous: v?.previous ?? 0 };
+}
+function compactGraph(g) {
+    if (g instanceof Api.StatsGraphAsync)
+        return { type: "async", token: g.token };
+    if (g instanceof Api.StatsGraphError)
+        return { type: "error", error: g.error };
+    if (g instanceof Api.StatsGraph) {
+        let parsed = g.json?.data;
+        if (typeof parsed === "string") {
+            try {
+                parsed = JSON.parse(parsed);
+            }
+            catch {
+                // leave raw string
+            }
+        }
+        return { type: "data", data: parsed, zoomToken: g.zoomToken };
+    }
+    const any = g;
+    if (typeof any.token === "string")
+        return { type: "async", token: any.token };
+    if (typeof any.error === "string")
+        return { type: "error", error: any.error };
+    return { type: "data", data: any.json?.data, zoomToken: any.zoomToken };
+}
+export function summarizeMegagroupStats(stats, includeGraphs) {
+    const summary = {
+        period: {
+            minDate: stats.period?.minDate ?? 0,
+            maxDate: stats.period?.maxDate ?? 0,
+        },
+        members: absValue(stats.members),
+        messages: absValue(stats.messages),
+        viewers: absValue(stats.viewers),
+        posters: absValue(stats.posters),
+        topPosters: (stats.topPosters ?? []).map((p) => ({
+            userId: p.userId?.toString() ?? "",
+            messages: p.messages,
+            avgChars: p.avgChars,
+        })),
+        topAdmins: (stats.topAdmins ?? []).map((a) => ({
+            userId: a.userId?.toString() ?? "",
+            deleted: a.deleted,
+            kicked: a.kicked,
+            banned: a.banned,
+        })),
+        topInviters: (stats.topInviters ?? []).map((i) => ({
+            userId: i.userId?.toString() ?? "",
+            invitations: i.invitations,
+        })),
+    };
+    if (includeGraphs) {
+        summary.graphs = {
+            growth: compactGraph(stats.growthGraph),
+            members: compactGraph(stats.membersGraph),
+            newMembersBySource: compactGraph(stats.newMembersBySourceGraph),
+            languages: compactGraph(stats.languagesGraph),
+            messages: compactGraph(stats.messagesGraph),
+            actions: compactGraph(stats.actionsGraph),
+            topHours: compactGraph(stats.topHoursGraph),
+            weekdays: compactGraph(stats.weekdaysGraph),
+        };
+    }
+    return summary;
+}
+export function summarizeBroadcastStats(stats, includeGraphs) {
+    const enabled = stats.enabledNotifications;
+    const part = enabled?.part ?? 0;
+    const total = enabled?.total ?? 0;
+    const percent = total > 0 ? (part / total) * 100 : 0;
+    const summary = {
+        period: {
+            minDate: stats.period?.minDate ?? 0,
+            maxDate: stats.period?.maxDate ?? 0,
+        },
+        followers: absValue(stats.followers),
+        viewsPerPost: absValue(stats.viewsPerPost),
+        sharesPerPost: absValue(stats.sharesPerPost),
+        reactionsPerPost: absValue(stats.reactionsPerPost),
+        viewsPerStory: absValue(stats.viewsPerStory),
+        sharesPerStory: absValue(stats.sharesPerStory),
+        reactionsPerStory: absValue(stats.reactionsPerStory),
+        enabledNotifications: { part, total, percent },
+        recentPostsInteractions: (stats.recentPostsInteractions ?? []).map((p) => {
+            if (p instanceof Api.PostInteractionCountersStory) {
+                return {
+                    kind: "story",
+                    storyId: p.storyId,
+                    views: p.views,
+                    forwards: p.forwards,
+                    reactions: p.reactions,
+                };
+            }
+            const m = p;
+            return {
+                kind: "message",
+                msgId: m.msgId,
+                views: m.views,
+                forwards: m.forwards,
+                reactions: m.reactions,
+            };
+        }),
+    };
+    if (includeGraphs) {
+        summary.graphs = {
+            growth: compactGraph(stats.growthGraph),
+            followers: compactGraph(stats.followersGraph),
+            mute: compactGraph(stats.muteGraph),
+            topHours: compactGraph(stats.topHoursGraph),
+            interactions: compactGraph(stats.interactionsGraph),
+            ivInteractions: compactGraph(stats.ivInteractionsGraph),
+            viewsBySource: compactGraph(stats.viewsBySourceGraph),
+            newFollowersBySource: compactGraph(stats.newFollowersBySourceGraph),
+            languages: compactGraph(stats.languagesGraph),
+            reactionsByEmotion: compactGraph(stats.reactionsByEmotionGraph),
+            storyInteractions: compactGraph(stats.storyInteractionsGraph),
+            storyReactionsByEmotion: compactGraph(stats.storyReactionsByEmotionGraph),
+        };
+    }
+    return summary;
+}
+const BANNED_RIGHT_FLAGS = [
+    "sendMessages",
+    "sendMedia",
+    "sendStickers",
+    "sendGifs",
+    "sendPolls",
+    "sendInline",
+    "embedLinks",
+    "changeInfo",
+    "inviteUsers",
+    "pinMessages",
+];
+// Newer granular flags not exposed in ChatPermissions input but must be preserved from currentRights
+const EXTRA_BANNED_RIGHT_FLAGS = [
+    "sendGames",
+    "manageTopics",
+    "sendPhotos",
+    "sendVideos",
+    "sendRoundvideos",
+    "sendAudios",
+    "sendVoices",
+    "sendDocs",
+    "sendPlain",
+];
+export function mergeBannedRights(current, permissions) {
+    const result = {};
+    for (const flag of BANNED_RIGHT_FLAGS) {
+        const userValue = permissions[flag];
+        if (userValue !== undefined) {
+            result[flag] = !userValue;
+        }
+        else {
+            result[flag] = Boolean(current?.[flag]);
+        }
+    }
+    // Preserve newer granular flags from existing rights so they are not silently cleared
+    for (const flag of EXTRA_BANNED_RIGHT_FLAGS) {
+        result[flag] = Boolean(current?.[flag]);
+    }
+    return result;
+}
+export function describeKeyboardButton(button, row, col) {
+    const base = {
+        row,
+        col,
+        type: button.className,
+        label: "text" in button && typeof button.text === "string" ? button.text : "",
+    };
+    if (button instanceof Api.KeyboardButtonCallback) {
+        base.data = Buffer.from(button.data).toString("base64");
+        if (button.requiresPassword)
+            base.requiresPassword = true;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonUrl) {
+        base.url = button.url;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonUrlAuth) {
+        base.url = button.url;
+        base.buttonId = button.buttonId;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonSwitchInline) {
+        base.switchQuery = button.query;
+        base.samePeer = Boolean(button.samePeer);
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonWebView || button instanceof Api.KeyboardButtonSimpleWebView) {
+        base.url = button.url;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonUserProfile) {
+        base.userId = button.userId?.toString();
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonRequestPoll) {
+        if (button.quiz)
+            base.quiz = true;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonRequestPeer) {
+        base.buttonId = button.buttonId;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonCopy) {
+        base.copyText = button.copyText;
+        return base;
+    }
+    return base;
+}
+export function peerToCompact(peer) {
+    if (!peer)
+        return undefined;
+    if (peer instanceof Api.PeerUser)
+        return { kind: "user", id: peer.userId.toString() };
+    if (peer instanceof Api.PeerChat)
+        return { kind: "chat", id: peer.chatId.toString() };
+    if (peer instanceof Api.PeerChannel)
+        return { kind: "channel", id: peer.channelId.toString() };
+    return undefined;
+}
+function summarizeMessageForUpdates(msg) {
+    if (msg instanceof Api.MessageEmpty)
+        return null;
+    const peer = peerToCompact(msg.peerId);
+    if (!peer)
+        return null;
+    const fromId = peerToCompact(msg.fromId);
+    const date = msg.date ?? 0;
+    if (msg instanceof Api.Message) {
+        return { id: msg.id, peer, fromId, date, text: msg.message ?? "", isService: false };
+    }
+    if (msg instanceof Api.MessageService) {
+        return {
+            id: msg.id,
+            peer,
+            fromId,
+            date,
+            text: `[${msg.action?.className ?? "service"}]`,
+            isService: true,
+        };
+    }
+    return null;
+}
+function collectDeletedMessageIds(updates) {
+    const out = [];
+    for (const u of updates) {
+        if (u instanceof Api.UpdateDeleteMessages) {
+            out.push({ messageIds: u.messages });
+        }
+        else if (u instanceof Api.UpdateDeleteChannelMessages) {
+            out.push({
+                peer: { kind: "channel", id: u.channelId.toString() },
+                messageIds: u.messages,
+            });
+        }
+    }
+    return out;
+}
+export function summarizeUpdatesDifference(diff, cursor) {
+    if (diff instanceof Api.updates.DifferenceEmpty) {
+        return {
+            state: { pts: cursor.pts, qts: cursor.qts, date: diff.date, seq: diff.seq },
+            isFinal: true,
+            newMessages: [],
+            deletedMessageIds: [],
+            otherUpdates: [],
+        };
+    }
+    if (diff instanceof Api.updates.DifferenceTooLong) {
+        return {
+            state: { pts: diff.pts, qts: cursor.qts, date: cursor.date, seq: 0 },
+            isFinal: true,
+            newMessages: [],
+            deletedMessageIds: [],
+            otherUpdates: [],
+            fallback: {
+                kind: "tooLong",
+                suggestedAction: "gap too large — call telegram-read-messages per chat or telegram-get-state to resync",
+            },
+        };
+    }
+    const isFinal = diff instanceof Api.updates.Difference;
+    const state = isFinal
+        ? diff.state
+        : diff.intermediateState;
+    const newMessages = (diff.newMessages ?? [])
+        .map(summarizeMessageForUpdates)
+        .filter((m) => m !== null);
+    const otherUpdates = diff.otherUpdates ?? [];
+    return {
+        state: {
+            pts: state.pts,
+            qts: state.qts,
+            date: state.date,
+            seq: state.seq,
+            unreadCount: state.unreadCount,
+        },
+        isFinal,
+        newMessages,
+        deletedMessageIds: collectDeletedMessageIds(otherUpdates),
+        otherUpdates: otherUpdates.map((u) => ({ type: u.className })),
+    };
+}
+export function summarizeChannelDifference(diff, channelId, fallbackPts) {
+    if (diff instanceof Api.updates.ChannelDifferenceEmpty) {
+        return {
+            channelId,
+            pts: diff.pts,
+            isFinal: Boolean(diff.final),
+            timeout: diff.timeout,
+            newMessages: [],
+            otherUpdates: [],
+        };
+    }
+    if (diff instanceof Api.updates.ChannelDifferenceTooLong) {
+        const freshPts = diff.dialog instanceof Api.Dialog ? (diff.dialog.pts ?? fallbackPts) : fallbackPts;
+        return {
+            channelId,
+            pts: freshPts,
+            isFinal: Boolean(diff.final),
+            timeout: diff.timeout,
+            newMessages: (diff.messages ?? [])
+                .map(summarizeMessageForUpdates)
+                .filter((m) => m !== null),
+            otherUpdates: [],
+            fallback: {
+                kind: "tooLong",
+                suggestedAction: "channel gap too large — dialog snapshot returned; call telegram-read-messages for full history",
+            },
+        };
+    }
+    if (diff instanceof Api.updates.ChannelDifference) {
+        return {
+            channelId,
+            pts: diff.pts,
+            isFinal: Boolean(diff.final),
+            timeout: diff.timeout,
+            newMessages: (diff.newMessages ?? [])
+                .map(summarizeMessageForUpdates)
+                .filter((m) => m !== null),
+            otherUpdates: (diff.otherUpdates ?? []).map((u) => ({ type: u.className })),
+        };
+    }
+    return {
+        channelId,
+        pts: fallbackPts,
+        isFinal: false,
+        newMessages: [],
+        otherUpdates: [],
+    };
+}
+export function summarizeMyBoost(boost) {
+    const b = boost;
+    return {
+        slot: b.slot,
+        peer: peerToCompact(b.peer),
+        date: b.date,
+        expires: b.expires,
+        cooldownUntilDate: b.cooldownUntilDate,
+    };
+}
+export function summarizeMyBoosts(result) {
+    const boosts = result.myBoosts ?? [];
+    return {
+        count: boosts.length,
+        myBoosts: boosts.map(summarizeMyBoost),
+    };
+}
+export function summarizePrepaidGiveaway(g) {
+    if (g instanceof Api.PrepaidStarsGiveaway) {
+        return {
+            kind: "stars",
+            id: g.id.toString(),
+            quantity: g.quantity,
+            date: g.date,
+            stars: g.stars.toString(),
+            boosts: g.boosts,
+        };
+    }
+    const p = g;
+    return {
+        kind: "premium",
+        id: p.id.toString(),
+        quantity: p.quantity,
+        date: p.date,
+        months: p.months,
+    };
+}
+export function summarizeBoostsStatus(result) {
+    const r = result;
+    const out = {
+        level: r.level,
+        boosts: r.boosts,
+        currentLevelBoosts: r.currentLevelBoosts,
+        nextLevelBoosts: r.nextLevelBoosts,
+        giftBoosts: r.giftBoosts,
+        boostUrl: r.boostUrl,
+        myBoost: r.myBoost,
+        myBoostSlots: r.myBoostSlots,
+    };
+    if (r.premiumAudience) {
+        out.premiumAudience = { part: r.premiumAudience.part, total: r.premiumAudience.total };
+    }
+    if (r.prepaidGiveaways && r.prepaidGiveaways.length > 0) {
+        out.prepaidGiveaways = r.prepaidGiveaways.map(summarizePrepaidGiveaway);
+    }
+    return out;
+}
+export function summarizeBoost(boost) {
+    const b = boost;
+    return {
+        id: b.id,
+        userId: b.userId?.toString(),
+        date: b.date,
+        expires: b.expires,
+        gift: b.gift,
+        giveaway: b.giveaway,
+        unclaimed: b.unclaimed,
+        giveawayMsgId: b.giveawayMsgId,
+        usedGiftSlug: b.usedGiftSlug,
+        multiplier: b.multiplier,
+        stars: b.stars?.toString(),
+    };
+}
+export function summarizeBoostsList(result) {
+    const r = result;
+    return {
+        count: r.count,
+        boosts: (r.boosts ?? []).map(summarizeBoost),
+        nextOffset: r.nextOffset,
+    };
+}
+export function summarizeBusinessChatLink(link) {
+    const l = link;
+    return {
+        link: l.link,
+        message: l.message,
+        title: l.title,
+        views: l.views,
+        entityCount: l.entities?.length ?? 0,
+    };
+}
+export function summarizeBusinessChatLinks(result) {
+    const r = result;
+    const links = r.links ?? [];
+    return {
+        count: links.length,
+        links: links.map(summarizeBusinessChatLink),
+    };
+}
+export function summarizeGroupCallInfo(call) {
+    if (call instanceof Api.GroupCallDiscarded) {
+        return {
+            kind: "discarded",
+            id: call.id.toString(),
+            accessHash: call.accessHash.toString(),
+            duration: call.duration,
+        };
+    }
+    const c = call;
+    return {
+        kind: "active",
+        id: c.id.toString(),
+        accessHash: c.accessHash.toString(),
+        participantsCount: c.participantsCount,
+        title: c.title,
+        scheduleDate: c.scheduleDate,
+        recordStartDate: c.recordStartDate,
+        streamDcId: c.streamDcId,
+        unmutedVideoCount: c.unmutedVideoCount,
+        unmutedVideoLimit: c.unmutedVideoLimit,
+        version: c.version,
+        joinMuted: c.joinMuted,
+        canChangeJoinMuted: c.canChangeJoinMuted,
+        joinDateAsc: c.joinDateAsc,
+        scheduleStartSubscribed: c.scheduleStartSubscribed,
+        canStartVideo: c.canStartVideo,
+        recordVideoActive: c.recordVideoActive,
+        rtmpStream: c.rtmpStream,
+        listenersHidden: c.listenersHidden,
+    };
+}
+export function summarizeGroupCallParticipant(p) {
+    const gp = p;
+    return {
+        peer: peerToCompact(gp.peer),
+        date: gp.date,
+        activeDate: gp.activeDate,
+        source: gp.source,
+        volume: gp.volume,
+        muted: gp.muted,
+        left: gp.left,
+        canSelfUnmute: gp.canSelfUnmute,
+        justJoined: gp.justJoined,
+        self: gp.self,
+        mutedByYou: gp.mutedByYou,
+        volumeByAdmin: gp.volumeByAdmin,
+        videoJoined: gp.videoJoined,
+        about: gp.about,
+        raiseHandRating: gp.raiseHandRating?.toString(),
+        hasVideo: gp.video ? true : undefined,
+        hasPresentation: gp.presentation ? true : undefined,
+    };
+}
+export function summarizeGroupCall(result) {
+    const r = result;
+    return {
+        call: summarizeGroupCallInfo(r.call),
+        participants: (r.participants ?? []).map(summarizeGroupCallParticipant),
+        participantsNextOffset: r.participantsNextOffset || undefined,
+    };
+}
+export function summarizeGroupCallParticipants(result) {
+    const r = result;
+    return {
+        count: r.count,
+        participants: (r.participants ?? []).map(summarizeGroupCallParticipant),
+        nextOffset: r.nextOffset || undefined,
+        version: r.version,
+    };
+}
+export function summarizeStarsAmount(amount) {
+    const a = amount;
+    return { amount: a.amount.toString(), nanos: a.nanos };
+}
+export function summarizeStarsTransactionPeer(peer) {
+    if (peer instanceof Api.StarsTransactionPeerAppStore)
+        return { kind: "appStore" };
+    if (peer instanceof Api.StarsTransactionPeerPlayMarket)
+        return { kind: "playMarket" };
+    if (peer instanceof Api.StarsTransactionPeerPremiumBot)
+        return { kind: "premiumBot" };
+    if (peer instanceof Api.StarsTransactionPeerFragment)
+        return { kind: "fragment" };
+    if (peer instanceof Api.StarsTransactionPeerAds)
+        return { kind: "ads" };
+    if (peer instanceof Api.StarsTransactionPeerAPI)
+        return { kind: "api" };
+    if (peer instanceof Api.StarsTransactionPeer)
+        return { kind: "peer", peer: peerToCompact(peer.peer) };
+    return { kind: "unsupported" };
+}
+export function summarizeStarsTransaction(tx) {
+    const t = tx;
+    return {
+        id: t.id,
+        stars: summarizeStarsAmount(t.stars),
+        date: t.date,
+        peer: summarizeStarsTransactionPeer(t.peer),
+        refund: t.refund,
+        pending: t.pending,
+        failed: t.failed,
+        gift: t.gift,
+        reaction: t.reaction,
+        title: t.title,
+        description: t.description,
+        msgId: t.msgId,
+        subscriptionPeriod: t.subscriptionPeriod,
+        giveawayPostId: t.giveawayPostId,
+        transactionDate: t.transactionDate,
+        transactionUrl: t.transactionUrl,
+    };
+}
+export function summarizeStarsSubscription(sub) {
+    const s = sub;
+    const pricing = s.pricing;
+    return {
+        id: s.id,
+        peer: peerToCompact(s.peer),
+        untilDate: s.untilDate,
+        pricing: { period: pricing.period, amount: pricing.amount.toString() },
+        canceled: s.canceled,
+        canRefulfill: s.canRefulfill,
+        missingBalance: s.missingBalance,
+        botCanceled: s.botCanceled,
+        chatInviteHash: s.chatInviteHash,
+        title: s.title,
+        invoiceSlug: s.invoiceSlug,
+    };
+}
+export function summarizeQuickReply(reply) {
+    const r = reply;
+    return {
+        shortcutId: r.shortcutId,
+        shortcut: r.shortcut,
+        topMessage: r.topMessage,
+        count: r.count,
+    };
+}
+export function summarizeQuickReplies(result) {
+    if (result instanceof Api.messages.QuickRepliesNotModified) {
+        return { notModified: true };
+    }
+    const r = result;
+    return { quickReplies: r.quickReplies.map(summarizeQuickReply) };
+}
+export function summarizeQuickReplyMessage(msg) {
+    if (msg instanceof Api.MessageEmpty)
+        return null;
+    const base = msg;
+    const fromId = peerToCompact(base.fromId);
+    const replyHeader = base.replyTo;
+    const replyToMsgId = replyHeader instanceof Api.MessageReplyHeader ? replyHeader.replyToMsgId : undefined;
+    if (msg instanceof Api.Message) {
+        return {
+            id: msg.id,
+            date: msg.date,
+            text: msg.message ?? "",
+            isService: false,
+            fromId,
+            replyToMsgId,
+        };
+    }
+    if (msg instanceof Api.MessageService) {
+        return {
+            id: msg.id,
+            date: msg.date,
+            text: `[${msg.action?.className ?? "service"}]`,
+            isService: true,
+            fromId,
+        };
+    }
+    return null;
+}
+export function summarizeQuickReplyMessages(result) {
+    if (result instanceof Api.messages.MessagesNotModified) {
+        return { notModified: true, count: result.count };
+    }
+    const rawMessages = result
+        .messages;
+    const messages = rawMessages.map(summarizeQuickReplyMessage).filter((m) => m !== null);
+    const count = result instanceof Api.messages.Messages
+        ? messages.length
+        : result.count;
+    return { count, messages };
+}
+export function summarizeStarsStatus(result) {
+    const r = result;
+    const out = {
+        balance: summarizeStarsAmount(r.balance),
+        subscriptionsNextOffset: r.subscriptionsNextOffset || undefined,
+        subscriptionsMissingBalance: r.subscriptionsMissingBalance?.toString(),
+        nextOffset: r.nextOffset || undefined,
+    };
+    if (r.subscriptions && r.subscriptions.length > 0) {
+        out.subscriptions = r.subscriptions.map(summarizeStarsSubscription);
+    }
+    if (r.history && r.history.length > 0) {
+        out.history = r.history.map(summarizeStarsTransaction);
+    }
+    return out;
+}
+export function summarizeStoryItem(item) {
+    if (item instanceof Api.StoryItemDeleted) {
+        return { id: item.id, kind: "deleted" };
+    }
+    if (item instanceof Api.StoryItemSkipped) {
+        return {
+            id: item.id,
+            kind: "skipped",
+            date: item.date,
+            expireDate: item.expireDate,
+            closeFriends: item.closeFriends,
+        };
+    }
+    const story = item;
+    return {
+        id: story.id,
+        kind: "active",
+        date: story.date,
+        expireDate: story.expireDate,
+        caption: story.caption,
+        mediaType: story.media?.className,
+        pinned: story.pinned,
+        public: story.public,
+        closeFriends: story.closeFriends,
+        edited: story.edited,
+        noforwards: story.noforwards,
+        fromId: peerToCompact(story.fromId),
+        viewsCount: story.views?.viewsCount,
+        reactionsCount: story.views?.reactionsCount,
+    };
+}
+export function summarizePeerStories(ps) {
+    const peer = peerToCompact(ps.peer);
+    if (!peer)
+        return null;
+    return {
+        peer,
+        maxReadId: ps.maxReadId,
+        stories: (ps.stories ?? []).map(summarizeStoryItem),
+    };
+}
+export function summarizeStoriesById(result) {
+    return {
+        count: result.count,
+        stories: (result.stories ?? []).map(summarizeStoryItem),
+        pinnedToTop: result.pinnedToTop,
+    };
+}
+export function summarizeStoryView(view) {
+    if (view instanceof Api.StoryViewPublicForward) {
+        const msg = view.message;
+        const messageId = msg instanceof Api.MessageEmpty ? undefined : msg?.id;
+        const peer = msg instanceof Api.MessageEmpty
+            ? undefined
+            : peerToCompact(msg?.peerId);
+        return {
+            kind: "publicForward",
+            messageId,
+            peer,
+            blocked: view.blocked,
+            blockedMyStoriesFrom: view.blockedMyStoriesFrom,
+        };
+    }
+    if (view instanceof Api.StoryViewPublicRepost) {
+        const story = view.story;
+        return {
+            kind: "publicRepost",
+            peer: peerToCompact(view.peerId),
+            storyId: story?.id,
+            blocked: view.blocked,
+            blockedMyStoriesFrom: view.blockedMyStoriesFrom,
+        };
+    }
+    const v = view;
+    return {
+        kind: "user",
+        userId: v.userId.toString(),
+        date: v.date,
+        reaction: v.reaction ? reactionToEmoji(v.reaction) : undefined,
+        blocked: v.blocked,
+        blockedMyStoriesFrom: v.blockedMyStoriesFrom,
+    };
+}
+export function summarizeStoryViewsList(result) {
+    const list = result;
+    return {
+        count: list.count,
+        viewsCount: list.viewsCount,
+        forwardsCount: list.forwardsCount,
+        reactionsCount: list.reactionsCount,
+        views: (list.views ?? []).map(summarizeStoryView),
+        nextOffset: list.nextOffset,
+    };
+}
+export function summarizeAllStories(result) {
+    const stealthMode = result.stealthMode
+        ? {
+            activeUntilDate: result.stealthMode.activeUntilDate,
+            cooldownUntilDate: result.stealthMode.cooldownUntilDate,
+        }
+        : undefined;
+    if (result instanceof Api.stories.AllStoriesNotModified) {
+        return {
+            modified: false,
+            state: result.state,
+            peerStories: [],
+            stealthMode,
+        };
+    }
+    const all = result;
+    const peerStories = (all.peerStories ?? [])
+        .map(summarizePeerStories)
+        .filter((p) => p !== null);
+    return {
+        modified: true,
+        state: all.state,
+        hasMore: all.hasMore,
+        count: all.count,
+        peerStories,
+        stealthMode,
+    };
+}