clementine-agent 1.0.0

package/dist/channels/slack-utils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Clementine TypeScript — Shared Slack utilities.
+ *
+ * Extracted from slack.ts so agent bot clients can reuse streaming,
+ * markdown conversion, and chunked sending without importing the monolith.
+ */
+import type { App } from '@slack/bolt';
+export declare const STREAM_UPDATE_INTERVAL = 1500;
+export declare const SLACK_MSG_LIMIT = 3900;
+export declare function mdToSlack(text: string): string;
+export declare function sendChunkedSlack(client: App['client'], channel: string, text: string, threadTs?: string): Promise<void>;
+export declare class SlackStreamingMessage {
+    private client;
+    private channel;
+    private threadTs?;
+    private ts;
+    private lastEdit;
+    private pendingText;
+    private lastFlushedText;
+    private isFinal;
+    private toolStatus;
+    private flushTimer;
+    private progressTimer;
+    private startTime;
+    private toolCallCount;
+    private lastTextTime;
+    /** The message timestamp (available after start). Used for reaction tracking. */
+    get messageTs(): string | null;
+    constructor(client: App['client'], channel: string, threadTs?: string);
+    start(): Promise<void>;
+    /** Update the tool activity status line shown during streaming. */
+    setToolStatus(status: string): void;
+    update(text: string): Promise<void>;
+    finalize(text: string): Promise<void>;
+    /** Format elapsed milliseconds as human-readable duration. */
+    private formatElapsed;
+    private flush;
+}
+//# sourceMappingURL=slack-utils.d.ts.map

package/dist/channels/slack-utils.js

