@foxden-app/foxclaw 0.12.0 → 0.13.0

package/dist/telegram/gateway.js

@@ -1,3 +1,4 @@
+import { setTimeout as delay } from 'node:timers/promises';
 import { EventEmitter } from 'node:events';
 import crypto from 'node:crypto';
 import { callTelegramApi, callTelegramMultipartApi, downloadTelegramFile, getTelegramFile } from './api.js';
@@ -13,7 +14,28 @@ export class TelegramGateway extends EventEmitter {
     logger;
     namespacedScopes;
     commandProvider;
+    inboundConsumer = null;
+    generations = new Map();
+    setInboundConsumer(consumer) {
+        if (this.inboundConsumer && this.inboundConsumer !== consumer)
+            throw new Error('Telegram inbound consumer already owned');
+        this.inboundConsumer = consumer;
+        return () => { if (this.inboundConsumer === consumer)
+            this.inboundConsumer = null; };
+    }
+    registerGeneration(draftId, scopeId, taskId, chatId, topicId) {
+        this.generations.set(draftId, { scopeId, taskId, chatId, topicId });
+    }
+    releaseGeneration(draftId) { this.generations.delete(draftId); }
+    async dispatchInbound(updateId, inbound) {
+        if (this.inboundConsumer)
+            await this.inboundConsumer(`${this.botKey}:${updateId}`, inbound);
+        else
+            this.emit(inbound.kind, inbound.event);
+    }
     running = false;
+    polling = null;
+    pollAbort = null;
     botKey;
     botUsername = null;
     botUserId = null;
@@ -57,11 +79,16 @@ export class TelegramGateway extends EventEmitter {
     async start() {
         if (this.running)
             return;
+        await this.polling;
         this.running = true;
-        void this.pollLoop();
+        this.pollAbort = new AbortController();
+        this.polling = this.pollLoop();
     }
-    stop() {
+    async stop() {
         this.running = false;
+        this.pollAbort?.abort();
+        await this.polling;
+        this.generations.clear();
     }
     async sendMessage(chatId, text, inlineKeyboard, messageThreadId) {
         return this.sendMessageWithOptions(chatId, text, inlineKeyboard, undefined, messageThreadId);
@@ -124,11 +151,12 @@ export class TelegramGateway extends EventEmitter {
             throw new Error(result.description || 'Failed to send Telegram draft message');
         }
     }
-    async sendRichMessageDraft(chatId, draftId, richMessage, messageThreadId) {
+    async sendRichMessageDraft(chatId, draftId, richMessage, messageThreadId, canStop = false) {
         const result = await callTelegramApi(this.botToken, 'sendRichMessageDraft', {
             chat_id: chatId,
             draft_id: draftId,
             rich_message: richMessage,
+            ...(canStop ? { can_stop: true, keep_on_stop: true } : {}),
             ...(messageThreadId !== null && messageThreadId !== undefined ? { message_thread_id: messageThreadId } : {}),
         });
         if (!result.ok) {
@@ -223,8 +251,8 @@ export class TelegramGateway extends EventEmitter {
     async downloadResolvedFile(remoteFilePath, destinationPath) {
         return downloadTelegramFile(this.botToken, remoteFilePath, destinationPath);
     }
-    async resolveBotIdentity(required = false) {
-        const result = await callTelegramApi(this.botToken, 'getMe', {});
+    async resolveBotIdentity(required = false, signal) {
+        const result = await callTelegramApi(this.botToken, 'getMe', {}, signal);
         if (result.ok && result.result) {
             this.botKey = `telegram:bot${result.result.id}`;
             this.botUserId = result.result.id;
@@ -235,18 +263,18 @@ export class TelegramGateway extends EventEmitter {
             throw new Error(result.description || 'Failed to resolve Telegram bot identity');
         }
     }
-    async registerCommands() {
+    async registerCommands(signal) {
         await callTelegramApi(this.botToken, 'setMyCommands', {
             commands: this.commandProvider('zh'),
-        });
+        }, signal);
         await callTelegramApi(this.botToken, 'setMyCommands', {
             commands: this.commandProvider('en'),
             language_code: 'en',
-        });
+        }, signal);
         await callTelegramApi(this.botToken, 'setMyCommands', {
             commands: this.commandProvider('zh'),
             language_code: 'zh',
-        });
+        }, signal);
     }
     async setChatCommands(chatId, commands) {
         try {
@@ -261,11 +289,14 @@ export class TelegramGateway extends EventEmitter {
     }
     async pollLoop() {
         let remoteInitialized = false;
+        const signal = this.pollAbort?.signal;
         while (this.running) {
             try {
                 if (!remoteInitialized) {
-                    await this.resolveBotIdentity(true);
-                    await this.registerCommands();
+                    await this.resolveBotIdentity(true, signal);
+                    if (!this.running)
+                        return;
+                    await this.registerCommands(signal);
                     remoteInitialized = true;
                     this.emit('remoteReady');
                     if (!this.running)
@@ -275,25 +306,40 @@ export class TelegramGateway extends EventEmitter {
                 const result = await callTelegramApi(this.botToken, 'getUpdates', {
                     timeout: Math.max(1, Math.floor(this.pollIntervalMs / 1000)),
                     offset,
-                    allowed_updates: ['message', 'callback_query']
-                });
+                    allowed_updates: ['message', 'callback_query', 'stopped_message_generation']
+                }, signal);
+                if (!this.running)
+                    return;
                 if (!result.ok || !result.result) {
                     this.logger.warn('telegram.getUpdates failed', result.description);
-                    await sleep(this.pollIntervalMs);
+                    await delay(this.pollIntervalMs, undefined, { signal }).catch(() => { });
                     continue;
                 }
                 for (const update of result.result) {
-                    this.store.setTelegramOffset(this.botKey, update.update_id);
+                    if (!this.running)
+                        return;
                     await this.handleUpdate(update);
+                    this.store.setTelegramOffset(this.botKey, update.update_id);
                 }
             }
             catch (error) {
+                if (!this.running)
+                    return;
                 this.logger.error('telegram.pollLoop error', toErrorMeta(error));
-                await sleep(this.pollIntervalMs);
+                await delay(this.pollIntervalMs, undefined, { signal }).catch(() => { });
             }
         }
     }
     async handleUpdate(update) {
+        const stopped = update.stopped_message_generation;
+        if (stopped) {
+            const generation = this.generations.get(stopped.draft_id);
+            // Native drafts are private-chat only; the private chat id identifies the authorized user.
+            if (!generation || stopped.chat.type !== 'private' || String(stopped.chat.id) !== this.allowedUserId || generation.chatId !== String(stopped.chat.id) || generation.topicId !== (stopped.message_thread_id ?? null))
+                return;
+            await this.dispatchInbound(update.update_id, { kind: 'stop', event: { scopeId: generation.scopeId, taskId: generation.taskId } });
+            return;
+        }
         if (update.message && update.message.from && this.isAllowedChat(update.message.chat)) {
             if (String(update.message.from.id) !== this.allowedUserId) {
                 if (update.message.chat.type === 'private') {
@@ -320,20 +366,20 @@ export class TelegramGateway extends EventEmitter {
             const entities = update.message.text ? (update.message.entities ?? []) : (update.message.caption_entities ?? []);
             const replyToBot = this.botUserId !== null && update.message.reply_to_message?.from?.id === this.botUserId;
             if (text || attachments.length > 0) {
-                this.emit('text', {
-                    chatId: String(update.message.chat.id),
-                    topicId,
-                    scopeId,
-                    chatType: update.message.chat.type,
-                    userId: String(update.message.from.id),
-                    text,
-                    messageId: update.message.message_id,
-                    mediaGroupId: update.message.media_group_id ?? null,
-                    attachments,
-                    entities,
-                    replyToBot,
-                    ...(update.message.from.language_code ? { languageCode: update.message.from.language_code } : {}),
-                });
+                await this.dispatchInbound(update.update_id, { kind: 'text', event: {
+                        chatId: String(update.message.chat.id),
+                        topicId,
+                        scopeId,
+                        chatType: update.message.chat.type,
+                        userId: String(update.message.from.id),
+                        text,
+                        messageId: update.message.message_id,
+                        mediaGroupId: update.message.media_group_id ?? null,
+                        attachments,
+                        entities,
+                        replyToBot,
+                        ...(update.message.from.language_code ? { languageCode: update.message.from.language_code } : {}),
+                    } });
                 if (update.message.chat.type === 'private' && this.identity) {
                     this.store.rememberTelegramPrivateScope(this.identity, scopeId, String(update.message.chat.id));
                 }
@@ -346,16 +392,16 @@ export class TelegramGateway extends EventEmitter {
             if (!this.isAllowedChat(update.callback_query.message.chat))
                 return;
             const topicId = update.callback_query.message.message_thread_id ?? null;
-            this.emit('callback', {
-                chatId: String(update.callback_query.message.chat.id),
-                topicId,
-                scopeId: toTelegramBridgeScopeId(createTelegramScopeId(String(update.callback_query.message.chat.id), topicId), this.namespacedScopes ? this.identity : null),
-                userId: String(update.callback_query.from.id),
-                data: update.callback_query.data,
-                callbackQueryId: update.callback_query.id,
-                messageId: update.callback_query.message.message_id,
-                ...(update.callback_query.from.language_code ? { languageCode: update.callback_query.from.language_code } : {}),
-            });
+            await this.dispatchInbound(update.update_id, { kind: 'callback', event: {
+                    chatId: String(update.callback_query.message.chat.id),
+                    topicId,
+                    scopeId: toTelegramBridgeScopeId(createTelegramScopeId(String(update.callback_query.message.chat.id), topicId), this.namespacedScopes ? this.identity : null),
+                    userId: String(update.callback_query.from.id),
+                    data: update.callback_query.data,
+                    callbackQueryId: update.callback_query.id,
+                    messageId: update.callback_query.message.message_id,
+                    ...(update.callback_query.from.language_code ? { languageCode: update.callback_query.from.language_code } : {}),
+                } });
         }
     }
     isAllowedChat(chat) {
@@ -368,9 +414,6 @@ export class TelegramGateway extends EventEmitter {
         return false;
     }
 }
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
 export function parseTelegramBotId(botToken) {
     const match = /^(\d+):/.exec(botToken.trim());
     if (!match)

package/dist/telegram/media.d.ts

@@ -1,34 +1,2 @@
-export declare const TELEGRAM_INBOX_DIR = ".telegram-inbox";
-export declare const TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES: number;
-export type TelegramAttachmentKind = 'photo' | 'document' | 'audio' | 'voice' | 'video' | 'animation' | 'sticker' | 'videoNote';
-export interface TelegramInboundAttachment {
-    kind: TelegramAttachmentKind;
-    fileId: string;
-    fileUniqueId: string;
-    fileName: string | null;
-    mimeType: string | null;
-    fileSize: number | null;
-    width: number | null;
-    height: number | null;
-    durationSeconds: number | null;
-    isAnimated: boolean;
-    isVideo: boolean;
-    /** When set, {@link stageAttachments} copies this file instead of Telegram Bot API download. */
-    localPath?: string;
-}
-export interface StagedTelegramAttachment extends TelegramInboundAttachment {
-    fileName: string;
-    localPath: string;
-    relativePath: string;
-    nativeImage: boolean;
-}
-interface PlannedAttachmentPath {
-    fileName: string;
-    localPath: string;
-    relativePath: string;
-}
-export declare function isNativeImageAttachment(attachment: TelegramInboundAttachment): boolean;
-export declare function planAttachmentStoragePath(cwd: string, threadId: string, attachment: TelegramInboundAttachment, remoteFilePath?: string | null, now?: Date): PlannedAttachmentPath;
-export declare function buildAttachmentPrompt(userText: string, attachments: readonly StagedTelegramAttachment[]): string;
-export declare function summarizeTelegramInput(text: string, attachments: readonly TelegramInboundAttachment[]): string;
-export {};
+export type { AttachmentKind as TelegramAttachmentKind, InboundAttachment as TelegramInboundAttachment, StagedAttachment as StagedTelegramAttachment } from '../core/attachment_types.js';
+export { ATTACHMENT_INBOX_DIR as TELEGRAM_INBOX_DIR, DEFAULT_REMOTE_DOWNLOAD_LIMIT_BYTES as TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES, isNativeImageAttachment, planAttachmentStoragePath, buildAttachmentPrompt, summarizeInput as summarizeTelegramInput } from '../core/attachment_files.js';

package/dist/telegram/media.js

@@ -1,180 +1 @@
-import path from 'node:path';
-export const TELEGRAM_INBOX_DIR = '.telegram-inbox';
-export const TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES = 20 * 1024 * 1024;
-const FALLBACK_EXTENSION_BY_KIND = {
-    photo: '.jpg',
-    document: '',
-    audio: '.mp3',
-    voice: '.ogg',
-    video: '.mp4',
-    animation: '.mp4',
-    sticker: '.webp',
-    videoNote: '.mp4',
-};
-const MIME_EXTENSION_MAP = {
-    'application/gzip': '.gz',
-    'application/json': '.json',
-    'application/pdf': '.pdf',
-    'application/zip': '.zip',
-    'audio/mpeg': '.mp3',
-    'audio/mp4': '.m4a',
-    'audio/ogg': '.ogg',
-    'audio/wav': '.wav',
-    'image/gif': '.gif',
-    'image/jpeg': '.jpg',
-    'image/png': '.png',
-    'image/webp': '.webp',
-    'text/csv': '.csv',
-    'text/html': '.html',
-    'text/markdown': '.md',
-    'text/plain': '.txt',
-    'video/mp4': '.mp4',
-    'video/quicktime': '.mov',
-};
-export function isNativeImageAttachment(attachment) {
-    if (attachment.kind === 'photo') {
-        return true;
-    }
-    if (attachment.kind === 'sticker') {
-        return !attachment.isAnimated && !attachment.isVideo;
-    }
-    if (attachment.kind !== 'document') {
-        return false;
-    }
-    const lowerMime = attachment.mimeType?.toLowerCase() ?? '';
-    if (lowerMime === 'image/jpeg' || lowerMime === 'image/png' || lowerMime === 'image/webp' || lowerMime === 'image/gif') {
-        return true;
-    }
-    const extension = extensionFromName(attachment.fileName);
-    return extension === '.jpg' || extension === '.jpeg' || extension === '.png' || extension === '.webp' || extension === '.gif';
-}
-export function planAttachmentStoragePath(cwd, threadId, attachment, remoteFilePath, now = new Date()) {
-    const dateSegment = now.toISOString().slice(0, 10);
-    const threadSegment = sanitizePathSegment(threadId);
-    const timestamp = now.toISOString().slice(0, 19).replace(/[-:]/g, '').replace('T', '-');
-    const resolvedFileName = resolveAttachmentFileName(attachment, remoteFilePath);
-    const uniquePrefix = `${timestamp}-${sanitizePathSegment(attachment.fileUniqueId).slice(0, 16)}`;
-    const joinedName = truncateFileName(`${uniquePrefix}-${resolvedFileName}`, 160);
-    const relativePath = path.join(TELEGRAM_INBOX_DIR, dateSegment, threadSegment, joinedName);
-    return {
-        fileName: resolvedFileName,
-        localPath: path.resolve(cwd, relativePath),
-        relativePath,
-    };
-}
-export function buildAttachmentPrompt(userText, attachments) {
-    const normalizedText = userText.trim();
-    const lines = [];
-    if (normalizedText) {
-        lines.push(normalizedText, '');
-    }
-    else {
-        lines.push('User sent Telegram attachments without a caption.', '');
-    }
-    lines.push('Telegram attachments:');
-    attachments.forEach((attachment, index) => {
-        lines.push(`${index + 1}. ${describeAttachment(attachment)}`);
-        lines.push(`   filename: ${attachment.fileName}`);
-        lines.push(`   path: ${attachment.localPath}`);
-        if (attachment.mimeType)
-            lines.push(`   mime: ${attachment.mimeType}`);
-        if (attachment.fileSize !== null)
-            lines.push(`   size_bytes: ${attachment.fileSize}`);
-        if (attachment.width !== null && attachment.height !== null) {
-            lines.push(`   dimensions: ${attachment.width}x${attachment.height}`);
-        }
-        if (attachment.durationSeconds !== null) {
-            lines.push(`   duration_seconds: ${attachment.durationSeconds}`);
-        }
-        if (attachment.nativeImage) {
-            lines.push('   attached_as: localImage');
-        }
-    });
-    lines.push('', 'Use the local file paths above when you inspect these attachments.');
-    return lines.join('\n');
-}
-export function summarizeTelegramInput(text, attachments) {
-    const lines = [];
-    const normalizedText = text.trim();
-    if (normalizedText) {
-        lines.push(normalizedText);
-    }
-    if (attachments.length > 0) {
-        lines.push(`[attachments: ${attachments.map((attachment) => `${attachment.kind}:${attachment.fileName ?? attachment.fileUniqueId}`).join(', ')}]`);
-    }
-    return truncateSummary(lines.join(' '), 500);
-}
-function resolveAttachmentFileName(attachment, remoteFilePath) {
-    const providedName = attachment.fileName ? path.basename(attachment.fileName) : '';
-    const remoteName = remoteFilePath ? path.basename(remoteFilePath) : '';
-    const baseCandidate = providedName || remoteName || `${attachment.kind}-${attachment.fileUniqueId}`;
-    const sanitizedBase = sanitizeFileName(baseCandidate);
-    const extension = extensionFromName(sanitizedBase)
-        || extensionFromName(remoteName)
-        || extensionFromMimeType(attachment.mimeType)
-        || fallbackExtensionByKind(attachment.kind);
-    if (!extension) {
-        return sanitizedBase;
-    }
-    const withoutExtension = sanitizedBase.slice(0, sanitizedBase.length - extensionFromName(sanitizedBase).length) || `${attachment.kind}-${attachment.fileUniqueId}`;
-    return truncateFileName(`${withoutExtension}${extension}`, 120);
-}
-function describeAttachment(attachment) {
-    switch (attachment.kind) {
-        case 'photo':
-            return 'photo';
-        case 'document':
-            return 'document';
-        case 'audio':
-            return 'audio file';
-        case 'voice':
-            return 'voice message';
-        case 'video':
-            return 'video';
-        case 'animation':
-            return 'animation';
-        case 'sticker':
-            return attachment.isAnimated || attachment.isVideo ? 'animated sticker' : 'sticker';
-        case 'videoNote':
-            return 'video note';
-    }
-}
-function sanitizeFileName(fileName) {
-    const trimmed = fileName.trim().replace(/[\\/]+/g, '-');
-    const sanitized = trimmed
-        .replace(/[^\w.\-()+@]+/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^\.+/, '')
-        .replace(/^-+/, '')
-        .replace(/[.-]+$/, '');
-    return sanitized || 'attachment';
-}
-function sanitizePathSegment(value) {
-    return value.replace(/[^\w.-]+/g, '-').replace(/-+/g, '-').replace(/^-+|-+$/g, '') || 'thread';
-}
-function extensionFromMimeType(mimeType) {
-    if (!mimeType)
-        return '';
-    return MIME_EXTENSION_MAP[mimeType.toLowerCase()] ?? '';
-}
-function extensionFromName(fileName) {
-    if (!fileName)
-        return '';
-    const extension = path.extname(fileName).toLowerCase();
-    return extension === '.' ? '' : extension;
-}
-function truncateFileName(fileName, maxLength) {
-    if (fileName.length <= maxLength)
-        return fileName;
-    const extension = extensionFromName(fileName);
-    const base = extension ? fileName.slice(0, -extension.length) : fileName;
-    return `${base.slice(0, Math.max(1, maxLength - extension.length))}${extension}`;
-}
-function truncateSummary(text, maxLength) {
-    if (text.length <= maxLength)
-        return text;
-    return `${text.slice(0, maxLength - 3)}...`;
-}
-function fallbackExtensionByKind(kind) {
-    return FALLBACK_EXTENSION_BY_KIND[kind] ?? '';
-}
+export { ATTACHMENT_INBOX_DIR as TELEGRAM_INBOX_DIR, DEFAULT_REMOTE_DOWNLOAD_LIMIT_BYTES as TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES, isNativeImageAttachment, planAttachmentStoragePath, buildAttachmentPrompt, summarizeInput as summarizeTelegramInput } from '../core/attachment_files.js';

package/dist/telegram/task_preview.d.ts

@@ -0,0 +1,13 @@
+import type { TelegramGateway } from './gateway.js';
+/** Owns live drafts and fallback cards; draft ids are never persistent message ids. */
+export declare class TelegramTaskPreviews {
+    private readonly gateway;
+    private readonly previews;
+    private readonly draftIds;
+    constructor(gateway: TelegramGateway);
+    private keyboard;
+    private sendCard;
+    begin(scopeId: string, taskId: string, text: string, reuseMessageId?: number): Promise<number>;
+    update(scopeId: string, taskId: string, messageId: number, html: string): Promise<number>;
+    end(scopeId: string, taskId: string): Promise<void>;
+}

package/dist/telegram/task_preview.js

@@ -0,0 +1,92 @@
+import { randomInt } from 'node:crypto';
+import { parseTelegramTargetFromBridgeScope } from '../core/bridge_scope.js';
+import { telegramRichHtml } from './rich.js';
+import { renderTelegramMarkdownRichHtml } from './rich_markdown.js';
+/** Owns live drafts and fallback cards; draft ids are never persistent message ids. */
+export class TelegramTaskPreviews {
+    gateway;
+    previews = new Map();
+    draftIds = new Set();
+    constructor(gateway) {
+        this.gateway = gateway;
+    }
+    keyboard(taskId) { return [[{ text: '🛑 停止 / Stop', callback_data: `engine:stop:${taskId}` }]]; }
+    async sendCard(scopeId, taskId, html) {
+        const target = parseTelegramTargetFromBridgeScope(scopeId);
+        try {
+            return await this.gateway.sendRichMessage(target.chatId, telegramRichHtml(html), this.keyboard(taskId), target.topicId);
+        }
+        catch {
+            return this.gateway.sendHtmlMessage(target.chatId, html.replace(/<\/?p>/g, ''), this.keyboard(taskId), target.topicId);
+        }
+    }
+    async begin(scopeId, taskId, text, reuseMessageId = 0) {
+        const target = parseTelegramTargetFromBridgeScope(scopeId);
+        const html = renderTelegramMarkdownRichHtml(text);
+        const preview = { scopeId, draftId: null, messageId: reuseMessageId };
+        this.previews.set(taskId, preview);
+        if (reuseMessageId > 0) {
+            await this.gateway.editRichMessage(target.chatId, reuseMessageId, telegramRichHtml(html), this.keyboard(taskId));
+            return reuseMessageId;
+        }
+        if (/^[1-9]\d*$/.test(target.chatId)) {
+            let draftId = randomInt(1, 2 ** 31);
+            while (this.draftIds.has(draftId))
+                draftId = randomInt(1, 2 ** 31);
+            this.draftIds.add(draftId);
+            preview.draftId = draftId;
+            this.gateway.registerGeneration(draftId, scopeId, taskId, target.chatId, target.topicId);
+            try {
+                await this.gateway.sendRichMessageDraft(target.chatId, draftId, telegramRichHtml(html), target.topicId, true);
+                return 0;
+            }
+            catch {
+                this.gateway.releaseGeneration(draftId);
+                this.draftIds.delete(draftId);
+                preview.draftId = null;
+            }
+        }
+        preview.messageId = await this.sendCard(scopeId, taskId, html);
+        return preview.messageId;
+    }
+    async update(scopeId, taskId, messageId, html) {
+        const preview = this.previews.get(taskId);
+        if (!preview || preview.scopeId !== scopeId)
+            return messageId;
+        const target = parseTelegramTargetFromBridgeScope(scopeId);
+        if (preview.draftId !== null) {
+            try {
+                await this.gateway.sendRichMessageDraft(target.chatId, preview.draftId, telegramRichHtml(html), target.topicId, true);
+                return 0;
+            }
+            catch {
+                const draftId = preview.draftId;
+                this.gateway.releaseGeneration(draftId);
+                this.draftIds.delete(draftId);
+                preview.draftId = null;
+                await this.gateway.sendMessageDraft(target.chatId, draftId, '', target.topicId).catch(() => { });
+                preview.messageId = await this.sendCard(scopeId, taskId, html);
+                return preview.messageId;
+            }
+        }
+        try {
+            await this.gateway.editRichMessage(target.chatId, preview.messageId, telegramRichHtml(html), this.keyboard(taskId));
+        }
+        catch {
+            await this.gateway.editHtmlMessage(target.chatId, preview.messageId, html, this.keyboard(taskId));
+        }
+        return preview.messageId;
+    }
+    async end(scopeId, taskId) {
+        const preview = this.previews.get(taskId);
+        if (!preview || preview.scopeId !== scopeId)
+            return;
+        this.previews.delete(taskId);
+        if (preview.draftId !== null) {
+            this.gateway.releaseGeneration(preview.draftId);
+            this.draftIds.delete(preview.draftId);
+            const target = parseTelegramTargetFromBridgeScope(scopeId);
+            await this.gateway.sendMessageDraft(target.chatId, preview.draftId, '', target.topicId).catch(() => { });
+        }
+    }
+}

package/dist/telegram/task_result.d.ts

@@ -0,0 +1,2 @@
+/** Only the generated fold formatting is accepted; arbitrary model HTML remains escaped. */
+export declare function telegramTaskResult(content: string): import("./rich.js").TelegramInputRichMessage;

package/dist/telegram/task_result.js

@@ -0,0 +1,12 @@
+import { telegramRichHtml, telegramRichMarkdown } from './rich.js';
+import { renderTelegramMarkdownRichHtml } from './rich_markdown.js';
+/** Only the generated fold formatting is accepted; arbitrary model HTML remains escaped. */
+export function telegramTaskResult(content) {
+    const folded = /^(<blockquote expandable>[\s\S]*?<\/blockquote>)(?:\s*|$)/.exec(content);
+    if (!folded)
+        return telegramRichMarkdown(content, { skipEntityDetection: true });
+    const response = content.slice(folded[0].length);
+    const summary = folded[1].replace(/<[^>]*>/g, tag => /^(?:<\/?(?:b|i|code)>|<blockquote expandable>|<\/blockquote>)$/.test(tag)
+        ? tag : tag.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;'));
+    return telegramRichHtml(`${response.trim() ? renderTelegramMarkdownRichHtml(response) : ''}\n${summary}`, { skipEntityDetection: true });
+}

package/dist/telegram/text.d.ts

@@ -2,6 +2,6 @@ export declare const TELEGRAM_MESSAGE_LIMIT = 4000;
 export declare const TELEGRAM_STREAM_MESSAGE_LIMIT = 1200;
 export declare const TELEGRAM_DRAFT_LIMIT = 4000;
 export declare function sanitizeTelegramPreview(text: string): string;
-export declare function chunkTelegramMessage(text: string, limit?: number, fallbackText?: string): string[];
+export { chunkMessage as chunkTelegramMessage } from '../core/message_text.js';
 export declare function chunkTelegramStreamMessage(text: string, limit?: number): string[];
 export declare function clipTelegramDraftMessage(text: string, fallbackText?: string): string;

package/dist/telegram/text.js

@@ -8,33 +8,8 @@ export function sanitizeTelegramPreview(text) {
         ? `${text.slice(0, TELEGRAM_MESSAGE_LIMIT - 3)}...`
         : text;
 }
-export function chunkTelegramMessage(text, limit = TELEGRAM_MESSAGE_LIMIT, fallbackText = 'Completed.') {
-    const source = text.trim() ? text : fallbackText;
-    if (!source) {
-        return [];
-    }
-    if (source.length <= limit) {
-        return [source];
-    }
-    const chunks = [];
-    let start = 0;
-    while (start < source.length) {
-        const remaining = source.length - start;
-        if (remaining <= limit) {
-            chunks.push(source.slice(start));
-            break;
-        }
-        const tentativeEnd = start + limit;
-        const window = source.slice(start, tentativeEnd);
-        const splitAt = Math.max(window.lastIndexOf('\n\n'), window.lastIndexOf('\n'));
-        const end = splitAt >= Math.floor(limit / 2)
-            ? start + splitAt + 1
-            : tentativeEnd;
-        chunks.push(source.slice(start, end));
-        start = end;
-    }
-    return chunks.filter(chunk => chunk.length > 0);
-}
+export { chunkMessage as chunkTelegramMessage } from '../core/message_text.js';
+import { chunkMessage as chunkTelegramMessage } from '../core/message_text.js';
 export function chunkTelegramStreamMessage(text, limit = TELEGRAM_STREAM_MESSAGE_LIMIT) {
     return chunkTelegramMessage(text, limit, '');
 }

package/dist/types.d.ts

@@ -17,7 +17,7 @@ export interface ChatSessionSettings {
     /** Bridge scope id (e.g. `telegram:…`). */
     chatId: string;
     model: string | null;
-    reasoningEffort: ReasoningEffortValue | null;
+    reasoningEffort: string | null;
     locale: AppLocale | null;
     accessPreset: AccessPresetValue | null;
     collaborationMode: CollaborationModeValue | null;