@acp-router/adapter-telegram 0.1.0

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './telegram-adapter.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAA"}

package/lib/index.js

@@ -0,0 +1 @@
+export * from './telegram-adapter.js';

package/lib/markdown.d.ts

@@ -0,0 +1,2 @@
+export declare function markdownToTelegramHtml(markdown: string): string;
+//# sourceMappingURL=markdown.d.ts.map

package/lib/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../src/markdown.ts"],"names":[],"mappings":"AAwKA,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE/D"}

package/lib/markdown.js

@@ -0,0 +1,146 @@
+import MarkdownIt from 'markdown-it';
+function escapeHtml(str) {
+    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function createTelegramRenderer() {
+    const md = new MarkdownIt({ linkify: true });
+    const { rules } = md.renderer;
+    let listStack = [];
+    let blockquoteDepth = 0;
+    rules.text = (tokens, idx) => escapeHtml(tokens[idx].content);
+    rules.strong_open = () => '<b>';
+    rules.strong_close = () => '</b>';
+    rules.em_open = () => '<i>';
+    rules.em_close = () => '</i>';
+    rules.s_open = () => '<s>';
+    rules.s_close = () => '</s>';
+    rules.code_inline = (tokens, idx) => `<code>${escapeHtml(tokens[idx].content)}</code>`;
+    rules.fence = (tokens, idx) => {
+        const token = tokens[idx];
+        const lang = token.info.trim();
+        const code = escapeHtml(token.content);
+        if (lang) {
+            return `<pre><code class="language-${escapeHtml(lang)}">${code}</code></pre>\n`;
+        }
+        return `<pre><code>${code}</code></pre>\n`;
+    };
+    rules.code_block = (tokens, idx) => {
+        return `<pre><code>${escapeHtml(tokens[idx].content)}</code></pre>\n`;
+    };
+    rules.heading_open = (tokens, idx) => {
+        const level = Number(tokens[idx].tag.slice(1));
+        if (level <= 2)
+            return '<b>';
+        return '<b>';
+    };
+    rules.heading_close = () => '</b>\n';
+    rules.paragraph_open = () => '';
+    rules.paragraph_close = (_tokens, _idx, _options, env) => {
+        if (env._inListItem)
+            return '';
+        if (blockquoteDepth > 0)
+            return '\n';
+        return '\n\n';
+    };
+    rules.blockquote_open = () => {
+        blockquoteDepth++;
+        return '<blockquote>';
+    };
+    rules.blockquote_close = () => {
+        blockquoteDepth--;
+        return '</blockquote>\n';
+    };
+    rules.bullet_list_open = () => {
+        const nested = listStack.length > 0;
+        listStack.push({ ordered: false, index: 0 });
+        return nested ? '\n' : '';
+    };
+    rules.bullet_list_close = () => {
+        listStack.pop();
+        return listStack.length > 0 ? '' : '\n';
+    };
+    rules.ordered_list_open = (tokens, idx) => {
+        const nested = listStack.length > 0;
+        const start = Number(tokens[idx].attrGet('start') ?? 1);
+        listStack.push({ ordered: true, index: start });
+        return nested ? '\n' : '';
+    };
+    rules.ordered_list_close = () => {
+        listStack.pop();
+        return listStack.length > 0 ? '' : '\n';
+    };
+    rules.list_item_open = (_tokens, _idx, _options, env) => {
+        env._inListItem = (env._inListItem ?? 0) + 1;
+        const ctx = listStack[listStack.length - 1];
+        if (!ctx)
+            return '• ';
+        const indent = '  '.repeat(listStack.length - 1);
+        if (ctx.ordered) {
+            const num = ctx.index;
+            ctx.index++;
+            return `${indent}${num}. `;
+        }
+        return `${indent}• `;
+    };
+    rules.list_item_close = (_tokens, _idx, _options, env) => {
+        env._inListItem = Math.max(0, (env._inListItem ?? 1) - 1);
+        return '\n';
+    };
+    rules.link_open = (tokens, idx) => {
+        const href = tokens[idx].attrGet('href') ?? '';
+        return `<a href="${escapeHtml(href)}">`;
+    };
+    rules.link_close = () => '</a>';
+    rules.image = (tokens, idx) => {
+        const token = tokens[idx];
+        const src = token.attrGet('src') ?? '';
+        const alt = token.content || token.attrGet('alt') || 'image';
+        return `<a href="${escapeHtml(src)}">${escapeHtml(alt)}</a>`;
+    };
+    rules.table_open = () => '<pre>';
+    rules.table_close = () => '</pre>\n';
+    rules.thead_open = () => '';
+    rules.thead_close = () => '';
+    rules.tbody_open = () => '';
+    rules.tbody_close = () => '';
+    rules.tr_open = () => '';
+    rules.tr_close = () => '\n';
+    rules.th_open = () => '';
+    rules.th_close = () => ' | ';
+    rules.td_open = () => '';
+    rules.td_close = () => ' | ';
+    rules.hr = () => '———\n';
+    rules.softbreak = () => '\n';
+    rules.hardbreak = () => '\n';
+    rules.html_block = (tokens, idx) => escapeHtml(tokens[idx].content);
+    rules.html_inline = (tokens, idx) => escapeHtml(tokens[idx].content);
+    // Store original renderToken for fallback on unknown open/close tokens
+    const originalRenderToken = md.renderer.renderToken.bind(md.renderer);
+    md.renderer.renderToken = function (tokens, idx, options) {
+        const token = tokens[idx];
+        // Suppress tags we don't explicitly handle (e.g. <p>, <ul>, <ol>, <li>, <table>)
+        // Open/close tokens for known container types are handled by rules above
+        const suppressed = new Set([
+            'p', 'ul', 'ol', 'li', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+            'blockquote', 'table', 'thead', 'tbody', 'tr', 'th', 'td', 'hr',
+            'dl', 'dt', 'dd'
+        ]);
+        if (suppressed.has(token.tag))
+            return '';
+        return originalRenderToken(tokens, idx, options);
+    };
+    // Reset state before each render
+    const originalRender = md.render.bind(md);
+    md.render = (src, env) => {
+        listStack = [];
+        blockquoteDepth = 0;
+        const result = originalRender(src, env ?? {});
+        // Clean up excessive blank lines
+        return result.replace(/\n{3,}/g, '\n\n').trim();
+    };
+    return md;
+}
+const renderer = createTelegramRenderer();
+export function markdownToTelegramHtml(markdown) {
+    return renderer.render(markdown);
+}

package/lib/telegram-adapter.d.ts

@@ -0,0 +1,31 @@
+import { IMAdapter, type AdapterInteraction, type InlineMessage, type InlineUpdate, type InteractiveMessageKind, type TextMessageKind } from '@acp-router/core';
+export declare class TelegramAdapter extends IMAdapter {
+    private token;
+    private allowList;
+    readonly platform = "telegram";
+    private bot;
+    private actionHandlers;
+    private fallbackActions;
+    private sendQueues;
+    private typingTimers;
+    constructor(token: string, allowList: number[]);
+    private enqueue;
+    init(): Promise<void>;
+    sendTextMessage(chatId: string, text: string, kind?: TextMessageKind): Promise<void>;
+    sendMedia(chatId: string, payload: {
+        kind: string;
+        mimeType: string;
+        data: Uint8Array;
+        filename?: string;
+    }): Promise<void>;
+    setCommands(commands: {
+        name: string;
+        description: string;
+    }[]): Promise<void>;
+    sendInteractiveMessage(chatId: string, message: InlineMessage, kind?: InteractiveMessageKind): Promise<AdapterInteraction>;
+    editInteractiveMessage(chatId: string, messageId: string, update: InlineUpdate): Promise<void>;
+    setActive(chatId: string, active: boolean): Promise<void>;
+    setReaction(chatId: string, messageId: string, kind: 'queued' | 'aborted' | 'ignored' | undefined): Promise<void>;
+    private refreshActions;
+}
+//# sourceMappingURL=telegram-adapter.d.ts.map

package/lib/telegram-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram-adapter.d.ts","sourceRoot":"","sources":["../src/telegram-adapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAU,KAAK,kBAAkB,EAAsB,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,sBAAsB,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAG3L,qBAAa,eAAgB,SAAQ,SAAS;IAQhC,OAAO,CAAC,KAAK;IAAU,OAAO,CAAC,SAAS;IAPpD,QAAQ,CAAC,QAAQ,cAAa;IAC9B,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,cAAc,CAAyD;IAC/E,OAAO,CAAC,eAAe,CAAyD;IAChF,OAAO,CAAC,UAAU,CAAmC;IACrD,OAAO,CAAC,YAAY,CAAoD;gBAEpD,KAAK,EAAE,MAAM,EAAU,SAAS,EAAE,MAAM,EAAE;IAK9D,OAAO,CAAC,OAAO;IAOT,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAgDrB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,eAA2B,GAAG,OAAO,CAAC,IAAI,CAAC;IAiC/F,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,UAAU,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAoB1H,WAAW,CAAC,QAAQ,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAK7E,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,IAAI,GAAE,sBAAkC,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAkCrI,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAqC9F,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBzD,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBvH,OAAO,CAAC,cAAc;CAuBvB"}

package/lib/telegram-adapter.js

@@ -0,0 +1,277 @@
+import { Bot, InlineKeyboard, InputFile } from 'grammy';
+import { IMAdapter, logger } from '@acp-router/core';
+import { markdownToTelegramHtml } from './markdown.js';
+export class TelegramAdapter extends IMAdapter {
+    token;
+    allowList;
+    platform = 'telegram';
+    bot;
+    actionHandlers = new Map();
+    fallbackActions = new Map();
+    sendQueues = new Map();
+    typingTimers = new Map();
+    constructor(token, allowList) {
+        super();
+        this.token = token;
+        this.allowList = allowList;
+        this.bot = new Bot(token);
+    }
+    enqueue(chatId, fn) {
+        const prev = this.sendQueues.get(chatId) ?? Promise.resolve();
+        const next = prev.then(fn, fn);
+        this.sendQueues.set(chatId, next.then(() => { }, () => { }));
+        return next;
+    }
+    async init() {
+        logger.debug('Initializing Telegram adapter');
+        this.bot.use(async (ctx, next) => {
+            const chatId = ctx.chat?.id;
+            const chatType = ctx.chat?.type;
+            logger.debug({ chatId, chatType, hasMessage: !!ctx.message, hasCallback: !!ctx.callbackQuery }, 'Incoming update');
+            if (!chatId || !this.allowList.includes(chatId)) {
+                logger.debug({ chatId }, 'Chat not in allow list, ignoring');
+                return;
+            }
+            if (chatType !== 'private') {
+                logger.debug({ chatId, chatType }, 'Non-private chat, ignoring');
+                return;
+            }
+            await next();
+        });
+        this.bot.on('message:text', async (ctx) => {
+            const text = ctx.message.text;
+            const chatId = String(ctx.chat.id);
+            if (text.startsWith('/')) {
+                logger.debug({ chatId, text }, 'Received command message');
+                const parts = text.slice(1).trim().split(' ');
+                const command = parts[0];
+                const args = parts.slice(1).filter(Boolean);
+                logger.debug({ chatId, command, args }, 'Dispatching command');
+                await this.emit('command', chatId, String(ctx.message.message_id), command, args);
+            }
+            else {
+                logger.debug({ chatId, textLength: text.length }, 'Received text message');
+                await this.emit('text', chatId, String(ctx.message.message_id), text);
+            }
+        });
+        this.bot.on('callback_query:data', async (ctx) => {
+            const data = ctx.callbackQuery?.data;
+            if (!data)
+                return;
+            logger.debug({ data }, 'Received callback query');
+            const handler = this.actionHandlers.get(data) ?? this.fallbackActions.get(data);
+            if (!handler) {
+                logger.debug({ data }, 'No handler found for callback query');
+                return;
+            }
+            await handler(data);
+            await ctx.answerCallbackQuery().catch(() => { });
+        });
+        this.bot.catch((err) => logger.error({ err }, 'Telegram adapter error'));
+        this.bot.start();
+        logger.debug('Telegram bot polling started');
+    }
+    async sendTextMessage(chatId, text, kind = 'message') {
+        return this.enqueue(chatId, async () => {
+            logger.debug({ chatId, textLength: text.length, kind }, 'Sending message');
+            if (kind === 'thought') {
+                try {
+                    const innerHtml = markdownToTelegramHtml(text);
+                    const html = `<blockquote expandable>\u{1F4AD} <b>Thinking</b>\n\n${innerHtml}</blockquote>`;
+                    await this.bot.api.sendMessage(Number(chatId), html, { parse_mode: 'HTML' });
+                }
+                catch (err) {
+                    logger.warn({ chatId, err }, 'Failed to send thought as expandable blockquote, falling back');
+                    try {
+                        const html = markdownToTelegramHtml(`> **Thinking**\n>\n> ${text.replace(/\n/g, '\n> ')}`);
+                        await this.bot.api.sendMessage(Number(chatId), html, { parse_mode: 'HTML' });
+                    }
+                    catch {
+                        await this.bot.api.sendMessage(Number(chatId), `\u{1F4AD} Thinking\n\n${text}`).catch((err2) => {
+                            logger.warn({ chatId, err: err2 }, 'Failed to send thought fallback');
+                        });
+                    }
+                }
+            }
+            else {
+                try {
+                    const html = markdownToTelegramHtml(text);
+                    await this.bot.api.sendMessage(Number(chatId), html, { parse_mode: 'HTML' });
+                }
+                catch (err) {
+                    logger.warn({ chatId, err }, 'Failed to send as HTML, falling back to plain text');
+                    await this.bot.api.sendMessage(Number(chatId), text).catch((err2) => {
+                        logger.warn({ chatId, err: err2 }, 'Failed to send plain text fallback');
+                    });
+                }
+            }
+        });
+    }
+    async sendMedia(chatId, payload) {
+        return this.enqueue(chatId, async () => {
+            logger.debug({ chatId, kind: payload.kind, mimeType: payload.mimeType, size: payload.data.length }, 'Sending media');
+            const file = new InputFile(Buffer.from(payload.data), payload.filename ?? `file.${extFromMime(payload.mimeType)}`);
+            if (payload.kind === 'image') {
+                await this.bot.api.sendPhoto(Number(chatId), file).catch((err) => logger.warn({ chatId, err }, 'Failed to send photo'));
+                return;
+            }
+            if (payload.kind === 'audio') {
+                await this.bot.api.sendAudio(Number(chatId), file).catch((err) => logger.warn({ chatId, err }, 'Failed to send audio'));
+                return;
+            }
+            if (payload.kind === 'video') {
+                await this.bot.api.sendVideo(Number(chatId), file).catch((err) => logger.warn({ chatId, err }, 'Failed to send video'));
+                return;
+            }
+            await this.bot.api.sendDocument(Number(chatId), file).catch((err) => logger.warn({ chatId, err }, 'Failed to send document'));
+        });
+    }
+    async setCommands(commands) {
+        await this.bot.api.setMyCommands(commands.map((cmd) => ({ command: cmd.name, description: cmd.description }))).catch(() => { });
+        logger.debug({ count: commands.length }, 'Telegram commands updated');
+    }
+    async sendInteractiveMessage(chatId, message, kind = 'generic') {
+        return this.enqueue(chatId, async () => {
+            logger.debug({ chatId, actionsCount: message.actions?.items.length ?? 0 }, 'Sending interactive message');
+            const kb = message.actions ? toKeyboard(message.actions) : undefined;
+            let html;
+            try {
+                html = markdownToTelegramHtml(message.markdown);
+            }
+            catch {
+                html = message.markdown;
+            }
+            const sent = await this.bot.api
+                .sendMessage(Number(chatId), html, { parse_mode: 'HTML', reply_markup: kb })
+                .catch((err) => {
+                logger.warn({ chatId, err }, 'Failed to send interactive message');
+                return null;
+            });
+            if (message.actions) {
+                for (const action of message.actions.items) {
+                    this.actionHandlers.set(action.id, async (actionId) => {
+                        await message.actions?.callback(actionId);
+                    });
+                }
+                if (!sent) {
+                    for (const action of message.actions.items) {
+                        this.fallbackActions.set(action.id, async (actionId) => {
+                            await message.actions?.callback(actionId);
+                        });
+                    }
+                }
+            }
+            return { id: sent ? String(sent.message_id) : `temp-${Date.now()}`, message };
+        });
+    }
+    async editInteractiveMessage(chatId, messageId, update) {
+        return this.enqueue(chatId, async () => {
+            logger.debug({ chatId, messageId, hasMarkdown: update.markdown != null, hasActions: 'actions' in update }, 'Updating interactive message');
+            const nextActions = 'actions' in update ? update.actions : undefined;
+            const removeKb = 'actions' in update && !update.actions;
+            const kb = nextActions ? toKeyboard(nextActions) : removeKb ? new InlineKeyboard() : undefined;
+            if (update.markdown != null) {
+                let html;
+                try {
+                    html = markdownToTelegramHtml(update.markdown);
+                }
+                catch {
+                    html = update.markdown;
+                }
+                await this.bot.api
+                    .editMessageText(Number(chatId), Number(messageId), html, {
+                    parse_mode: 'HTML',
+                    reply_markup: kb
+                })
+                    .catch((err) => {
+                    logger.warn({ chatId, messageId, err }, 'Failed to edit message text');
+                });
+                this.refreshActions(nextActions);
+                return;
+            }
+            if ('actions' in update) {
+                await this.bot.api
+                    .editMessageReplyMarkup(Number(chatId), Number(messageId), {
+                    reply_markup: kb
+                })
+                    .catch((err) => {
+                    logger.warn({ chatId, messageId, err }, 'Failed to edit message reply markup');
+                });
+                this.refreshActions(nextActions);
+            }
+        });
+    }
+    async setActive(chatId, active) {
+        logger.debug({ chatId, active }, 'Setting chat active state');
+        const existing = this.typingTimers.get(chatId);
+        if (existing) {
+            clearInterval(existing);
+            this.typingTimers.delete(chatId);
+        }
+        if (!active)
+            return;
+        const sendTyping = () => {
+            this.bot.api.sendChatAction(Number(chatId), 'typing').catch((err) => {
+                logger.warn({ chatId, err }, 'Failed to send typing action');
+            });
+        };
+        sendTyping();
+        this.typingTimers.set(chatId, setInterval(sendTyping, 5000));
+    }
+    async setReaction(chatId, messageId, kind) {
+        return this.enqueue(chatId, async () => {
+            logger.debug({ chatId, messageId, kind }, 'Setting reaction');
+            const reaction = kind === 'queued'
+                ? [{ type: 'emoji', emoji: '✍' }]
+                : kind === 'aborted'
+                    ? [{ type: 'emoji', emoji: '🕊' }]
+                    : kind === 'ignored'
+                        ? [{ type: 'emoji', emoji: '🤡' }]
+                        : [];
+            await this.bot.api.setMessageReaction(Number(chatId), Number(messageId), reaction).catch((err) => {
+                logger.warn({ chatId, messageId, kind, err }, 'Failed to set reaction');
+            });
+        });
+    }
+    refreshActions(actions) {
+        if (!actions) {
+            this.actionHandlers.clear();
+            this.fallbackActions.clear();
+            return;
+        }
+        if (actions.items) {
+            this.actionHandlers.clear();
+            for (const action of actions.items) {
+                this.actionHandlers.set(action.id, async (actionId) => {
+                    await actions.callback?.(actionId);
+                });
+            }
+        }
+        if (actions.callback && !actions.items) {
+            for (const [id, handler] of this.actionHandlers) {
+                this.actionHandlers.set(id, async (actionId) => {
+                    await actions.callback?.(actionId);
+                    await handler(actionId);
+                });
+            }
+        }
+    }
+}
+function extFromMime(mime) {
+    const idx = mime.indexOf('/');
+    return idx === -1 ? 'bin' : mime.slice(idx + 1);
+}
+function toKeyboard(actions) {
+    const kb = new InlineKeyboard();
+    const columns = actions.columns ?? 2;
+    let col = 0;
+    for (const action of actions.items) {
+        kb.text(action.label, action.id);
+        col += 1;
+        if (col >= columns) {
+            kb.row();
+            col = 0;
+        }
+    }
+    return kb;
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@acp-router/adapter-telegram",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@acp-router/core": "0.1.0",
+    "grammy": "^1.35.0",
+    "markdown-it": "^14.1.1"
+  },
+  "devDependencies": {
+    "@types/markdown-it": "^14.1.2",
+    "typescript": "^5.9.3"
+  }
+}