@@ -0,0 +1,189 @@
+/**
+ * Clementine TypeScript — Shared Slack utilities.
+ *
+ * Extracted from slack.ts so agent bot clients can reuse streaming,
+ * markdown conversion, and chunked sending without importing the monolith.
+ */
+export const STREAM_UPDATE_INTERVAL = 1500; // ms
+export const SLACK_MSG_LIMIT = 3900;
+// ── Markdown to Slack mrkdwn ──────────────────────────────────────────
+export function mdToSlack(text) {
+    // Convert Markdown bold **text** to Slack bold *text*
+    return text.replace(/\*\*(.+?)\*\*/g, '*$1*');
+}
+// ── Chunked sending ───────────────────────────────────────────────────
+export async function sendChunkedSlack(client, channel, text, threadTs) {
+    let remaining = text;
+    while (remaining) {
+        if (remaining.length <= SLACK_MSG_LIMIT) {
+            await client.chat.postMessage({ channel, text: remaining, thread_ts: threadTs });
+            break;
+        }
+        let splitAt = remaining.lastIndexOf('\n', SLACK_MSG_LIMIT);
+        if (splitAt === -1)
+            splitAt = SLACK_MSG_LIMIT;
+        await client.chat.postMessage({ channel, text: remaining.slice(0, splitAt), thread_ts: threadTs });
+        remaining = remaining.slice(splitAt).replace(/^\n+/, '');
+    }
+}
+// ── Streaming message ─────────────────────────────────────────────────
+export class SlackStreamingMessage {
+    client;
+    channel;
+    threadTs;
+    ts = null;
+    lastEdit = 0;
+    pendingText = '';
+    lastFlushedText = '';
+    isFinal = false;
+    toolStatus = '';
+    flushTimer = null;
+    progressTimer = null;
+    startTime = Date.now();
+    toolCallCount = 0;
+    lastTextTime = 0;
+    /** The message timestamp (available after start). Used for reaction tracking. */
+    get messageTs() { return this.ts; }
+    constructor(client, channel, threadTs) {
+        this.client = client;
+        this.channel = channel;
+        this.threadTs = threadTs;
+    }
+    async start() {
+        const result = await this.client.chat.postMessage({
+            channel: this.channel,
+            text: ':sparkles: _thinking..._',
+            thread_ts: this.threadTs,
+        });
+        this.ts = result.ts ?? null;
+        this.lastEdit = Date.now();
+        // Periodic refresh keeps elapsed time display current during long silent stretches
+        this.progressTimer = setInterval(() => {
+            if (!this.isFinal && this.toolCallCount > 3)
+                this.flush().catch(() => { });
+        }, 30_000);
+    }
+    /** Update the tool activity status line shown during streaming. */
+    setToolStatus(status) {
+        this.toolStatus = status;
+        this.toolCallCount++;
+        // Trigger a flush so the status is displayed during long tool chains
+        const elapsed = Date.now() - this.lastEdit;
+        if (elapsed >= STREAM_UPDATE_INTERVAL) {
+            this.flush().catch(() => { });
+        }
+        else if (!this.flushTimer) {
+            this.flushTimer = setTimeout(() => {
+                this.flushTimer = null;
+                this.flush().catch(() => { });
+            }, STREAM_UPDATE_INTERVAL - elapsed);
+        }
+    }
+    async update(text) {
+        this.pendingText = text;
+        this.lastTextTime = Date.now();
+        const elapsed = Date.now() - this.lastEdit;
+        if (elapsed >= STREAM_UPDATE_INTERVAL) {
+            await this.flush();
+        }
+        else if (!this.flushTimer) {
+            this.flushTimer = setTimeout(() => {
+                this.flushTimer = null;
+                this.flush().catch(() => { });
+            }, STREAM_UPDATE_INTERVAL - elapsed);
+        }
+    }
+    async finalize(text) {
+        this.isFinal = true;
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        if (this.progressTimer) {
+            clearInterval(this.progressTimer);
+            this.progressTimer = null;
+        }
+        if (!text)
+            text = '_(no response)_';
+        text = mdToSlack(text);
+        if (this.ts) {
+            if (text.length <= SLACK_MSG_LIMIT) {
+                await this.client.chat.update({
+                    channel: this.channel,
+                    ts: this.ts,
+                    text,
+                });
+            }
+            else {
+                await this.client.chat.delete({ channel: this.channel, ts: this.ts }).catch(() => { });
+                await sendChunkedSlack(this.client, this.channel, text, this.threadTs);
+            }
+        }
+        else {
+            await sendChunkedSlack(this.client, this.channel, text, this.threadTs);
+        }
+    }
+    /** Format elapsed milliseconds as human-readable duration. */
+    formatElapsed(ms) {
+        const s = Math.floor(ms / 1000);
+        if (s < 60)
+            return `${s}s`;
+        const m = Math.floor(s / 60);
+        const rem = s % 60;
+        return rem > 0 ? `${m}m ${rem}s` : `${m}m`;
+    }
+    async flush() {
+        if (!this.ts || this.isFinal)
+            return;
+        // Enhanced status when tools have been running 60s+ with no text output
+        const silenceDuration = Date.now() - (this.lastTextTime || this.startTime);
+        const showProgress = this.toolCallCount > 3 && silenceDuration > 60_000;
+        // Skip flush if nothing changed — but always allow when showing progress (elapsed time updates)
+        if (!showProgress) {
+            if (!this.pendingText && !this.toolStatus)
+                return;
+            if (this.pendingText === this.lastFlushedText && !this.toolStatus)
+                return;
+        }
+        let display = mdToSlack(this.pendingText);
+        let statusLine;
+        if (showProgress) {
+            const elapsed = this.formatElapsed(Date.now() - this.startTime);
+            const current = this.toolStatus ? ` \u2014 ${this.toolStatus}` : '';
+            statusLine = `\n\n_:wrench: Working... (${this.toolCallCount} steps, ${elapsed})${current}_`;
+        }
+        else {
+            statusLine = this.toolStatus ? `\n\n_${this.toolStatus}_` : '\n\n:writing_hand: _typing..._';
+        }
+        if (display.length > SLACK_MSG_LIMIT) {
+            display = display.slice(0, SLACK_MSG_LIMIT) + '\n\n_...streaming..._';
+        }
+        else if (display) {
+            display = display + statusLine;
+        }
+        else {
+            // No text yet — show tool status or progress as the main content
+            if (showProgress) {
+                const elapsed = this.formatElapsed(Date.now() - this.startTime);
+                const current = this.toolStatus ? ` \u2014 ${this.toolStatus}` : '';
+                display = `:sparkles: _Working... (${this.toolCallCount} steps, ${elapsed})${current}_`;
+            }
+            else {
+                display = this.toolStatus ? `:sparkles: _${this.toolStatus}_` : ':sparkles: _thinking..._';
+            }
+        }
+        try {
+            await this.client.chat.update({
+                channel: this.channel,
+                ts: this.ts,
+                text: display,
+            });
+            this.lastFlushedText = this.pendingText;
+            this.lastEdit = Date.now();
+        }
+        catch {
+            // Rate limit or message deleted — ignore
+        }
+    }
+}
+//# sourceMappingURL=slack-utils.js.map

