@ai-devkit/channel-connector 0.7.0 → 0.8.0

package/dist/__tests__/adapters/TelegramAdapter.test.js

@@ -0,0 +1,240 @@
+import * as telegrafModule from 'telegraf';
+import { TelegramAdapter } from '../../adapters/TelegramAdapter.js';
+// Mock telegraf
+vi.mock('telegraf', ()=>{
+    const handlers = {};
+    const mockBot = {
+        launch: vi.fn().mockResolvedValue(undefined),
+        stop: vi.fn().mockResolvedValue(undefined),
+        on: vi.fn((event, handler)=>{
+            handlers[event] = handler;
+        }),
+        telegram: {
+            sendMessage: vi.fn().mockResolvedValue(undefined),
+            getMe: vi.fn().mockResolvedValue({
+                username: 'test_bot'
+            })
+        },
+        _handlers: handlers,
+        _triggerText: async (chatId, userId, text)=>{
+            const ctx = {
+                message: {
+                    chat: {
+                        id: chatId
+                    },
+                    from: {
+                        id: userId
+                    },
+                    text,
+                    date: Math.floor(Date.now() / 1000)
+                },
+                reply: vi.fn().mockResolvedValue(undefined)
+            };
+            if (handlers['text']) {
+                await handlers['text'](ctx);
+            }
+            return ctx;
+        }
+    };
+    return {
+        Telegraf: vi.fn(function() {
+            return mockBot;
+        }),
+        __mockBot: mockBot
+    };
+});
+function getMockBot() {
+    return telegrafModule.__mockBot;
+}
+describe('TelegramAdapter', ()=>{
+    let adapter;
+    beforeEach(()=>{
+        vi.clearAllMocks();
+        adapter = new TelegramAdapter({
+            botToken: 'test-token-123'
+        });
+    });
+    describe('type', ()=>{
+        it('should return "telegram"', ()=>{
+            expect(adapter.type).toBe('telegram');
+        });
+    });
+    describe('start', ()=>{
+        it('should launch the telegraf bot', async ()=>{
+            const bot = getMockBot();
+            await adapter.start();
+            expect(bot.launch).toHaveBeenCalled();
+        });
+    });
+    describe('stop', ()=>{
+        it('should stop the telegraf bot', async ()=>{
+            const bot = getMockBot();
+            await adapter.start();
+            await adapter.stop();
+            expect(bot.stop).toHaveBeenCalled();
+        });
+    });
+    describe('onMessage', ()=>{
+        it('should silently ignore messages when no handler is registered', async ()=>{
+            // Don't register a handler
+            await adapter.start();
+            const bot = getMockBot();
+            const ctx = await bot._triggerText(12345, 67890, 'hello');
+            // Should not throw or reply
+            expect(ctx.reply).not.toHaveBeenCalled();
+        });
+        it('should handle non-Error thrown by handler', async ()=>{
+            const handler = vi.fn().mockRejectedValue('string error');
+            adapter.onMessage(handler);
+            await adapter.start();
+            const bot = getMockBot();
+            const ctx = await bot._triggerText(12345, 67890, 'hello');
+            expect(ctx.reply).toHaveBeenCalledWith('Error processing message: Unknown error');
+        });
+        it('should call handler with IncomingMessage on incoming text', async ()=>{
+            const handler = vi.fn().mockResolvedValue(undefined);
+            adapter.onMessage(handler);
+            await adapter.start();
+            const bot = getMockBot();
+            await bot._triggerText(12345, 67890, 'hello agent');
+            expect(handler).toHaveBeenCalledTimes(1);
+            const msg = handler.mock.calls[0][0];
+            expect(msg.channelType).toBe('telegram');
+            expect(msg.chatId).toBe('12345');
+            expect(msg.userId).toBe('67890');
+            expect(msg.text).toBe('hello agent');
+            expect(msg.timestamp).toBeInstanceOf(Date);
+        });
+        it('should handle handler errors gracefully', async ()=>{
+            const handler = vi.fn().mockRejectedValue(new Error('handler failed'));
+            adapter.onMessage(handler);
+            await adapter.start();
+            const bot = getMockBot();
+            const ctx = await bot._triggerText(12345, 67890, 'hello');
+            // Should not throw, and should reply with error
+            expect(ctx.reply).toHaveBeenCalledWith(expect.stringContaining('Error processing message'));
+        });
+    });
+    describe('sendMessage', ()=>{
+        it('should send plain text with parse_mode HTML', async ()=>{
+            const bot = getMockBot();
+            await adapter.sendMessage('12345', 'hello from bot');
+            expect(bot.telegram.sendMessage).toHaveBeenCalledWith('12345', 'hello from bot', {
+                parse_mode: 'HTML'
+            });
+        });
+        it('should render markdown as Telegram HTML', async ()=>{
+            const bot = getMockBot();
+            await adapter.sendMessage('12345', '**bold** and *italic* and `code`');
+            const sent = bot.telegram.sendMessage.mock.calls[0][1];
+            expect(sent).toContain('<b>bold</b>');
+            expect(sent).toContain('<i>italic</i>');
+            expect(sent).toContain('<code>code</code>');
+            expect(bot.telegram.sendMessage.mock.calls[0][2]).toEqual({
+                parse_mode: 'HTML'
+            });
+        });
+        it('should chunk messages exceeding 4096 chars', async ()=>{
+            const bot = getMockBot();
+            const line = 'A'.repeat(100) + '\n';
+            const longMessage = line.repeat(50); // 5050 chars
+            await adapter.sendMessage('12345', longMessage);
+            expect(bot.telegram.sendMessage.mock.calls.length).toBeGreaterThan(1);
+            for (const call of bot.telegram.sendMessage.mock.calls){
+                expect(call[1].length).toBeLessThanOrEqual(4096);
+                expect(call[2]).toEqual({
+                    parse_mode: 'HTML'
+                });
+            }
+        });
+        it('should hard split at 4096 when no newlines available', async ()=>{
+            const bot = getMockBot();
+            const longMessage = 'A'.repeat(5000);
+            await adapter.sendMessage('12345', longMessage);
+            expect(bot.telegram.sendMessage.mock.calls.length).toBe(2);
+            expect(bot.telegram.sendMessage.mock.calls[0][1].length).toBe(4096);
+            expect(bot.telegram.sendMessage.mock.calls[1][1].length).toBe(904);
+        });
+        it('should prefer paragraph (\\n\\n) over single \\n when chunking', async ()=>{
+            const bot = getMockBot();
+            // 4 paragraphs of ~1500 chars each, total > 4096
+            const paragraph = 'A'.repeat(1500);
+            const message = `${paragraph}\n\n${paragraph}\n\n${paragraph}\n\n${paragraph}`;
+            await adapter.sendMessage('12345', message);
+            // First chunk should end at a \n\n boundary, not mid-paragraph
+            const firstChunk = bot.telegram.sendMessage.mock.calls[0][1];
+            expect(firstChunk.endsWith('\n\n')).toBe(true);
+        });
+        it('should send short messages in a single call', async ()=>{
+            const bot = getMockBot();
+            await adapter.sendMessage('12345', 'short message');
+            expect(bot.telegram.sendMessage).toHaveBeenCalledTimes(1);
+        });
+        it('should retry as plain text when Telegram rejects HTML with parse-entities error', async ()=>{
+            const bot = getMockBot();
+            const parseError = Object.assign(new Error('400: Bad Request'), {
+                description: "Bad Request: can't parse entities: Unsupported start tag \"foo\""
+            });
+            bot.telegram.sendMessage.mockRejectedValueOnce(parseError).mockResolvedValueOnce(undefined);
+            await adapter.sendMessage('12345', '**hello**');
+            expect(bot.telegram.sendMessage).toHaveBeenCalledTimes(2);
+            // First call: rendered HTML with parse_mode
+            const [, htmlChunk, htmlOpts] = bot.telegram.sendMessage.mock.calls[0];
+            expect(htmlChunk).toContain('<b>hello</b>');
+            expect(htmlOpts).toEqual({
+                parse_mode: 'HTML'
+            });
+            // Second call: same content, plain text (tags stripped, no parse_mode)
+            const [, plainChunk, plainOpts] = bot.telegram.sendMessage.mock.calls[1];
+            expect(plainChunk).toBe('hello');
+            expect(plainOpts).toBeUndefined();
+        });
+        it('should detect parse-entities error from "message" field too', async ()=>{
+            const bot = getMockBot();
+            // Some error shapes carry the marker on `message` rather than `description`
+            const parseError = new Error("can't parse entities");
+            bot.telegram.sendMessage.mockRejectedValueOnce(parseError).mockResolvedValueOnce(undefined);
+            await adapter.sendMessage('12345', '**hi**');
+            expect(bot.telegram.sendMessage).toHaveBeenCalledTimes(2);
+        });
+        it('should decode HTML entities when falling back to plain text', async ()=>{
+            const bot = getMockBot();
+            const parseError = Object.assign(new Error('400'), {
+                description: "Bad Request: can't parse entities"
+            });
+            bot.telegram.sendMessage.mockRejectedValueOnce(parseError).mockResolvedValueOnce(undefined);
+            // Source has chars that escapeHtml encodes; fallback should decode them
+            await adapter.sendMessage('12345', 'a < b && c > d');
+            const [, plainChunk] = bot.telegram.sendMessage.mock.calls[1];
+            expect(plainChunk).toContain('a < b && c > d');
+            expect(plainChunk).not.toContain('&lt;');
+            expect(plainChunk).not.toContain('&amp;');
+        });
+        it('should propagate non-parse-entities errors without falling back', async ()=>{
+            const bot = getMockBot();
+            const otherError = Object.assign(new Error('403'), {
+                description: 'Forbidden: bot was blocked by the user'
+            });
+            bot.telegram.sendMessage.mockRejectedValueOnce(otherError);
+            await expect(adapter.sendMessage('12345', 'hi')).rejects.toBe(otherError);
+            // Only the HTML attempt should have happened — no fallback retry
+            expect(bot.telegram.sendMessage).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('isHealthy', ()=>{
+        it('should return true after start', async ()=>{
+            await adapter.start();
+            expect(await adapter.isHealthy()).toBe(true);
+        });
+        it('should return false before start', async ()=>{
+            expect(await adapter.isHealthy()).toBe(false);
+        });
+        it('should return false after stop', async ()=>{
+            await adapter.start();
+            await adapter.stop();
+            expect(await adapter.isHealthy()).toBe(false);
+        });
+    });
+});
+
+//# sourceMappingURL=TelegramAdapter.test.js.map

package/dist/__tests__/adapters/TelegramAdapter.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/__tests__/adapters/TelegramAdapter.test.ts"],"sourcesContent":["import * as telegrafModule from 'telegraf';\nimport { TelegramAdapter } from '../../adapters/TelegramAdapter.js';\nimport type { IncomingMessage } from '../../types.js';\n\n// Mock telegraf\nvi.mock('telegraf', () => {\n    const handlers: Record<string, (...args: any[]) => any> = {};\n    const mockBot = {\n        launch: vi.fn().mockResolvedValue(undefined),\n        stop: vi.fn().mockResolvedValue(undefined),\n        on: vi.fn((event: string, handler: (...args: any[]) => any) => {\n            handlers[event] = handler;\n        }),\n        telegram: {\n            sendMessage: vi.fn().mockResolvedValue(undefined),\n            getMe: vi.fn().mockResolvedValue({ username: 'test_bot' }),\n        },\n        _handlers: handlers,\n        _triggerText: async (chatId: number, userId: number, text: string) => {\n            const ctx = {\n                message: {\n                    chat: { id: chatId },\n                    from: { id: userId },\n                    text,\n                    date: Math.floor(Date.now() / 1000),\n                },\n                reply: vi.fn().mockResolvedValue(undefined),\n            };\n            if (handlers['text']) {\n                await handlers['text'](ctx);\n            }\n            return ctx;\n        },\n    };\n    return {\n        Telegraf: vi.fn(function () { return mockBot; }),\n        __mockBot: mockBot,\n    };\n});\n\nfunction getMockBot() {\n    return (telegrafModule as unknown as { __mockBot: ReturnType<typeof vi.fn>['mock'] & Record<string, unknown> }).__mockBot;\n}\n\ndescribe('TelegramAdapter', () => {\n    let adapter: TelegramAdapter;\n\n    beforeEach(() => {\n        vi.clearAllMocks();\n        adapter = new TelegramAdapter({ botToken: 'test-token-123' });\n    });\n\n    describe('type', () => {\n        it('should return \"telegram\"', () => {\n            expect(adapter.type).toBe('telegram');\n        });\n    });\n\n    describe('start', () => {\n        it('should launch the telegraf bot', async () => {\n            const bot = getMockBot();\n            await adapter.start();\n            expect(bot.launch).toHaveBeenCalled();\n        });\n    });\n\n    describe('stop', () => {\n        it('should stop the telegraf bot', async () => {\n            const bot = getMockBot();\n            await adapter.start();\n            await adapter.stop();\n            expect(bot.stop).toHaveBeenCalled();\n        });\n    });\n\n    describe('onMessage', () => {\n        it('should silently ignore messages when no handler is registered', async () => {\n            // Don't register a handler\n            await adapter.start();\n\n            const bot = getMockBot();\n            const ctx = await bot._triggerText(12345, 67890, 'hello');\n\n            // Should not throw or reply\n            expect(ctx.reply).not.toHaveBeenCalled();\n        });\n\n        it('should handle non-Error thrown by handler', async () => {\n            const handler = vi.fn().mockRejectedValue('string error');\n            adapter.onMessage(handler);\n            await adapter.start();\n\n            const bot = getMockBot();\n            const ctx = await bot._triggerText(12345, 67890, 'hello');\n\n            expect(ctx.reply).toHaveBeenCalledWith(\n                'Error processing message: Unknown error'\n            );\n        });\n\n        it('should call handler with IncomingMessage on incoming text', async () => {\n            const handler = vi.fn().mockResolvedValue(undefined);\n            adapter.onMessage(handler);\n            await adapter.start();\n\n            const bot = getMockBot();\n            await bot._triggerText(12345, 67890, 'hello agent');\n\n            expect(handler).toHaveBeenCalledTimes(1);\n            const msg: IncomingMessage = handler.mock.calls[0][0];\n            expect(msg.channelType).toBe('telegram');\n            expect(msg.chatId).toBe('12345');\n            expect(msg.userId).toBe('67890');\n            expect(msg.text).toBe('hello agent');\n            expect(msg.timestamp).toBeInstanceOf(Date);\n        });\n\n        it('should handle handler errors gracefully', async () => {\n            const handler = vi.fn().mockRejectedValue(new Error('handler failed'));\n            adapter.onMessage(handler);\n            await adapter.start();\n\n            const bot = getMockBot();\n            const ctx = await bot._triggerText(12345, 67890, 'hello');\n\n            // Should not throw, and should reply with error\n            expect(ctx.reply).toHaveBeenCalledWith(\n                expect.stringContaining('Error processing message')\n            );\n        });\n    });\n\n    describe('sendMessage', () => {\n        it('should send plain text with parse_mode HTML', async () => {\n            const bot = getMockBot();\n            await adapter.sendMessage('12345', 'hello from bot');\n\n            expect(bot.telegram.sendMessage).toHaveBeenCalledWith(\n                '12345',\n                'hello from bot',\n                { parse_mode: 'HTML' }\n            );\n        });\n\n        it('should render markdown as Telegram HTML', async () => {\n            const bot = getMockBot();\n            await adapter.sendMessage('12345', '**bold** and *italic* and `code`');\n\n            const sent = bot.telegram.sendMessage.mock.calls[0][1];\n            expect(sent).toContain('<b>bold</b>');\n            expect(sent).toContain('<i>italic</i>');\n            expect(sent).toContain('<code>code</code>');\n            expect(bot.telegram.sendMessage.mock.calls[0][2]).toEqual({\n                parse_mode: 'HTML',\n            });\n        });\n\n        it('should chunk messages exceeding 4096 chars', async () => {\n            const bot = getMockBot();\n            const line = 'A'.repeat(100) + '\\n';\n            const longMessage = line.repeat(50); // 5050 chars\n\n            await adapter.sendMessage('12345', longMessage);\n\n            expect(bot.telegram.sendMessage.mock.calls.length).toBeGreaterThan(1);\n            for (const call of bot.telegram.sendMessage.mock.calls) {\n                expect(call[1].length).toBeLessThanOrEqual(4096);\n                expect(call[2]).toEqual({ parse_mode: 'HTML' });\n            }\n        });\n\n        it('should hard split at 4096 when no newlines available', async () => {\n            const bot = getMockBot();\n            const longMessage = 'A'.repeat(5000);\n\n            await adapter.sendMessage('12345', longMessage);\n\n            expect(bot.telegram.sendMessage.mock.calls.length).toBe(2);\n            expect(bot.telegram.sendMessage.mock.calls[0][1].length).toBe(4096);\n            expect(bot.telegram.sendMessage.mock.calls[1][1].length).toBe(904);\n        });\n\n        it('should prefer paragraph (\\\\n\\\\n) over single \\\\n when chunking', async () => {\n            const bot = getMockBot();\n            // 4 paragraphs of ~1500 chars each, total > 4096\n            const paragraph = 'A'.repeat(1500);\n            const message = `${paragraph}\\n\\n${paragraph}\\n\\n${paragraph}\\n\\n${paragraph}`;\n\n            await adapter.sendMessage('12345', message);\n\n            // First chunk should end at a \\n\\n boundary, not mid-paragraph\n            const firstChunk = bot.telegram.sendMessage.mock.calls[0][1];\n            expect(firstChunk.endsWith('\\n\\n')).toBe(true);\n        });\n\n        it('should send short messages in a single call', async () => {\n            const bot = getMockBot();\n            await adapter.sendMessage('12345', 'short message');\n\n            expect(bot.telegram.sendMessage).toHaveBeenCalledTimes(1);\n        });\n\n        it('should retry as plain text when Telegram rejects HTML with parse-entities error', async () => {\n            const bot = getMockBot();\n            const parseError = Object.assign(new Error('400: Bad Request'), {\n                description: \"Bad Request: can't parse entities: Unsupported start tag \\\"foo\\\"\",\n            });\n            bot.telegram.sendMessage\n                .mockRejectedValueOnce(parseError)\n                .mockResolvedValueOnce(undefined);\n\n            await adapter.sendMessage('12345', '**hello**');\n\n            expect(bot.telegram.sendMessage).toHaveBeenCalledTimes(2);\n\n            // First call: rendered HTML with parse_mode\n            const [, htmlChunk, htmlOpts] = bot.telegram.sendMessage.mock.calls[0];\n            expect(htmlChunk).toContain('<b>hello</b>');\n            expect(htmlOpts).toEqual({ parse_mode: 'HTML' });\n\n            // Second call: same content, plain text (tags stripped, no parse_mode)\n            const [, plainChunk, plainOpts] = bot.telegram.sendMessage.mock.calls[1];\n            expect(plainChunk).toBe('hello');\n            expect(plainOpts).toBeUndefined();\n        });\n\n        it('should detect parse-entities error from \"message\" field too', async () => {\n            const bot = getMockBot();\n            // Some error shapes carry the marker on `message` rather than `description`\n            const parseError = new Error(\"can't parse entities\");\n            bot.telegram.sendMessage\n                .mockRejectedValueOnce(parseError)\n                .mockResolvedValueOnce(undefined);\n\n            await adapter.sendMessage('12345', '**hi**');\n\n            expect(bot.telegram.sendMessage).toHaveBeenCalledTimes(2);\n        });\n\n        it('should decode HTML entities when falling back to plain text', async () => {\n            const bot = getMockBot();\n            const parseError = Object.assign(new Error('400'), {\n                description: \"Bad Request: can't parse entities\",\n            });\n            bot.telegram.sendMessage\n                .mockRejectedValueOnce(parseError)\n                .mockResolvedValueOnce(undefined);\n\n            // Source has chars that escapeHtml encodes; fallback should decode them\n            await adapter.sendMessage('12345', 'a < b && c > d');\n\n            const [, plainChunk] = bot.telegram.sendMessage.mock.calls[1];\n            expect(plainChunk).toContain('a < b && c > d');\n            expect(plainChunk).not.toContain('&lt;');\n            expect(plainChunk).not.toContain('&amp;');\n        });\n\n        it('should propagate non-parse-entities errors without falling back', async () => {\n            const bot = getMockBot();\n            const otherError = Object.assign(new Error('403'), {\n                description: 'Forbidden: bot was blocked by the user',\n            });\n            bot.telegram.sendMessage.mockRejectedValueOnce(otherError);\n\n            await expect(adapter.sendMessage('12345', 'hi')).rejects.toBe(otherError);\n\n            // Only the HTML attempt should have happened — no fallback retry\n            expect(bot.telegram.sendMessage).toHaveBeenCalledTimes(1);\n        });\n    });\n\n    describe('isHealthy', () => {\n        it('should return true after start', async () => {\n            await adapter.start();\n            expect(await adapter.isHealthy()).toBe(true);\n        });\n\n        it('should return false before start', async () => {\n            expect(await adapter.isHealthy()).toBe(false);\n        });\n\n        it('should return false after stop', async () => {\n            await adapter.start();\n            await adapter.stop();\n            expect(await adapter.isHealthy()).toBe(false);\n        });\n    });\n});\n"],"names":["telegrafModule","TelegramAdapter","vi","mock","handlers","mockBot","launch","fn","mockResolvedValue","undefined","stop","on","event","handler","telegram","sendMessage","getMe","username","_handlers","_triggerText","chatId","userId","text","ctx","message","chat","id","from","date","Math","floor","Date","now","reply","Telegraf","__mockBot","getMockBot","describe","adapter","beforeEach","clearAllMocks","botToken","it","expect","type","toBe","bot","start","toHaveBeenCalled","not","mockRejectedValue","onMessage","toHaveBeenCalledWith","toHaveBeenCalledTimes","msg","calls","channelType","timestamp","toBeInstanceOf","Error","stringContaining","parse_mode","sent","toContain","toEqual","line","repeat","longMessage","length","toBeGreaterThan","call","toBeLessThanOrEqual","paragraph","firstChunk","endsWith","parseError","Object","assign","description","mockRejectedValueOnce","mockResolvedValueOnce","htmlChunk","htmlOpts","plainChunk","plainOpts","toBeUndefined","otherError","rejects","isHealthy"],"mappings":"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"}

package/dist/__tests__/utils/telegramHtml.test.js

@@ -0,0 +1,86 @@
+import { markdownToTelegramHtml } from '../../utils/telegramHtml.js';
+describe('markdownToTelegramHtml', ()=>{
+    it('renders bold, italic, strikethrough', ()=>{
+        const out = markdownToTelegramHtml('**b** _i_ ~~s~~');
+        expect(out).toContain('<b>b</b>');
+        expect(out).toContain('<i>i</i>');
+        expect(out).toContain('<s>s</s>');
+    });
+    it('renders inline code and fenced code with language', ()=>{
+        const md = 'Run `npm test`\n\n```ts\nconst x = 1;\n```';
+        const out = markdownToTelegramHtml(md);
+        expect(out).toContain('<code>npm test</code>');
+        expect(out).toContain('<pre><code class="language-ts">const x = 1;</code></pre>');
+    });
+    it('renders links and converts headings to bold', ()=>{
+        const md = '# Title\n\nSee [docs](https://x.com).';
+        const out = markdownToTelegramHtml(md);
+        expect(out).toContain('<b>Title</b>');
+        expect(out).toContain('<a href="https://x.com">docs</a>');
+    });
+    it('renders images as alt-text links', ()=>{
+        const out = markdownToTelegramHtml('![diagram](https://x.com/d.png)');
+        expect(out).toBe('<a href="https://x.com/d.png">diagram</a>');
+    });
+    it('falls back to URL when image has no alt text', ()=>{
+        const out = markdownToTelegramHtml('![](https://x.com/d.png)');
+        expect(out).toContain('<a href="https://x.com/d.png">https://x.com/d.png</a>');
+    });
+    it('renders unordered lists with bullets', ()=>{
+        const out = markdownToTelegramHtml('- one\n- two\n- three');
+        expect(out).toContain('• one');
+        expect(out).toContain('• two');
+        expect(out).toContain('• three');
+        expect(out).not.toContain('<ul>');
+    });
+    it('renders ordered lists with numbers', ()=>{
+        const out = markdownToTelegramHtml('1. one\n2. two');
+        expect(out).toContain('1. one');
+        expect(out).toContain('2. two');
+        expect(out).not.toContain('<ol>');
+    });
+    it('renders tables as ASCII inside <pre>', ()=>{
+        const md = '| a | b |\n|---|---|\n| 1 | 2 |';
+        const out = markdownToTelegramHtml(md);
+        expect(out.startsWith('<pre>')).toBe(true);
+        expect(out).toContain('a');
+        expect(out).toContain('b');
+        expect(out).toContain('1');
+        expect(out).toContain('2');
+        expect(out).not.toContain('<table>');
+    });
+    it('uses <blockquote> for quotes', ()=>{
+        const out = markdownToTelegramHtml('> quoted');
+        expect(out).toContain('<blockquote>');
+        expect(out).toContain('quoted');
+        expect(out).toContain('</blockquote>');
+    });
+    it('escapes HTML special chars in plain text', ()=>{
+        const out = markdownToTelegramHtml('a < b && c > d');
+        expect(out).toContain('&lt;');
+        expect(out).toContain('&amp;');
+        expect(out).toContain('&gt;');
+        expect(out).not.toContain(' < ');
+    });
+    it('escapes HTML special chars inside code', ()=>{
+        const out = markdownToTelegramHtml('`<script>`');
+        expect(out).toContain('<code>&lt;script&gt;</code>');
+    });
+    it('strips raw HTML blocks', ()=>{
+        const out = markdownToTelegramHtml('hello\n\n<div>raw</div>\n\nworld');
+        expect(out).not.toContain('<div>');
+        expect(out).toContain('hello');
+        expect(out).toContain('world');
+    });
+    it('renders horizontal rule as a divider', ()=>{
+        const out = markdownToTelegramHtml('above\n\n---\n\nbelow');
+        expect(out).toContain('above');
+        expect(out).toContain('———');
+        expect(out).toContain('below');
+    });
+    it('passes plain text through unchanged', ()=>{
+        expect(markdownToTelegramHtml('hello world')).toBe('hello world');
+    });
+});
+
+//# sourceMappingURL=telegramHtml.test.js.map

package/dist/__tests__/utils/telegramHtml.test.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/__tests__/utils/telegramHtml.test.ts"],"sourcesContent":["import { markdownToTelegramHtml } from '../../utils/telegramHtml.js';\n\ndescribe('markdownToTelegramHtml', () => {\n    it('renders bold, italic, strikethrough', () => {\n        const out = markdownToTelegramHtml('**b** _i_ ~~s~~');\n        expect(out).toContain('<b>b</b>');\n        expect(out).toContain('<i>i</i>');\n        expect(out).toContain('<s>s</s>');\n    });\n\n    it('renders inline code and fenced code with language', () => {\n        const md = 'Run `npm test`\\n\\n```ts\\nconst x = 1;\\n```';\n        const out = markdownToTelegramHtml(md);\n        expect(out).toContain('<code>npm test</code>');\n        expect(out).toContain('<pre><code class=\"language-ts\">const x = 1;</code></pre>');\n    });\n\n    it('renders links and converts headings to bold', () => {\n        const md = '# Title\\n\\nSee [docs](https://x.com).';\n        const out = markdownToTelegramHtml(md);\n        expect(out).toContain('<b>Title</b>');\n        expect(out).toContain('<a href=\"https://x.com\">docs</a>');\n    });\n\n    it('renders images as alt-text links', () => {\n        const out = markdownToTelegramHtml('![diagram](https://x.com/d.png)');\n        expect(out).toBe('<a href=\"https://x.com/d.png\">diagram</a>');\n    });\n\n    it('falls back to URL when image has no alt text', () => {\n        const out = markdownToTelegramHtml('![](https://x.com/d.png)');\n        expect(out).toContain('<a href=\"https://x.com/d.png\">https://x.com/d.png</a>');\n    });\n\n    it('renders unordered lists with bullets', () => {\n        const out = markdownToTelegramHtml('- one\\n- two\\n- three');\n        expect(out).toContain('• one');\n        expect(out).toContain('• two');\n        expect(out).toContain('• three');\n        expect(out).not.toContain('<ul>');\n    });\n\n    it('renders ordered lists with numbers', () => {\n        const out = markdownToTelegramHtml('1. one\\n2. two');\n        expect(out).toContain('1. one');\n        expect(out).toContain('2. two');\n        expect(out).not.toContain('<ol>');\n    });\n\n    it('renders tables as ASCII inside <pre>', () => {\n        const md = '| a | b |\\n|---|---|\\n| 1 | 2 |';\n        const out = markdownToTelegramHtml(md);\n        expect(out.startsWith('<pre>')).toBe(true);\n        expect(out).toContain('a');\n        expect(out).toContain('b');\n        expect(out).toContain('1');\n        expect(out).toContain('2');\n        expect(out).not.toContain('<table>');\n    });\n\n    it('uses <blockquote> for quotes', () => {\n        const out = markdownToTelegramHtml('> quoted');\n        expect(out).toContain('<blockquote>');\n        expect(out).toContain('quoted');\n        expect(out).toContain('</blockquote>');\n    });\n\n    it('escapes HTML special chars in plain text', () => {\n        const out = markdownToTelegramHtml('a < b && c > d');\n        expect(out).toContain('&lt;');\n        expect(out).toContain('&amp;');\n        expect(out).toContain('&gt;');\n        expect(out).not.toContain(' < ');\n    });\n\n    it('escapes HTML special chars inside code', () => {\n        const out = markdownToTelegramHtml('`<script>`');\n        expect(out).toContain('<code>&lt;script&gt;</code>');\n    });\n\n    it('strips raw HTML blocks', () => {\n        const out = markdownToTelegramHtml('hello\\n\\n<div>raw</div>\\n\\nworld');\n        expect(out).not.toContain('<div>');\n        expect(out).toContain('hello');\n        expect(out).toContain('world');\n    });\n\n    it('renders horizontal rule as a divider', () => {\n        const out = markdownToTelegramHtml('above\\n\\n---\\n\\nbelow');\n        expect(out).toContain('above');\n        expect(out).toContain('———');\n        expect(out).toContain('below');\n    });\n\n    it('passes plain text through unchanged', () => {\n        expect(markdownToTelegramHtml('hello world')).toBe('hello world');\n    });\n});\n"],"names":["markdownToTelegramHtml","describe","it","out","expect","toContain","md","toBe","not","startsWith"],"mappings":"AAAA,SAASA,sBAAsB,QAAQ,8BAA8B;AAErEC,SAAS,0BAA0B;IAC/BC,GAAG,uCAAuC;QACtC,MAAMC,MAAMH,uBAAuB;QACnCI,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;IAC1B;IAEAH,GAAG,qDAAqD;QACpD,MAAMI,KAAK;QACX,MAAMH,MAAMH,uBAAuBM;QACnCF,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;IAC1B;IAEAH,GAAG,+CAA+C;QAC9C,MAAMI,KAAK;QACX,MAAMH,MAAMH,uBAAuBM;QACnCF,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;IAC1B;IAEAH,GAAG,oCAAoC;QACnC,MAAMC,MAAMH,uBAAuB;QACnCI,OAAOD,KAAKI,IAAI,CAAC;IACrB;IAEAL,GAAG,gDAAgD;QAC/C,MAAMC,MAAMH,uBAAuB;QACnCI,OAAOD,KAAKE,SAAS,CAAC;IAC1B;IAEAH,GAAG,wCAAwC;QACvC,MAAMC,MAAMH,uBAAuB;QACnCI,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKK,GAAG,CAACH,SAAS,CAAC;IAC9B;IAEAH,GAAG,sCAAsC;QACrC,MAAMC,MAAMH,uBAAuB;QACnCI,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKK,GAAG,CAACH,SAAS,CAAC;IAC9B;IAEAH,GAAG,wCAAwC;QACvC,MAAMI,KAAK;QACX,MAAMH,MAAMH,uBAAuBM;QACnCF,OAAOD,IAAIM,UAAU,CAAC,UAAUF,IAAI,CAAC;QACrCH,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKK,GAAG,CAACH,SAAS,CAAC;IAC9B;IAEAH,GAAG,gCAAgC;QAC/B,MAAMC,MAAMH,uBAAuB;QACnCI,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;IAC1B;IAEAH,GAAG,4CAA4C;QAC3C,MAAMC,MAAMH,uBAAuB;QACnCI,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKK,GAAG,CAACH,SAAS,CAAC;IAC9B;IAEAH,GAAG,0CAA0C;QACzC,MAAMC,MAAMH,uBAAuB;QACnCI,OAAOD,KAAKE,SAAS,CAAC;IAC1B;IAEAH,GAAG,0BAA0B;QACzB,MAAMC,MAAMH,uBAAuB;QACnCI,OAAOD,KAAKK,GAAG,CAACH,SAAS,CAAC;QAC1BD,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;IAC1B;IAEAH,GAAG,wCAAwC;QACvC,MAAMC,MAAMH,uBAAuB;QACnCI,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;QACtBD,OAAOD,KAAKE,SAAS,CAAC;IAC1B;IAEAH,GAAG,uCAAuC;QACtCE,OAAOJ,uBAAuB,gBAAgBO,IAAI,CAAC;IACvD;AACJ"}

package/dist/adapters/ChannelAdapter.js

@@ -1,2 +1,8 @@
-export {};
+/**
+ * Interface for messaging platform adapters.
+ *
+ * Implementations connect to a specific platform (Telegram, Slack, etc.)
+ * and provide a generic send/receive abstraction.
+ */ export { };
+
 //# sourceMappingURL=ChannelAdapter.js.map

package/dist/adapters/ChannelAdapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"ChannelAdapter.js","sourceRoot":"","sources":["../../src/adapters/ChannelAdapter.ts"],"names":[],"mappings":""}
+{"version":3,"sources":["../../src/adapters/ChannelAdapter.ts"],"sourcesContent":["import type { IncomingMessage } from '../types.js';\n\n/**\n * Interface for messaging platform adapters.\n *\n * Implementations connect to a specific platform (Telegram, Slack, etc.)\n * and provide a generic send/receive abstraction.\n */\nexport interface ChannelAdapter {\n    /** Identifier for this channel type (e.g., 'telegram') */\n    readonly type: string;\n\n    /** Start listening for incoming messages */\n    start(): Promise<void>;\n\n    /** Stop listening and clean up resources */\n    stop(): Promise<void>;\n\n    /**\n     * Send a message to a specific chat.\n     * Implementations should handle platform-specific limits\n     * (e.g., chunking at 4096 chars for Telegram).\n     */\n    sendMessage(chatId: string, text: string): Promise<void>;\n\n    /**\n     * Register a handler for incoming text messages.\n     * Fire-and-forget — handler returns void.\n     * Responses are sent separately via sendMessage().\n     */\n    onMessage(handler: (msg: IncomingMessage) => Promise<void>): void;\n\n    /** Check if the adapter is connected and healthy */\n    isHealthy(): Promise<boolean>;\n}\n"],"names":[],"mappings":"AAEA;;;;;CAKC,GACD,WA0BC"}

package/dist/adapters/TelegramAdapter.js

@@ -5,30 +5,27 @@ export const TELEGRAM_MAX_MESSAGE_LENGTH = 4096;
 const TELEGRAM_PARSE_MODE = 'HTML';
 /**
  * Telegram Bot API adapter using telegraf with long polling.
- */
-export class TelegramAdapter {
+ */ export class TelegramAdapter {
     type = TELEGRAM_CHANNEL_TYPE;
     bot;
     messageHandler = null;
     running = false;
-    constructor(options) {
+    constructor(options){
         this.bot = new Telegraf(options.botToken);
     }
     async start() {
-        this.bot.on('text', async (ctx) => {
-            if (!this.messageHandler)
-                return;
+        this.bot.on('text', async (ctx)=>{
+            if (!this.messageHandler) return;
             const msg = {
                 channelType: TELEGRAM_CHANNEL_TYPE,
                 chatId: String(ctx.message.chat.id),
                 userId: String(ctx.message.from.id),
                 text: ctx.message.text,
-                timestamp: new Date(ctx.message.date * 1000),
+                timestamp: new Date(ctx.message.date * 1000)
             };
             try {
                 await this.messageHandler(msg);
-            }
-            catch (error) {
+            } catch (error) {
                 const errorMessage = error instanceof Error ? error.message : 'Unknown error';
                 await ctx.reply(`Error processing message: ${errorMessage}`);
             }
@@ -45,17 +42,16 @@ export class TelegramAdapter {
      * Long messages are chunked at paragraph boundaries when possible; very
      * long single blocks (e.g. a `<pre>` over 4096 chars) may still split
      * mid-tag and produce a partial render in the second chunk.
-     */
-    async sendMessage(chatId, text) {
+     */ async sendMessage(chatId, text) {
         const html = markdownToTelegramHtml(text);
         const chunks = chunkMessage(html, TELEGRAM_MAX_MESSAGE_LENGTH);
-        for (const chunk of chunks) {
+        for (const chunk of chunks){
             try {
-                await this.bot.telegram.sendMessage(chatId, chunk, { parse_mode: TELEGRAM_PARSE_MODE });
-            }
-            catch (error) {
-                if (!isParseEntitiesError(error))
-                    throw error;
+                await this.bot.telegram.sendMessage(chatId, chunk, {
+                    parse_mode: TELEGRAM_PARSE_MODE
+                });
+            } catch (error) {
+                if (!isParseEntitiesError(error)) throw error;
                 // Telegram rejected the rendered HTML — fall back to plain text
                 // so the user still gets the content (just unformatted).
                 await this.bot.telegram.sendMessage(chatId, htmlToPlainText(chunk));
@@ -70,28 +66,21 @@ export class TelegramAdapter {
     }
 }
 function isParseEntitiesError(error) {
-    if (!error || typeof error !== 'object')
-        return false;
+    if (!error || typeof error !== 'object') return false;
     const description = error.description;
     const message = error.message;
     return ((description ?? '') + (message ?? '')).includes("can't parse entities");
 }
 function htmlToPlainText(html) {
-    return html
-        .replace(/<[^>]+>/g, '')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&quot;/g, '"')
-        .replace(/&amp;/g, '&');
+    return html.replace(/<[^>]+>/g, '').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&amp;/g, '&');
 }
 /**
  * Split text into chunks of maxLen or fewer characters. Prefers paragraph
  * boundaries (\n\n), then single newlines (\n), then hard-splits at maxLen.
- */
-function chunkMessage(text, maxLen) {
+ */ function chunkMessage(text, maxLen) {
     const chunks = [];
     let remaining = text;
-    while (remaining.length > 0) {
+    while(remaining.length > 0){
         if (remaining.length <= maxLen) {
             chunks.push(remaining);
             break;
@@ -101,11 +90,9 @@ function chunkMessage(text, maxLen) {
         let splitAt;
         if (lastParagraph > 0) {
             splitAt = lastParagraph + 2;
-        }
-        else if (lastNewline > 0) {
+        } else if (lastNewline > 0) {
             splitAt = lastNewline + 1;
-        }
-        else {
+        } else {
             splitAt = maxLen;
         }
         chunks.push(remaining.slice(0, splitAt));
@@ -113,4 +100,5 @@ function chunkMessage(text, maxLen) {
     }
     return chunks;
 }
+
 //# sourceMappingURL=TelegramAdapter.js.map

package/dist/adapters/TelegramAdapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"TelegramAdapter.js","sourceRoot":"","sources":["../../src/adapters/TelegramAdapter.ts"],"names":[],"mappings":"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"}
+{"version":3,"sources":["../../src/adapters/TelegramAdapter.ts"],"sourcesContent":["import { Telegraf } from 'telegraf';\nimport type { ChannelAdapter } from './ChannelAdapter.js';\nimport { markdownToTelegramHtml } from '../utils/telegramHtml.js';\nimport type { IncomingMessage } from '../types.js';\n\nexport const TELEGRAM_CHANNEL_TYPE = 'telegram';\nexport const TELEGRAM_MAX_MESSAGE_LENGTH = 4096;\nconst TELEGRAM_PARSE_MODE = 'HTML' as const;\n\nexport interface TelegramAdapterOptions {\n    botToken: string;\n}\n\n/**\n * Telegram Bot API adapter using telegraf with long polling.\n */\nexport class TelegramAdapter implements ChannelAdapter {\n    readonly type = TELEGRAM_CHANNEL_TYPE;\n\n    private bot: Telegraf;\n    private messageHandler: ((msg: IncomingMessage) => Promise<void>) | null = null;\n    private running = false;\n\n    constructor(options: TelegramAdapterOptions) {\n        this.bot = new Telegraf(options.botToken);\n    }\n\n    async start(): Promise<void> {\n        this.bot.on('text', async (ctx) => {\n            if (!this.messageHandler) return;\n\n            const msg: IncomingMessage = {\n                channelType: TELEGRAM_CHANNEL_TYPE,\n                chatId: String(ctx.message.chat.id),\n                userId: String(ctx.message.from.id),\n                text: ctx.message.text,\n                timestamp: new Date(ctx.message.date * 1000),\n            };\n\n            try {\n                await this.messageHandler(msg);\n            } catch (error) {\n                const errorMessage = error instanceof Error ? error.message : 'Unknown error';\n                await ctx.reply(`Error processing message: ${errorMessage}`);\n            }\n        });\n\n        await this.bot.launch();\n        this.running = true;\n    }\n\n    async stop(): Promise<void> {\n        this.running = false;\n        await this.bot.stop();\n    }\n\n    /**\n     * Input is treated as markdown and rendered as Telegram-compatible HTML.\n     * Long messages are chunked at paragraph boundaries when possible; very\n     * long single blocks (e.g. a `<pre>` over 4096 chars) may still split\n     * mid-tag and produce a partial render in the second chunk.\n     */\n    async sendMessage(chatId: string, text: string): Promise<void> {\n        const html = markdownToTelegramHtml(text);\n        const chunks = chunkMessage(html, TELEGRAM_MAX_MESSAGE_LENGTH);\n        for (const chunk of chunks) {\n            try {\n                await this.bot.telegram.sendMessage(chatId, chunk, { parse_mode: TELEGRAM_PARSE_MODE });\n            } catch (error) {\n                if (!isParseEntitiesError(error)) throw error;\n                // Telegram rejected the rendered HTML — fall back to plain text\n                // so the user still gets the content (just unformatted).\n                await this.bot.telegram.sendMessage(chatId, htmlToPlainText(chunk));\n            }\n        }\n    }\n\n    onMessage(handler: (msg: IncomingMessage) => Promise<void>): void {\n        this.messageHandler = handler;\n    }\n\n    async isHealthy(): Promise<boolean> {\n        return this.running;\n    }\n}\n\nfunction isParseEntitiesError(error: unknown): boolean {\n    if (!error || typeof error !== 'object') return false;\n    const description = (error as { description?: string }).description;\n    const message = (error as { message?: string }).message;\n    return ((description ?? '') + (message ?? '')).includes(\"can't parse entities\");\n}\n\nfunction htmlToPlainText(html: string): string {\n    return html\n        .replace(/<[^>]+>/g, '')\n        .replace(/&lt;/g, '<')\n        .replace(/&gt;/g, '>')\n        .replace(/&quot;/g, '\"')\n        .replace(/&amp;/g, '&');\n}\n\n/**\n * Split text into chunks of maxLen or fewer characters. Prefers paragraph\n * boundaries (\\n\\n), then single newlines (\\n), then hard-splits at maxLen.\n */\nfunction chunkMessage(text: string, maxLen: number): string[] {\n    const chunks: string[] = [];\n    let remaining = text;\n\n    while (remaining.length > 0) {\n        if (remaining.length <= maxLen) {\n            chunks.push(remaining);\n            break;\n        }\n\n        const lastParagraph = remaining.lastIndexOf('\\n\\n', maxLen - 2);\n        const lastNewline = remaining.lastIndexOf('\\n', maxLen - 1);\n\n        let splitAt: number;\n        if (lastParagraph > 0) {\n            splitAt = lastParagraph + 2;\n        } else if (lastNewline > 0) {\n            splitAt = lastNewline + 1;\n        } else {\n            splitAt = maxLen;\n        }\n\n        chunks.push(remaining.slice(0, splitAt));\n        remaining = remaining.slice(splitAt);\n    }\n\n    return chunks;\n}\n"],"names":["Telegraf","markdownToTelegramHtml","TELEGRAM_CHANNEL_TYPE","TELEGRAM_MAX_MESSAGE_LENGTH","TELEGRAM_PARSE_MODE","TelegramAdapter","type","bot","messageHandler","running","options","botToken","start","on","ctx","msg","channelType","chatId","String","message","chat","id","userId","from","text","timestamp","Date","date","error","errorMessage","Error","reply","launch","stop","sendMessage","html","chunks","chunkMessage","chunk","telegram","parse_mode","isParseEntitiesError","htmlToPlainText","onMessage","handler","isHealthy","description","includes","replace","maxLen","remaining","length","push","lastParagraph","lastIndexOf","lastNewline","splitAt","slice"],"mappings":"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"}

package/dist/index.js

@@ -1,4 +1,5 @@
 export { ChannelManager } from './ChannelManager.js';
 export { ConfigStore } from './ConfigStore.js';
 export { TelegramAdapter, TELEGRAM_CHANNEL_TYPE, TELEGRAM_MAX_MESSAGE_LENGTH } from './adapters/TelegramAdapter.js';
+
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export { ChannelManager } from './ChannelManager.js';\nexport { ConfigStore } from './ConfigStore.js';\nexport { TelegramAdapter, TELEGRAM_CHANNEL_TYPE, TELEGRAM_MAX_MESSAGE_LENGTH } from './adapters/TelegramAdapter.js';\nexport type { TelegramAdapterOptions } from './adapters/TelegramAdapter.js';\n\nexport type { ChannelAdapter } from './adapters/ChannelAdapter.js';\n\nexport type {\n    IncomingMessage,\n    MessageHandler,\n    ChannelConfig,\n    ChannelEntry,\n    ChannelType,\n    TelegramConfig,\n} from './types.js';\n"],"names":["ChannelManager","ConfigStore","TelegramAdapter","TELEGRAM_CHANNEL_TYPE","TELEGRAM_MAX_MESSAGE_LENGTH"],"mappings":"AAAA,SAASA,cAAc,QAAQ,sBAAsB;AACrD,SAASC,WAAW,QAAQ,mBAAmB;AAC/C,SAASC,eAAe,EAAEC,qBAAqB,EAAEC,2BAA2B,QAAQ,gCAAgC"}

package/dist/types.js

@@ -1,2 +1,8 @@
-export {};
+/**
+ * An incoming message from a messaging platform.
+ * Generic — no agent-specific concepts.
+ */ /**
+ * Telegram-specific configuration.
+ */ export { };
+
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["/**\n * An incoming message from a messaging platform.\n * Generic — no agent-specific concepts.\n */\nexport interface IncomingMessage {\n    channelType: string;\n    chatId: string;\n    userId: string;\n    text: string;\n    timestamp: Date;\n    metadata?: Record<string, unknown>;\n}\n\n/**\n * Handler function provided by the consumer (e.g., CLI).\n * Fire-and-forget — returns void. Responses are sent separately via sendMessage().\n */\nexport type MessageHandler = (message: IncomingMessage) => Promise<void>;\n\n/**\n * Root configuration for all channels.\n */\nexport interface ChannelConfig {\n    channels: Record<string, ChannelEntry>;\n}\n\n/**\n * Configuration entry for a single channel.\n */\nexport interface ChannelEntry {\n    type: ChannelType;\n    enabled: boolean;\n    createdAt: string;\n    config: TelegramConfig;\n}\n\n/**\n * Supported channel types.\n */\nexport type ChannelType = 'telegram' | 'slack' | 'whatsapp';\n\n/**\n * Telegram-specific configuration.\n */\nexport interface TelegramConfig {\n    botToken: string;\n    botUsername: string;\n    authorizedChatId?: number;\n}\n"],"names":[],"mappings":"AAAA;;;CAGC,GAsCD;;CAEC,GACD,WAIC"}