lazy-gravity 0.2.0 → 0.3.0

package/dist/platform/discord/wrappers.js

@@ -0,0 +1,331 @@
+"use strict";
+/**
+ * Wrapper functions to convert discord.js types to/from platform types.
+ *
+ * These functions form the boundary between the discord.js library and
+ * the platform-agnostic core. All conversions are pure (no mutation).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDiscordButtonStyle = toDiscordButtonStyle;
+exports.toDiscordPayload = toDiscordPayload;
+exports.wrapDiscordUser = wrapDiscordUser;
+exports.wrapDiscordSentMessage = wrapDiscordSentMessage;
+exports.wrapDiscordChannel = wrapDiscordChannel;
+exports.wrapDiscordMessage = wrapDiscordMessage;
+exports.wrapDiscordButton = wrapDiscordButton;
+exports.wrapDiscordSelect = wrapDiscordSelect;
+exports.wrapDiscordCommand = wrapDiscordCommand;
+const discord_js_1 = require("discord.js");
+// ---------------------------------------------------------------------------
+// Style mapping
+// ---------------------------------------------------------------------------
+const BUTTON_STYLE_MAP = {
+    primary: discord_js_1.ButtonStyle.Primary,
+    secondary: discord_js_1.ButtonStyle.Secondary,
+    success: discord_js_1.ButtonStyle.Success,
+    danger: discord_js_1.ButtonStyle.Danger,
+};
+/** Map a platform ButtonStyle to its discord.js equivalent. */
+function toDiscordButtonStyle(style) {
+    return BUTTON_STYLE_MAP[style];
+}
+// ---------------------------------------------------------------------------
+// Payload conversion
+// ---------------------------------------------------------------------------
+/**
+ * Convert a platform RichContent to a discord.js EmbedBuilder.
+ * Returns a new EmbedBuilder instance.
+ */
+function toDiscordEmbed(rc) {
+    const embed = new discord_js_1.EmbedBuilder();
+    if (rc.title !== undefined) {
+        embed.setTitle(rc.title);
+    }
+    if (rc.description !== undefined) {
+        embed.setDescription(rc.description);
+    }
+    if (rc.color !== undefined) {
+        embed.setColor(rc.color);
+    }
+    if (rc.fields !== undefined) {
+        for (const field of rc.fields) {
+            embed.addFields({ name: field.name, value: field.value, inline: field.inline });
+        }
+    }
+    if (rc.footer !== undefined) {
+        embed.setFooter({ text: rc.footer });
+    }
+    if (rc.timestamp !== undefined) {
+        embed.setTimestamp(rc.timestamp);
+    }
+    if (rc.thumbnailUrl !== undefined) {
+        embed.setThumbnail(rc.thumbnailUrl);
+    }
+    if (rc.imageUrl !== undefined) {
+        embed.setImage(rc.imageUrl);
+    }
+    return embed;
+}
+/**
+ * Convert platform ComponentRow[] to discord.js ActionRowBuilder[].
+ * Each row produces one ActionRowBuilder containing buttons or a select menu.
+ */
+function toDiscordComponents(rows) {
+    return rows.map((row) => {
+        const hasButton = row.components.some((c) => c.type === 'button');
+        const hasSelect = row.components.some((c) => c.type === 'selectMenu');
+        if (hasButton && hasSelect) {
+            throw new Error('Discord does not allow mixing buttons and select menus in the same ActionRow.');
+        }
+        const actionRow = new discord_js_1.ActionRowBuilder();
+        for (const comp of row.components) {
+            if (comp.type === 'button') {
+                const button = new discord_js_1.ButtonBuilder()
+                    .setCustomId(comp.customId)
+                    .setLabel(comp.label)
+                    .setStyle(toDiscordButtonStyle(comp.style));
+                if (comp.disabled === true) {
+                    button.setDisabled(true);
+                }
+                actionRow.addComponents(button);
+            }
+            else if (comp.type === 'selectMenu') {
+                const select = new discord_js_1.StringSelectMenuBuilder()
+                    .setCustomId(comp.customId)
+                    .addOptions(comp.options.map((opt) => ({
+                    label: opt.label,
+                    value: opt.value,
+                    description: opt.description,
+                    default: opt.isDefault,
+                })));
+                if (comp.placeholder !== undefined) {
+                    select.setPlaceholder(comp.placeholder);
+                }
+                actionRow.addComponents(select);
+            }
+        }
+        return actionRow;
+    });
+}
+/**
+ * Convert a platform MessagePayload to discord.js message send/reply options.
+ *
+ * This is the central conversion point used by wrapDiscordChannel.send(),
+ * wrapDiscordMessage.reply(), and interaction reply/update methods.
+ *
+ * @param payload  The platform-agnostic message payload.
+ * @param opts     Conversion options. Only interaction callers should set
+ *                 `allowEphemeral: true`.
+ */
+function toDiscordPayload(payload, opts = {}) {
+    const result = {};
+    if (payload.text !== undefined) {
+        result.content = payload.text;
+    }
+    if (payload.richContent !== undefined) {
+        result.embeds = [toDiscordEmbed(payload.richContent)];
+    }
+    if (payload.components !== undefined && payload.components.length > 0) {
+        result.components = toDiscordComponents(payload.components);
+    }
+    if (payload.files !== undefined && payload.files.length > 0) {
+        result.files = payload.files.map((f) => new discord_js_1.AttachmentBuilder(f.data, { name: f.name }));
+    }
+    if (opts.allowEphemeral === true && payload.ephemeral === true) {
+        result.flags = discord_js_1.MessageFlags.Ephemeral;
+    }
+    return result;
+}
+/** Reusable opts constant for interaction callers that allow ephemeral. */
+const EPHEMERAL_ALLOWED = Object.freeze({ allowEphemeral: true });
+/**
+ * Build a minimal PlatformChannel fallback when `interaction.channel` is null
+ * (e.g. DMs or uncached channels). Uses `interaction.channelId` which is
+ * always available as a string.
+ */
+function buildFallbackChannel(channelId) {
+    return {
+        id: channelId,
+        platform: 'discord',
+        name: undefined,
+        async send() {
+            throw new Error(`Cannot send to channel ${channelId}: channel object is not available (DM or uncached)`);
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Entity wrappers
+// ---------------------------------------------------------------------------
+/** Wrap a discord.js User as a PlatformUser. */
+function wrapDiscordUser(user) {
+    return {
+        id: user.id,
+        platform: 'discord',
+        username: user.username,
+        displayName: user.displayName ?? undefined,
+        isBot: user.bot,
+    };
+}
+/** Wrap a discord.js Message as a PlatformSentMessage (for edit/delete). */
+function wrapDiscordSentMessage(msg) {
+    return {
+        id: msg.id,
+        platform: 'discord',
+        channelId: msg.channelId,
+        async edit(payload) {
+            const edited = await msg.edit(toDiscordPayload(payload));
+            return wrapDiscordSentMessage(edited);
+        },
+        async delete() {
+            await msg.delete();
+        },
+    };
+}
+/** Wrap a discord.js TextChannel (or any channel with send()) as a PlatformChannel. */
+function wrapDiscordChannel(channel) {
+    return {
+        id: channel.id,
+        platform: 'discord',
+        name: 'name' in channel ? channel.name : undefined,
+        async send(payload) {
+            const sent = await channel.send(toDiscordPayload(payload));
+            return wrapDiscordSentMessage(sent);
+        },
+    };
+}
+/** Convert discord.js message attachments to PlatformAttachment[]. */
+function toAttachments(msg) {
+    return [...msg.attachments.values()].map((a) => ({
+        name: a.name,
+        contentType: a.contentType,
+        url: a.url,
+        size: a.size,
+    }));
+}
+/** Wrap a discord.js Message as a PlatformMessage. */
+function wrapDiscordMessage(message) {
+    const author = wrapDiscordUser(message.author);
+    const channel = wrapDiscordChannel(message.channel);
+    const attachments = toAttachments(message);
+    return {
+        id: message.id,
+        platform: 'discord',
+        content: message.content,
+        author,
+        channel,
+        attachments,
+        createdAt: message.createdAt,
+        async react(emoji) {
+            await message.react(emoji);
+        },
+        async reply(payload) {
+            const sent = await message.reply(toDiscordPayload(payload));
+            return wrapDiscordSentMessage(sent);
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Interaction wrappers
+// ---------------------------------------------------------------------------
+/** Wrap a discord.js ButtonInteraction as a PlatformButtonInteraction. */
+function wrapDiscordButton(interaction) {
+    const user = wrapDiscordUser(interaction.user);
+    const channel = interaction.channel
+        ? wrapDiscordChannel(interaction.channel)
+        : buildFallbackChannel(interaction.channelId);
+    return {
+        id: interaction.id,
+        platform: 'discord',
+        customId: interaction.customId,
+        user,
+        channel,
+        messageId: interaction.message.id,
+        async deferUpdate() {
+            await interaction.deferUpdate();
+        },
+        async reply(payload) {
+            await interaction.reply(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+        },
+        async update(payload) {
+            await interaction.update(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+        },
+        async editReply(payload) {
+            await interaction.editReply(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+        },
+        async followUp(payload) {
+            const sent = await interaction.followUp(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+            return wrapDiscordSentMessage(sent);
+        },
+    };
+}
+/** Wrap a discord.js StringSelectMenuInteraction as a PlatformSelectInteraction. */
+function wrapDiscordSelect(interaction) {
+    const user = wrapDiscordUser(interaction.user);
+    const channel = interaction.channel
+        ? wrapDiscordChannel(interaction.channel)
+        : buildFallbackChannel(interaction.channelId);
+    return {
+        id: interaction.id,
+        platform: 'discord',
+        customId: interaction.customId,
+        user,
+        channel,
+        values: interaction.values,
+        messageId: interaction.message.id,
+        async deferUpdate() {
+            await interaction.deferUpdate();
+        },
+        async reply(payload) {
+            await interaction.reply(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+        },
+        async update(payload) {
+            await interaction.update(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+        },
+        async editReply(payload) {
+            await interaction.editReply(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+        },
+        async followUp(payload) {
+            const sent = await interaction.followUp(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+            return wrapDiscordSentMessage(sent);
+        },
+    };
+}
+/** Extract command options from a ChatInputCommandInteraction into a ReadonlyMap. */
+function extractCommandOptions(interaction) {
+    const map = new Map();
+    for (const opt of interaction.options.data) {
+        if (opt.value !== undefined && opt.value !== null) {
+            map.set(opt.name, opt.value);
+        }
+    }
+    return map;
+}
+/** Wrap a discord.js ChatInputCommandInteraction as a PlatformCommandInteraction. */
+function wrapDiscordCommand(interaction) {
+    const user = wrapDiscordUser(interaction.user);
+    const channel = interaction.channel
+        ? wrapDiscordChannel(interaction.channel)
+        : buildFallbackChannel(interaction.channelId);
+    const options = extractCommandOptions(interaction);
+    return {
+        id: interaction.id,
+        platform: 'discord',
+        commandName: interaction.commandName,
+        user,
+        channel,
+        options,
+        async deferReply(opts) {
+            await interaction.deferReply({ flags: opts?.ephemeral ? discord_js_1.MessageFlags.Ephemeral : undefined });
+        },
+        async reply(payload) {
+            await interaction.reply(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+        },
+        async editReply(payload) {
+            await interaction.editReply(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+        },
+        async followUp(payload) {
+            const sent = await interaction.followUp(toDiscordPayload(payload, EPHEMERAL_ALLOWED));
+            return wrapDiscordSentMessage(sent);
+        },
+    };
+}

package/dist/platform/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipe = exports.withImage = exports.withThumbnail = exports.withTimestamp = exports.withFooter = exports.withFields = exports.addField = exports.withColor = exports.withDescription = exports.withTitle = exports.createRichContent = exports.fromPlatformKey = exports.toPlatformKey = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "toPlatformKey", { enumerable: true, get: function () { return types_1.toPlatformKey; } });
+Object.defineProperty(exports, "fromPlatformKey", { enumerable: true, get: function () { return types_1.fromPlatformKey; } });
+var richContentBuilder_1 = require("./richContentBuilder");
+Object.defineProperty(exports, "createRichContent", { enumerable: true, get: function () { return richContentBuilder_1.createRichContent; } });
+Object.defineProperty(exports, "withTitle", { enumerable: true, get: function () { return richContentBuilder_1.withTitle; } });
+Object.defineProperty(exports, "withDescription", { enumerable: true, get: function () { return richContentBuilder_1.withDescription; } });
+Object.defineProperty(exports, "withColor", { enumerable: true, get: function () { return richContentBuilder_1.withColor; } });
+Object.defineProperty(exports, "addField", { enumerable: true, get: function () { return richContentBuilder_1.addField; } });
+Object.defineProperty(exports, "withFields", { enumerable: true, get: function () { return richContentBuilder_1.withFields; } });
+Object.defineProperty(exports, "withFooter", { enumerable: true, get: function () { return richContentBuilder_1.withFooter; } });
+Object.defineProperty(exports, "withTimestamp", { enumerable: true, get: function () { return richContentBuilder_1.withTimestamp; } });
+Object.defineProperty(exports, "withThumbnail", { enumerable: true, get: function () { return richContentBuilder_1.withThumbnail; } });
+Object.defineProperty(exports, "withImage", { enumerable: true, get: function () { return richContentBuilder_1.withImage; } });
+Object.defineProperty(exports, "pipe", { enumerable: true, get: function () { return richContentBuilder_1.pipe; } });

package/dist/platform/richContentBuilder.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Immutable builder functions for RichContent.
+ *
+ * All functions return a new object — never mutate the input.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRichContent = createRichContent;
+exports.withTitle = withTitle;
+exports.withDescription = withDescription;
+exports.withColor = withColor;
+exports.addField = addField;
+exports.withFields = withFields;
+exports.withFooter = withFooter;
+exports.withTimestamp = withTimestamp;
+exports.withThumbnail = withThumbnail;
+exports.withImage = withImage;
+exports.pipe = pipe;
+/** Create an empty RichContent. */
+function createRichContent() {
+    return {};
+}
+/** Set the title. */
+function withTitle(rc, title) {
+    return { ...rc, title };
+}
+/** Set the description. */
+function withDescription(rc, description) {
+    return { ...rc, description };
+}
+/** Set the color (numeric, e.g. 0x5865F2). */
+function withColor(rc, color) {
+    return { ...rc, color };
+}
+/** Add a field. Existing fields are preserved. */
+function addField(rc, name, value, inline) {
+    const field = { name, value, inline };
+    const fields = rc.fields ? [...rc.fields, field] : [field];
+    return { ...rc, fields };
+}
+/** Replace all fields at once. */
+function withFields(rc, fields) {
+    return { ...rc, fields: fields.map((field) => ({ ...field })) };
+}
+/** Set the footer text. */
+function withFooter(rc, footer) {
+    return { ...rc, footer };
+}
+/** Set the timestamp. */
+function withTimestamp(rc, timestamp) {
+    return { ...rc, timestamp: timestamp ?? new Date() };
+}
+/** Set the thumbnail URL. */
+function withThumbnail(rc, thumbnailUrl) {
+    return { ...rc, thumbnailUrl };
+}
+/** Set the image URL. */
+function withImage(rc, imageUrl) {
+    return { ...rc, imageUrl };
+}
+// ---------------------------------------------------------------------------
+// Convenience: fluent-style chain helper
+// ---------------------------------------------------------------------------
+/**
+ * Apply a sequence of transforms to a RichContent.
+ * Each transform is a function `(rc: RichContent) => RichContent`.
+ * Usage:
+ *   pipe(
+ *     createRichContent(),
+ *     (rc) => withTitle(rc, 'Hello'),
+ *     (rc) => withColor(rc, 0x00FF00),
+ *   )
+ */
+function pipe(initial, ...transforms) {
+    return transforms.reduce((acc, fn) => fn(acc), initial);
+}

package/dist/platform/telegram/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTelegramPayload = exports.wrapTelegramSentMessage = exports.wrapTelegramCallbackQuery = exports.wrapTelegramMessage = exports.wrapTelegramChannel = exports.wrapTelegramUser = exports.richContentToHtml = exports.markdownToTelegramHtml = exports.escapeHtml = exports.TelegramAdapter = void 0;
+var telegramAdapter_1 = require("./telegramAdapter");
+Object.defineProperty(exports, "TelegramAdapter", { enumerable: true, get: function () { return telegramAdapter_1.TelegramAdapter; } });
+var telegramFormatter_1 = require("./telegramFormatter");
+Object.defineProperty(exports, "escapeHtml", { enumerable: true, get: function () { return telegramFormatter_1.escapeHtml; } });
+Object.defineProperty(exports, "markdownToTelegramHtml", { enumerable: true, get: function () { return telegramFormatter_1.markdownToTelegramHtml; } });
+Object.defineProperty(exports, "richContentToHtml", { enumerable: true, get: function () { return telegramFormatter_1.richContentToHtml; } });
+var wrappers_1 = require("./wrappers");
+Object.defineProperty(exports, "wrapTelegramUser", { enumerable: true, get: function () { return wrappers_1.wrapTelegramUser; } });
+Object.defineProperty(exports, "wrapTelegramChannel", { enumerable: true, get: function () { return wrappers_1.wrapTelegramChannel; } });
+Object.defineProperty(exports, "wrapTelegramMessage", { enumerable: true, get: function () { return wrappers_1.wrapTelegramMessage; } });
+Object.defineProperty(exports, "wrapTelegramCallbackQuery", { enumerable: true, get: function () { return wrappers_1.wrapTelegramCallbackQuery; } });
+Object.defineProperty(exports, "wrapTelegramSentMessage", { enumerable: true, get: function () { return wrappers_1.wrapTelegramSentMessage; } });
+Object.defineProperty(exports, "toTelegramPayload", { enumerable: true, get: function () { return wrappers_1.toTelegramPayload; } });

package/dist/platform/telegram/telegramAdapter.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * Telegram platform adapter.
+ *
+ * Implements the PlatformAdapter interface using a TelegramBotLike instance.
+ * This adapter translates Telegram events to the platform-agnostic event model
+ * so the bot core can operate without platform-specific knowledge.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelegramAdapter = void 0;
+const wrappers_1 = require("./wrappers");
+const logger_1 = require("../../utils/logger");
+// ---------------------------------------------------------------------------
+// TelegramAdapter
+// ---------------------------------------------------------------------------
+class TelegramAdapter {
+    platform = 'telegram';
+    bot;
+    botUserId;
+    events = null;
+    started = false;
+    handlersRegistered = false;
+    /** Timestamp when the adapter started — messages older than this are discarded. */
+    startedAt = 0;
+    constructor(bot, botUserId) {
+        this.bot = bot;
+        this.botUserId = botUserId;
+    }
+    /**
+     * Start the adapter.
+     *
+     * Registers Telegram event handlers that translate incoming events to the
+     * platform-agnostic event callbacks, then starts the bot polling loop.
+     */
+    async start(events) {
+        if (this.started) {
+            throw new Error('TelegramAdapter is already started');
+        }
+        this.events = events;
+        // Round down to whole seconds to match Telegram's second-precision timestamps
+        this.startedAt = Math.floor(Date.now() / 1000) * 1000;
+        if (!this.handlersRegistered) {
+            this.registerHandlers();
+            this.handlersRegistered = true;
+        }
+        // bot.start() returns a Promise that resolves when polling stops.
+        // We intentionally do NOT await it (would block forever).
+        // Catch errors to prevent unhandled promise rejections (e.g. getMe()
+        // failure inside grammY's init phase).
+        const startPromise = this.bot.start();
+        if (startPromise && typeof startPromise.catch === 'function') {
+            startPromise.catch((err) => {
+                logger_1.logger.error('[TelegramAdapter] Polling loop error:', err instanceof Error ? err.message : err);
+                this.emitError(err);
+            });
+        }
+        this.started = true;
+        if (this.events.onReady) {
+            this.events.onReady();
+        }
+    }
+    /**
+     * Stop the adapter (disconnect, cleanup).
+     */
+    async stop() {
+        if (!this.started)
+            return;
+        this.bot.stop();
+        this.started = false;
+        this.events = null;
+    }
+    /**
+     * Retrieve a channel (chat) by its platform-native ID.
+     * Returns a PlatformChannel backed by the bot API.
+     */
+    async getChannel(chatId) {
+        try {
+            const chat = await this.bot.api.getChat(chatId);
+            if (!chat)
+                return null;
+            const channel = (0, wrappers_1.wrapTelegramChannel)(this.bot.api, chatId, this.bot.toInputFile);
+            // Enrich with name from the fetched chat data
+            return {
+                ...channel,
+                name: chat.title ?? chat.first_name ?? undefined,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Return the bot's own user ID.
+     */
+    getBotUserId() {
+        return this.botUserId;
+    }
+    // -----------------------------------------------------------------------
+    // Private helpers
+    // -----------------------------------------------------------------------
+    /**
+     * Shared handler for both text and photo messages.
+     * Wraps the Telegram message and fires onMessage.
+     */
+    handleIncomingMessage(eventName, ctx) {
+        if (!this.events?.onMessage)
+            return;
+        try {
+            const msg = ctx.message ?? ctx.msg;
+            if (!msg)
+                return;
+            const msgTimestampMs = msg.date ? msg.date * 1000 : 0;
+            const delayMs = msgTimestampMs ? Date.now() - msgTimestampMs : null;
+            logger_1.logger.debug(`[TelegramAdapter] ${eventName} received (chat=${msg.chat.id}, delay=${delayMs !== null ? `${delayMs}ms` : 'unknown'})`);
+            // Discard messages sent before the adapter started (stale backlog)
+            if (msgTimestampMs && msgTimestampMs < this.startedAt) {
+                logger_1.logger.info(`[TelegramAdapter] Ignoring stale message (chat=${msg.chat.id}, age=${Math.round((this.startedAt - msgTimestampMs) / 1000)}s before startup)`);
+                return;
+            }
+            const platformMessage = (0, wrappers_1.wrapTelegramMessage)(msg, this.bot.api, this.bot.toInputFile, this.bot.token);
+            // Fire-and-forget: do NOT await so grammY's update loop stays
+            // unblocked. This allows /stop and other commands to be received
+            // while a long-running response is being monitored.
+            // The workspace queue in telegramMessageHandler serializes
+            // actual prompt processing per workspace.
+            this.events.onMessage(platformMessage).catch((error) => {
+                this.emitError(error);
+            });
+        }
+        catch (error) {
+            this.emitError(error);
+        }
+    }
+    registerHandlers() {
+        // Text messages
+        this.bot.on('message:text', async (ctx) => {
+            this.handleIncomingMessage('message:text', ctx);
+        });
+        // Photo messages
+        this.bot.on('message:photo', async (ctx) => {
+            this.handleIncomingMessage('message:photo', ctx);
+        });
+        // Callback queries (button presses and select menu selections)
+        this.bot.on('callback_query:data', async (ctx) => {
+            if (!this.events?.onButtonInteraction && !this.events?.onSelectInteraction)
+                return;
+            try {
+                const query = ctx.callbackQuery;
+                if (!query)
+                    return;
+                const interaction = (0, wrappers_1.wrapTelegramCallbackQuery)(query, this.bot.api);
+                // Select menu callbacks use \x1F (Unit Separator) between
+                // customId and value. Regular button customIds never contain
+                // \x1F, so this cleanly distinguishes the two.
+                const sepIdx = (query.data ?? '').indexOf(wrappers_1.SELECT_CALLBACK_SEP);
+                if (sepIdx > 0 && this.events.onSelectInteraction) {
+                    const selectCustomId = (query.data ?? '').slice(0, sepIdx);
+                    const selectedValue = (query.data ?? '').slice(sepIdx + 1);
+                    await this.events.onSelectInteraction({
+                        id: query.id,
+                        platform: 'telegram',
+                        customId: selectCustomId,
+                        user: interaction.user,
+                        channel: interaction.channel,
+                        values: [selectedValue],
+                        messageId: interaction.messageId,
+                        deferUpdate: interaction.deferUpdate,
+                        reply: interaction.reply,
+                        update: interaction.update,
+                        editReply: interaction.editReply,
+                        followUp: interaction.followUp,
+                    });
+                    return;
+                }
+                if (this.events.onButtonInteraction) {
+                    await this.events.onButtonInteraction(interaction);
+                }
+            }
+            catch (error) {
+                this.emitError(error);
+            }
+        });
+    }
+    emitError(error) {
+        if (!this.events?.onError)
+            return;
+        if (error instanceof Error) {
+            this.events.onError(error);
+        }
+        else {
+            this.events.onError(new Error(String(error)));
+        }
+    }
+}
+exports.TelegramAdapter = TelegramAdapter;