package/dist/channels/slack.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Clementine TypeScript — Slack channel adapter.
+ *
+ * Uses @slack/bolt with Socket Mode (no public URL required).
+ * Supports streaming message updates, markdown conversion, and chunked sending.
+ */
+import type { NotificationDispatcher } from '../gateway/notifications.js';
+import type { Gateway } from '../gateway/router.js';
+import type { SlackBotManager } from './slack-bot-manager.js';
+export declare function startSlack(gateway: Gateway, dispatcher: NotificationDispatcher, slackBotManager?: SlackBotManager): Promise<void>;
+//# sourceMappingURL=slack.d.ts.map

package/dist/channels/slack.js

@@ -0,0 +1,196 @@
+/**
+ * Clementine TypeScript — Slack channel adapter.
+ *
+ * Uses @slack/bolt with Socket Mode (no public URL required).
+ * Supports streaming message updates, markdown conversion, and chunked sending.
+ */
+import { App } from '@slack/bolt';
+import pino from 'pino';
+import { SLACK_BOT_TOKEN, SLACK_APP_TOKEN, SLACK_OWNER_USER_ID, VAULT_DIR, } from '../config.js';
+import { mdToSlack, sendChunkedSlack, SlackStreamingMessage } from './slack-utils.js';
+import { friendlyToolName } from './discord-utils.js';
+const logger = pino({ name: 'clementine.slack' });
+const BOT_MESSAGE_TRACKING_LIMIT = 100;
+/** Map of bot message ts -> context for reaction feedback. */
+const slackBotMessageMap = new Map();
+function trackSlackBotMessage(ts, context) {
+    slackBotMessageMap.set(ts, context);
+    if (slackBotMessageMap.size > BOT_MESSAGE_TRACKING_LIMIT) {
+        const firstKey = slackBotMessageMap.keys().next().value;
+        if (firstKey)
+            slackBotMessageMap.delete(firstKey);
+    }
+}
+// ── Lazy memory store for feedback logging ──────────────────────────────
+let _slackFeedbackStore = null;
+async function getSlackFeedbackStore() {
+    if (_slackFeedbackStore)
+        return _slackFeedbackStore;
+    try {
+        const { MemoryStore } = await import('../memory/store.js');
+        const { MEMORY_DB_PATH } = await import('../config.js');
+        const store = new MemoryStore(MEMORY_DB_PATH, VAULT_DIR);
+        store.initialize();
+        _slackFeedbackStore = store;
+        return _slackFeedbackStore;
+    }
+    catch {
+        return null;
+    }
+}
+// ── Slack reaction to rating mapping ────────────────────────────────────
+function slackReactionToRating(reaction) {
+    const positive = ['+1', 'thumbsup', 'heart', 'star', 'tada', 'raised_hands', 'white_check_mark'];
+    const negative = ['-1', 'thumbsdown'];
+    if (positive.includes(reaction))
+        return 'positive';
+    if (negative.includes(reaction))
+        return 'negative';
+    return null;
+}
+// ── Entry point ───────────────────────────────────────────────────────
+export async function startSlack(gateway, dispatcher, slackBotManager) {
+    const app = new App({
+        token: SLACK_BOT_TOKEN,
+        appToken: SLACK_APP_TOKEN,
+        socketMode: true,
+    });
+    // Catch Socket Mode errors so they don't crash the daemon
+    app.error(async (error) => {
+        logger.error({ err: error }, 'Slack app error — continuing');
+    });
+    app.message(async ({ message, client }) => {
+        try {
+            // Type guard: only handle regular user messages
+            if (!('user' in message) || !('text' in message))
+                return;
+            if ('bot_id' in message && message.bot_id)
+                return;
+            if ('subtype' in message && message.subtype)
+                return;
+            // Skip channels owned by agent bots (they handle their own messages)
+            if (slackBotManager?.getOwnedChannelIds().includes(message.channel))
+                return;
+            const userId = message.user;
+            // Owner-only check
+            if (SLACK_OWNER_USER_ID && userId !== SLACK_OWNER_USER_ID) {
+                logger.warn(`Ignored Slack message from non-owner: ${userId}`);
+                return;
+            }
+            let text = message.text ?? '';
+            // Extract file attachments (images and files)
+            const msgFiles = 'files' in message ? message.files : undefined;
+            if (msgFiles && Array.isArray(msgFiles) && msgFiles.length > 0) {
+                const fileLines = msgFiles.map((file) => {
+                    if (file.mimetype?.startsWith('image/')) {
+                        return `[Image attached: ${file.name} (${file.url_private})]`;
+                    }
+                    return `[File attached: ${file.name}, ${file.mimetype || 'unknown type'}, ${file.url_private}]`;
+                });
+                text = fileLines.join('\n') + (text ? '\n' + text : '');
+            }
+            if (!text)
+                return;
+            const channel = message.channel;
+            const threadTs = ('thread_ts' in message ? message.thread_ts : undefined) ?? message.ts;
+            const sessionKey = `slack:user:${userId}`;
+            // ── !stop — abort active query (bypasses session lock) ────────────
+            if (text === '!stop' || text === '/stop') {
+                const stopped = gateway.stopSession(sessionKey);
+                await client.chat.postMessage({ channel, thread_ts: threadTs, text: stopped ? 'Stopping...' : 'Nothing running to stop.' });
+                return;
+            }
+            // ── !verbose command intercept ─────────────────────────────────
+            if (text.startsWith('!verbose')) {
+                const parts = text.split(/\s+/);
+                const level = parts[1]?.toLowerCase();
+                if (level === 'quiet' || level === 'normal' || level === 'detailed') {
+                    gateway.setSessionVerboseLevel(sessionKey, level);
+                    await client.chat.postMessage({ channel, thread_ts: threadTs, text: `Verbose level set to *${level}*.` });
+                }
+                else {
+                    const current = gateway.getSessionVerboseLevel(sessionKey) ?? 'normal';
+                    await client.chat.postMessage({ channel, thread_ts: threadTs, text: `Current verbose level: *${current}*\nOptions: \`!verbose quiet\`, \`!verbose normal\`, \`!verbose detailed\`` });
+                }
+                return;
+            }
+            const streamer = new SlackStreamingMessage(client, channel, threadTs);
+            await streamer.start();
+            try {
+                const response = await gateway.handleMessage(sessionKey, text, (t) => streamer.update(t), undefined, // model
+                undefined, // maxTurns
+                async (toolName, toolInput) => { streamer.setToolStatus(friendlyToolName(toolName, toolInput)); });
+                await streamer.finalize(response);
+                // Track bot message for feedback reactions
+                if (streamer.messageTs) {
+                    trackSlackBotMessage(streamer.messageTs, {
+                        sessionKey,
+                        userMessage: text.slice(0, 500),
+                        botResponse: response.slice(0, 500),
+                        channel,
+                    });
+                }
+            }
+            catch (err) {
+                logger.error({ err }, 'Error processing Slack message');
+                await streamer.finalize(`Something went wrong: ${err}`);
+            }
+        }
+        catch (err) {
+            logger.error({ err }, 'Unhandled error in Slack message handler');
+        }
+    });
+    // ── Reaction-based feedback handler ─────────────────────────────────
+    app.event('reaction_added', async ({ event }) => {
+        // Owner-only
+        if (SLACK_OWNER_USER_ID && event.user !== SLACK_OWNER_USER_ID)
+            return;
+        // Check if reaction is on a tracked bot message
+        const itemTs = 'ts' in event.item ? event.item.ts : undefined;
+        if (!itemTs)
+            return;
+        const context = slackBotMessageMap.get(itemTs);
+        if (!context)
+            return;
+        // Map reaction to rating
+        const rating = slackReactionToRating(event.reaction);
+        if (!rating)
+            return;
+        // Log feedback
+        try {
+            const store = await getSlackFeedbackStore();
+            if (store) {
+                store.logFeedback({
+                    sessionKey: context.sessionKey,
+                    channel: 'slack',
+                    messageSnippet: context.userMessage,
+                    responseSnippet: context.botResponse,
+                    rating,
+                });
+                logger.info({ rating, ts: itemTs }, 'Feedback logged via Slack reaction');
+            }
+        }
+        catch (err) {
+            logger.warn({ err }, 'Failed to log Slack reaction feedback');
+        }
+    });
+    // Register notification sender
+    async function slackNotify(text) {
+        if (!SLACK_OWNER_USER_ID)
+            return;
+        try {
+            const dm = await app.client.conversations.open({ users: SLACK_OWNER_USER_ID });
+            const channelId = dm.channel?.id;
+            if (channelId) {
+                await sendChunkedSlack(app.client, channelId, mdToSlack(text));
+            }
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to send Slack notification');
+        }
+    }
+    dispatcher.register('slack', slackNotify);
+    logger.info('Starting Slack bot (Socket Mode)...');
+    await app.start();
+}
+//# sourceMappingURL=slack.js.map

package/dist/channels/telegram.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Clementine TypeScript — Telegram channel adapter.
+ *
+ * Uses grammY for long polling. Supports streaming message edits,
+ * markdown conversion, message chunking, and voice message handling (placeholder).
+ */
+import type { NotificationDispatcher } from '../gateway/notifications.js';
+import type { Gateway } from '../gateway/router.js';
+export declare function startTelegram(gateway: Gateway, dispatcher: NotificationDispatcher): Promise<void>;
+//# sourceMappingURL=telegram.d.ts.map

package/dist/channels/telegram.js

@@ -0,0 +1,235 @@
+/**
+ * Clementine TypeScript — Telegram channel adapter.
+ *
+ * Uses grammY for long polling. Supports streaming message edits,
+ * markdown conversion, message chunking, and voice message handling (placeholder).
+ */
+import { Bot } from 'grammy';
+import pino from 'pino';
+import { TELEGRAM_BOT_TOKEN, TELEGRAM_OWNER_ID, } from '../config.js';
+const logger = pino({ name: 'clementine.telegram' });
+const STREAM_UPDATE_INTERVAL = 1500; // ms
+const TELEGRAM_MSG_LIMIT = 4096;
+// ── Markdown conversion ───────────────────────────────────────────────
+function mdToTelegram(text) {
+    // Convert Markdown bold **text** to single-asterisk for plain text mode
+    return text.replace(/\*\*(.+?)\*\*/g, '*$1*');
+}
+// ── Chunked sending ───────────────────────────────────────────────────
+async function sendChunked(bot, chatId, text) {
+    let remaining = text;
+    while (remaining) {
+        if (remaining.length <= TELEGRAM_MSG_LIMIT) {
+            await bot.api.sendMessage(chatId, remaining);
+            break;
+        }
+        let splitAt = remaining.lastIndexOf('\n', TELEGRAM_MSG_LIMIT);
+        if (splitAt === -1)
+            splitAt = TELEGRAM_MSG_LIMIT;
+        await bot.api.sendMessage(chatId, remaining.slice(0, splitAt));
+        remaining = remaining.slice(splitAt).replace(/^\n+/, '');
+    }
+}
+// ── Streaming message ─────────────────────────────────────────────────
+class TelegramStreamingMessage {
+    bot;
+    chatId;
+    messageId = null;
+    lastEdit = 0;
+    pendingText = '';
+    isFinal = false;
+    constructor(bot, chatId) {
+        this.bot = bot;
+        this.chatId = chatId;
+    }
+    async start() {
+        const msg = await this.bot.api.sendMessage(this.chatId, '\u2728 _thinking\\.\\.\\._', { parse_mode: 'MarkdownV2' });
+        this.messageId = msg.message_id;
+        this.lastEdit = Date.now();
+    }
+    async update(text) {
+        this.pendingText = text;
+        if (Date.now() - this.lastEdit >= STREAM_UPDATE_INTERVAL) {
+            await this.flush();
+        }
+    }
+    async finalize(text) {
+        this.isFinal = true;
+        if (!text)
+            text = '_(no response)_';
+        text = mdToTelegram(text);
+        if (this.messageId) {
+            if (text.length <= TELEGRAM_MSG_LIMIT) {
+                try {
+                    await this.bot.api.editMessageText(this.chatId, this.messageId, text);
+                }
+                catch {
+                    // If edit fails (message unchanged), send new
+                    await sendChunked(this.bot, this.chatId, text);
+                }
+            }
+            else {
+                // Delete placeholder and send in chunks
+                try {
+                    await this.bot.api.deleteMessage(this.chatId, this.messageId);
+                }
+                catch {
+                    // Ignore delete failure
+                }
+                await sendChunked(this.bot, this.chatId, text);
+            }
+        }
+        else {
+            await sendChunked(this.bot, this.chatId, text);
+        }
+    }
+    async flush() {
+        if (this.messageId === null || !this.pendingText || this.isFinal)
+            return;
+        let display = mdToTelegram(this.pendingText);
+        if (display.length > TELEGRAM_MSG_LIMIT - 20) {
+            display = display.slice(0, TELEGRAM_MSG_LIMIT - 20) + '\n\n...streaming...';
+        }
+        else {
+            display = display + '\n\n\u270d\ufe0f typing...';
+        }
+        try {
+            await this.bot.api.editMessageText(this.chatId, this.messageId, display);
+            this.lastEdit = Date.now();
+        }
+        catch {
+            // Rate limit or message unchanged — ignore
+        }
+    }
+}
+// ── Entry point ───────────────────────────────────────────────────────
+export async function startTelegram(gateway, dispatcher) {
+    const bot = new Bot(TELEGRAM_BOT_TOKEN);
+    const ownerIdNum = Number(TELEGRAM_OWNER_ID);
+    // Catch errors from Grammy so they don't crash the daemon
+    bot.catch((err) => {
+        logger.error({ err: err.error, ctx: err.ctx?.update?.update_id }, 'Telegram bot error — continuing');
+    });
+    bot.on('message:text', async (ctx) => {
+        const userId = ctx.from?.id;
+        if (!userId)
+            return;
+        // Owner-only check
+        if (TELEGRAM_OWNER_ID && userId !== ownerIdNum) {
+            logger.warn(`Ignored Telegram message from non-owner: ${userId}`);
+            return;
+        }
+        const text = ctx.message.text ?? '';
+        if (!text)
+            return;
+        const chatId = ctx.chat.id;
+        const sessionKey = `telegram:user:${userId}`;
+        // ── Approval responses ──────────────────────────────────────────
+        const lower = text.toLowerCase().trim();
+        if (['yes', 'no', 'approve', 'deny', 'go', 'skip', 'always'].includes(lower)) {
+            const approvals = gateway.getPendingApprovals();
+            if (approvals.length > 0) {
+                const result = lower === 'always' ? 'always' :
+                    (lower === 'yes' || lower === 'approve' || lower === 'go');
+                gateway.resolveApproval(approvals[approvals.length - 1], result);
+                const approved = result !== false;
+                await ctx.reply(approved ? '✅ Approved.' : '❌ Denied.');
+                return;
+            }
+        }
+        const streamer = new TelegramStreamingMessage(bot, chatId);
+        await streamer.start();
+        try {
+            const response = await gateway.handleMessage(sessionKey, text, (t) => streamer.update(t));
+            await streamer.finalize(response);
+        }
+        catch (err) {
+            logger.error({ err }, 'Error processing Telegram message');
+            await streamer.finalize(`Something went wrong: ${err}`);
+        }
+    });
+    // Photo message handler — extracts image URL and forwards to gateway
+    bot.on('message:photo', async (ctx) => {
+        const userId = ctx.from?.id;
+        if (!userId)
+            return;
+        if (TELEGRAM_OWNER_ID && userId !== ownerIdNum)
+            return;
+        // Get the largest photo size (last in the array)
+        const photo = ctx.message.photo[ctx.message.photo.length - 1];
+        const file = await ctx.api.getFile(photo.file_id);
+        const fileUrl = `https://api.telegram.org/file/bot${TELEGRAM_BOT_TOKEN}/${file.file_path}`;
+        const caption = ctx.message.caption || '';
+        const text = `[Image attached: photo (${fileUrl})]\n${caption}`.trim();
+        const chatId = ctx.chat.id;
+        const sessionKey = `telegram:user:${userId}`;
+        const streamer = new TelegramStreamingMessage(bot, chatId);
+        await streamer.start();
+        try {
+            const response = await gateway.handleMessage(sessionKey, text, (t) => streamer.update(t));
+            await streamer.finalize(response);
+        }
+        catch (err) {
+            logger.error({ err }, 'Error processing Telegram photo');
+            await streamer.finalize(`Something went wrong: ${err}`);
+        }
+    });
+    // Document message handler — extracts file URL and forwards to gateway
+    bot.on('message:document', async (ctx) => {
+        const userId = ctx.from?.id;
+        if (!userId)
+            return;
+        if (TELEGRAM_OWNER_ID && userId !== ownerIdNum)
+            return;
+        const doc = ctx.message.document;
+        const file = await ctx.api.getFile(doc.file_id);
+        const fileUrl = `https://api.telegram.org/file/bot${TELEGRAM_BOT_TOKEN}/${file.file_path}`;
+        const caption = ctx.message.caption || '';
+        const isImage = doc.mime_type?.startsWith('image/');
+        const prefix = isImage
+            ? `[Image attached: ${doc.file_name} (${fileUrl})]`
+            : `[File attached: ${doc.file_name}, ${doc.mime_type || 'unknown type'}, ${fileUrl}]`;
+        const text = `${prefix}\n${caption}`.trim();
+        const chatId = ctx.chat.id;
+        const sessionKey = `telegram:user:${userId}`;
+        const streamer = new TelegramStreamingMessage(bot, chatId);
+        await streamer.start();
+        try {
+            const response = await gateway.handleMessage(sessionKey, text, (t) => streamer.update(t));
+            await streamer.finalize(response);
+        }
+        catch (err) {
+            logger.error({ err }, 'Error processing Telegram document');
+            await streamer.finalize(`Something went wrong: ${err}`);
+        }
+    });
+    // Voice message handler (placeholder — note for future STT integration)
+    bot.on('message:voice', async (ctx) => {
+        const userId = ctx.from?.id;
+        if (!userId)
+            return;
+        if (TELEGRAM_OWNER_ID && userId !== ownerIdNum)
+            return;
+        // TODO: Download voice file, transcribe via Groq Whisper STT
+        await ctx.reply('Voice messages are not yet supported in this version.');
+    });
+    // Register notification sender
+    async function telegramNotify(text) {
+        if (!TELEGRAM_OWNER_ID || ownerIdNum === 0)
+            return;
+        try {
+            const notifyText = mdToTelegram(text);
+            await sendChunked(bot, ownerIdNum, notifyText);
+        }
+        catch (err) {
+            logger.error({ err }, 'Failed to send Telegram notification');
+        }
+    }
+    dispatcher.register('telegram', telegramNotify);
+    logger.info('Starting Telegram bot (long polling)...');
+    await bot.start({
+        drop_pending_updates: true,
+        onStart: () => logger.info('Telegram bot polling started'),
+    });
+}
+//# sourceMappingURL=telegram.js.map