@deadragdoll/tellymcp 0.0.10 → 0.0.12

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/transportMessageFlow.js

@@ -0,0 +1,452 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportMessageFlow = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const redactSecrets_1 = require("../../lib/redact-secrets/redactSecrets");
+const telegramXchangeRecords_1 = require("../../lib/telegramXchangeRecords");
+const relay_1 = require("../../../app/webapp/relay");
+const transportUtils_1 = require("./transportUtils");
+class TransportMessageFlow {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async handleMessage(ctx) {
+        const text = this.host.extractIncomingText(ctx.message);
+        const attachments = this.host.collectIncomingAttachments(ctx.message);
+        if (!text && attachments.length === 0) {
+            return;
+        }
+        this.host.logger.info("Telegram message received", {
+            chatId: ctx.chat?.id,
+            userId: ctx.from?.id,
+            messageId: ctx.message?.message_id,
+            replyToMessageId: ctx.message?.reply_to_message?.message_id,
+            ...(text ? { text: (0, redactSecrets_1.redactSecrets)(text) } : {}),
+            attachmentCount: attachments.length,
+            activeWaiters: this.host.waiters.size,
+        });
+        if (this.host.isAdminBotProfile()) {
+            const handled = await this.handleGatewayTopLevelMessage(ctx, text);
+            if (handled) {
+                return;
+            }
+        }
+        if (text && (await this.host.handlePendingRename(ctx, text)))
+            return;
+        if (text && (await this.host.handlePendingBroadcast(ctx, text)))
+            return;
+        if (text && (await this.host.handlePendingPartnerNote(ctx, text)))
+            return;
+        if (text && (await this.host.handlePendingFileHandoff(ctx, text)))
+            return;
+        if (text && (await this.host.handlePendingProject(ctx, text)))
+            return;
+        if (text && (0, transportUtils_1.isMenuEntryCommand)(text)) {
+            this.host.clearPendingInteractionsForContext(ctx);
+            await this.host.showSessionsMenu(ctx);
+            return;
+        }
+        if (text && (0, transportUtils_1.isHelpCommand)(text)) {
+            this.host.clearPendingInteractionsForContext(ctx);
+            await this.host.showHelp(ctx);
+            return;
+        }
+        const replyMatched = text ? await this.handleReply(ctx) : false;
+        if (replyMatched) {
+            return;
+        }
+        if (attachments.length > 0) {
+            await this.handleAttachmentUpload(ctx, attachments);
+            return;
+        }
+        await this.handleInboxCapture(ctx);
+    }
+    async handleGatewayTopLevelMessage(ctx, text) {
+        const principal = this.host.getPrincipalFromContext(ctx);
+        const authToken = text ? (0, transportUtils_1.parseAdminAuthCommand)(text) : null;
+        if (authToken !== null) {
+            if (!this.host.isAdminAuthEnabled()) {
+                await this.host.replyText(ctx, await this.host.tForContext(ctx, "menu:admin.auth.disabled"), { sessionId: "gateway-auth", kind: "transport" });
+                return true;
+            }
+            if (authToken !== this.host.config.distributed.gatewayToken) {
+                await this.host.replyText(ctx, await this.host.tForContext(ctx, "menu:admin.auth.invalid"), { sessionId: "gateway-auth", kind: "transport" });
+                return true;
+            }
+            if (!principal) {
+                return true;
+            }
+            const user = await this.host.ensureGatewayUserForPrincipal({
+                principal,
+                ctx,
+            });
+            await this.host.setPrincipalAdminAuthorized(principal);
+            await this.host.replyText(ctx, [
+                await this.host.tForContext(ctx, "menu:admin.auth.success"),
+                "",
+                `<code>GATEWAY_USER_UUID=${user.gateway_user_uuid}</code>`,
+                "Set this in your agent .env.",
+            ].join("\n"), { sessionId: "gateway-auth", kind: "transport" }, { parse_mode: "HTML" });
+            return true;
+        }
+        if (this.host.isAdminAuthEnabled() &&
+            !(await this.host.isPrincipalAdminAuthorized(principal))) {
+            await this.host.replyText(ctx, await this.host.tForContext(ctx, "menu:admin.auth.prompt"), { sessionId: "gateway-auth", kind: "transport" });
+            return true;
+        }
+        if (text && (0, transportUtils_1.isMenuEntryCommand)(text)) {
+            if (principal) {
+                await this.host.ensureGatewayScopeConsolesBound({ principal, ctx });
+            }
+            const activeSessionId = principal
+                ? await this.host.bindingStore.getActiveSessionIdForPrincipal(principal)
+                : null;
+            const boundSessionIds = principal
+                ? await this.host.bindingStore.listBoundSessionIdsForPrincipal(principal)
+                : [];
+            const hasLinkedSessions = Boolean(activeSessionId) || boundSessionIds.length > 0;
+            this.host.logger.info("Gateway /menu routing evaluated", {
+                chatId: ctx.chat?.id,
+                userId: ctx.from?.id,
+                activeSessionId,
+                boundSessionCount: boundSessionIds.length,
+                boundSessionIds,
+            });
+            void hasLinkedSessions;
+            this.host.clearPendingInteractionsForContext(ctx);
+            await this.host.showSessionsMenu(ctx);
+            return true;
+        }
+        if (text && (0, transportUtils_1.isHelpCommand)(text)) {
+            const principal = this.host.getPrincipalFromContext(ctx);
+            if (principal) {
+                await this.host.ensureGatewayScopeConsolesBound({ principal, ctx });
+            }
+            this.host.clearPendingInteractionsForContext(ctx);
+            await this.host.showHelp(ctx);
+            return true;
+        }
+        return false;
+    }
+    resolveGatewayTelegramSourceLabel(ctx) {
+        const firstName = ctx.from?.first_name?.trim();
+        const lastName = ctx.from?.last_name?.trim();
+        const displayName = [firstName, lastName].filter(Boolean).join(" ").trim();
+        const username = ctx.from?.username?.trim();
+        if (displayName)
+            return displayName;
+        if (username)
+            return `@${username.replace(/^@/u, "")}`;
+        return `Telegram user ${ctx.from?.id ?? "unknown"}`;
+    }
+    async routeTelegramInboxToRelaySession(input) {
+        const sourceActorLabel = this.resolveGatewayTelegramSourceLabel(input.ctx);
+        const output = await this.host.callGatewayJson("/relay/console-message", {
+            source_actor_label: sourceActorLabel,
+            target_client_uuid: input.relayTarget.clientUuid,
+            target_local_session_id: input.relayTarget.localSessionId,
+            message: input.messageText,
+            ...(input.attachments.length > 0
+                ? {
+                    attachments: input.attachments.map((attachment) => attachment.filePath),
+                }
+                : {}),
+        });
+        this.host.logger.info("Telegram message routed to gateway relay session", {
+            sessionId: input.sourceSessionId,
+            targetClientUuid: input.relayTarget.clientUuid,
+            targetLocalSessionId: input.relayTarget.localSessionId,
+            submittedTextLength: output.submitted_text.length,
+            chatId: input.principal.telegramChatId,
+            userId: input.principal.telegramUserId,
+        });
+    }
+    async handleReply(ctx) {
+        const message = ctx.message;
+        const fromUserId = ctx.from?.id;
+        const chatId = ctx.chat?.id;
+        if (!message?.text || !fromUserId || !chatId) {
+            return false;
+        }
+        const waiters = Array.from(this.host.waiters.values());
+        if (waiters.length === 0) {
+            this.host.logger.debug("Telegram message ignored because there are no active waiters", {
+                chatId,
+                userId: fromUserId,
+                messageId: message.message_id,
+                text: (0, redactSecrets_1.redactSecrets)(message.text.trim()),
+            });
+            return false;
+        }
+        const replyToMessageId = message.reply_to_message?.message_id;
+        const messageTimestampMs = message.date * 1000;
+        const matched = waiters.find((waiter) => waiter.telegramChatId === chatId &&
+            waiter.telegramUserId === fromUserId &&
+            replyToMessageId === waiter.telegramMessageId) ??
+            (waiters.length === 1
+                ? waiters.find((waiter) => waiter.telegramChatId === chatId &&
+                    waiter.telegramUserId === fromUserId &&
+                    messageTimestampMs >= waiter.sentAtMs)
+                : undefined);
+        if (!matched) {
+            this.host.logger.debug("Telegram message did not match any active waiter", {
+                chatId,
+                userId: fromUserId,
+                messageId: message.message_id,
+                replyToMessageId,
+                activeWaiterIds: waiters.map((waiter) => waiter.requestId),
+                text: (0, redactSecrets_1.redactSecrets)(message.text.trim()),
+            });
+            return false;
+        }
+        this.host.logger.info("Telegram message matched active waiter", {
+            requestId: matched.requestId,
+            chatId,
+            userId: fromUserId,
+            messageId: message.message_id,
+            replyToMessageId,
+            text: (0, redactSecrets_1.redactSecrets)(message.text.trim()),
+        });
+        const reply = {
+            requestId: matched.requestId,
+            answer: message.text.trim(),
+            receivedAt: new Date(message.date * 1000).toISOString(),
+        };
+        if (matched.sourceClientUuid && this.host.config.distributed.gatewayPublicUrl) {
+            try {
+                await this.host.callGatewayJson("/transport/reply", {
+                    client_uuid: matched.sourceClientUuid,
+                    request_id: matched.requestId,
+                    answer: reply.answer,
+                    received_at: reply.receivedAt,
+                });
+            }
+            catch (error) {
+                this.host.logger.error("Failed to forward gateway transport reply to client", {
+                    requestId: matched.requestId,
+                    sourceClientUuid: matched.sourceClientUuid,
+                    chatId,
+                    userId: fromUserId,
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+                return false;
+            }
+            this.host.clearWaiter(matched.requestId);
+            return true;
+        }
+        if (matched.resolve) {
+            matched.resolve(reply);
+            return true;
+        }
+        matched.reply = reply;
+        return true;
+    }
+    async handleInboxCapture(ctx) {
+        const message = ctx.message;
+        const fromUserId = ctx.from?.id;
+        const chatId = ctx.chat?.id;
+        const text = this.host.extractIncomingText(message);
+        const attachmentDescriptors = this.host.collectIncomingAttachments(message);
+        if (!message || (!text && attachmentDescriptors.length === 0) || !fromUserId || !chatId) {
+            return;
+        }
+        const principal = { telegramChatId: chatId, telegramUserId: fromUserId };
+        const sessionId = await this.host.bindingStore.getActiveSessionIdForPrincipal(principal);
+        if (!sessionId) {
+            this.host.logger.debug("Telegram message ignored because no active session is linked for principal", { chatId, userId: fromUserId, messageId: message.message_id });
+            await this.host.replyText(ctx, "No active console selected yet. Open /menu and choose a console first.", { kind: "transport" });
+            return;
+        }
+        const session = await this.host.sessionStore.getSession(sessionId);
+        const relayTarget = (0, relay_1.parseLiveRelaySessionId)(sessionId);
+        let attachments = [];
+        try {
+            attachments = await this.host.downloadIncomingAttachments(session, sessionId, message.message_id, attachmentDescriptors);
+        }
+        catch (error) {
+            this.host.logger.error("Telegram attachment upload failed", {
+                sessionId,
+                chatId,
+                userId: fromUserId,
+                messageId: message.message_id,
+                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+            });
+            await this.host.replyText(ctx, error instanceof Error
+                ? `Could not save uploaded file: ${error.message}`
+                : "Could not save uploaded file.", { kind: "transport", sessionId }, {
+                reply_markup: this.host.getMainMenu(),
+            });
+            return;
+        }
+        const normalizedText = this.host.buildInboxText(text, attachments.map((attachment) => attachment.filePath));
+        if (relayTarget) {
+            try {
+                await this.routeTelegramInboxToRelaySession({
+                    ctx,
+                    principal,
+                    relayTarget,
+                    sourceSessionId: sessionId,
+                    messageText: normalizedText,
+                    attachments,
+                });
+            }
+            catch (error) {
+                this.host.logger.error("Failed to route Telegram message to gateway relay session", {
+                    sessionId,
+                    targetClientUuid: relayTarget.clientUuid,
+                    targetLocalSessionId: relayTarget.localSessionId,
+                    chatId,
+                    userId: fromUserId,
+                    messageId: message.message_id,
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+                await this.host.replyText(ctx, await this.host.tForContext(ctx, "menu:system.gateway_relay_inbox_failed"), { kind: "transport", sessionId });
+                return;
+            }
+            await this.host.replyText(ctx, await this.host.tForContext(ctx, "menu:system.gateway_relay_inbox_sent", {
+                sessionName: session?.label ?? relayTarget.localSessionId,
+            }), { kind: "transport", sessionId });
+            return;
+        }
+        await this.host.storeTelegramUploadMetas({
+            sessionId,
+            sourceTelegramMessageId: message.message_id,
+            uploadedAt: new Date(message.date * 1000).toISOString(),
+            attachments,
+            descriptors: attachmentDescriptors,
+        });
+        const recordId = await (0, telegramXchangeRecords_1.writeTelegramMessageXchangeRecord)({
+            config: this.host.config,
+            session,
+            sessionId,
+            text: normalizedText,
+            createdAt: new Date(message.date * 1000).toISOString(),
+            attachments: attachments.map((attachment) => ({
+                file_path: attachment.filePath,
+            })),
+            tags: [
+                "telegram",
+                "human",
+                ...(attachments.length > 0 ? ["attachments"] : []),
+            ],
+        });
+        this.host.logger.info("Telegram message stored in xchange", {
+            sessionId,
+            chatId,
+            userId: fromUserId,
+            messageId: message.message_id,
+            recordId,
+            text: (0, redactSecrets_1.redactSecrets)(normalizedText),
+            attachmentCount: attachments.length,
+            attachments: attachments.map((attachment) => attachment.filePath),
+        });
+        try {
+            this.host.scheduleTerminalNudgeForInboxMessage(sessionId, session);
+        }
+        catch (error) {
+            this.host.logger.error("terminal nudge failed after xchange capture", {
+                sessionId,
+                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+            });
+        }
+        await this.host.replyText(ctx, session?.label
+            ? attachments.length > 0
+                ? `Saved to xchange for session: ${session.label}. Files downloaded: ${attachments.length}`
+                : `Saved to xchange for session: ${session.label}`
+            : attachments.length > 0
+                ? `Saved to xchange for session: ${sessionId}. Files downloaded: ${attachments.length}`
+                : `Saved to xchange for session: ${sessionId}`, { kind: "transport", sessionId }, {
+            reply_markup: this.host.getMainMenu(),
+        });
+    }
+    async handleAttachmentUpload(ctx, attachmentDescriptors) {
+        const message = ctx.message;
+        const fromUserId = ctx.from?.id;
+        const chatId = ctx.chat?.id;
+        if (!message || !fromUserId || !chatId || attachmentDescriptors.length === 0) {
+            return;
+        }
+        const principal = { telegramChatId: chatId, telegramUserId: fromUserId };
+        const principalKey = (0, transportUtils_1.buildPrincipalKey)(principal);
+        const sessionId = await this.host.bindingStore.getActiveSessionIdForPrincipal(principal);
+        if (!sessionId) {
+            await this.host.replyText(ctx, "No active console selected yet. Open /menu and choose a console first.", { kind: "transport" });
+            return;
+        }
+        const session = await this.host.sessionStore.getSession(sessionId);
+        const caption = this.host.extractIncomingText(message);
+        const attachments = await this.host.downloadIncomingAttachments(session, sessionId, message.message_id, attachmentDescriptors);
+        const currentTarget = this.host.currentAttachmentTargets.get(principalKey);
+        if (currentTarget && currentTarget.sessionId === sessionId) {
+            await this.host.storeTelegramUploadMetas({
+                sessionId,
+                sourceTelegramMessageId: message.message_id,
+                uploadedAt: new Date(message.date * 1000).toISOString(),
+                attachments,
+                descriptors: attachmentDescriptors,
+                caption: caption || undefined,
+            });
+            for (const attachment of attachments) {
+                await this.host.deliverAttachmentToPartner({
+                    sessionId,
+                    filePath: attachment.filePath,
+                    description: (caption || "").trim() || node_path_1.default.basename(attachment.filePath),
+                    targetSessionId: currentTarget.targetSessionId,
+                    ...(currentTarget.projectUuid
+                        ? { projectUuid: currentTarget.projectUuid }
+                        : {}),
+                });
+            }
+            await this.host.replyText(ctx, currentTarget.projectUuid
+                ? await this.host.tForContext(ctx, "menu:handoff.uploaded_to_session", {
+                    label: currentTarget.targetSessionLabel,
+                })
+                : await this.host.tForContext(ctx, "menu:handoff.uploaded_to_partner", {
+                    label: currentTarget.targetSessionLabel,
+                }), { kind: "inbox", sessionId }, {
+                reply_markup: this.host.getMainMenu(),
+            });
+            return;
+        }
+        await this.host.storeTelegramUploadMetas({
+            sessionId,
+            sourceTelegramMessageId: message.message_id,
+            uploadedAt: new Date(message.date * 1000).toISOString(),
+            attachments,
+            descriptors: attachmentDescriptors,
+            caption: caption || undefined,
+        });
+        this.host.logger.info("Telegram files uploaded for session", {
+            sessionId,
+            chatId,
+            userId: fromUserId,
+            messageId: message.message_id,
+            attachmentCount: attachments.length,
+            attachments: attachments.map((attachment) => attachment.filePath),
+        });
+        await this.host.replyText(ctx, session?.label
+            ? attachments.length === 1
+                ? await this.host.tForContext(ctx, "menu:handoff.delivered_one", {
+                    label: session.label,
+                })
+                : await this.host.tForContext(ctx, "menu:handoff.delivered_many", {
+                    label: session.label,
+                    count: attachments.length,
+                })
+            : attachments.length === 1
+                ? await this.host.tForContext(ctx, "menu:handoff.delivered_one", {
+                    label: sessionId,
+                })
+                : await this.host.tForContext(ctx, "menu:handoff.delivered_many", {
+                    label: sessionId,
+                    count: attachments.length,
+                }), { kind: "inbox", sessionId }, {
+            reply_markup: this.host.getMainMenu(),
+        });
+    }
+}
+exports.TransportMessageFlow = TransportMessageFlow;

package/dist/services/features/telegram-mcp/src/shared/integrations/telegram/transportOutputActions.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportOutputActions = void 0;
+const grammy_1 = require("grammy");
+const transportUtils_1 = require("./transportUtils");
+class TransportOutputActions {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async sendTextChunks(telegramChatId, text, meta) {
+        const safeLimit = Math.min(this.host.config.telegram.maxMessageChars, 3900);
+        const { title, body } = (0, transportUtils_1.splitTitleAndBody)(text);
+        const rawChunkLimit = Math.max(256, safeLimit - title.length - 96);
+        const rawChunks = (0, transportUtils_1.splitLongTelegramText)(body, rawChunkLimit);
+        const bodyChunks = rawChunks.flatMap((chunk) => this.buildSizedBodyChunks(title, chunk, safeLimit));
+        const chunkCount = bodyChunks.length;
+        const chunks = bodyChunks.map((chunkBody, index) => (0, transportUtils_1.renderMarkdownChunk)(chunkCount > 1 ? `${title} (${index + 1}/${chunkCount})` : title, chunkBody));
+        const sent = [];
+        this.host.logger.debug("Telegram message chunking prepared", {
+            kind: meta.kind,
+            sessionId: meta.sessionId,
+            requestId: meta.requestId,
+            chunkCount: chunks.length,
+            totalLength: text.length,
+            safeLimit,
+        });
+        for (let index = 0; index < chunks.length; index += 1) {
+            const chunk = chunks[index];
+            if (!chunk) {
+                continue;
+            }
+            try {
+                const response = await this.sendTelegramMessageWithRetry(telegramChatId, chunk, { parse_mode: "MarkdownV2" }, {
+                    kind: meta.kind,
+                    sessionId: meta.sessionId,
+                    chunkIndex: index + 1,
+                    chunkCount: chunks.length,
+                    ...(meta.requestId ? { requestId: meta.requestId } : {}),
+                });
+                sent.push({
+                    messageId: response.message_id,
+                    textLength: chunk.length,
+                });
+                this.host.logger.debug("Telegram message chunk sent", {
+                    kind: meta.kind,
+                    sessionId: meta.sessionId,
+                    requestId: meta.requestId,
+                    chunkIndex: index + 1,
+                    chunkCount: chunks.length,
+                    messageId: response.message_id,
+                    textLength: chunk.length,
+                });
+            }
+            catch (error) {
+                this.host.logger.error("Telegram message chunk send failed", {
+                    kind: meta.kind,
+                    sessionId: meta.sessionId,
+                    requestId: meta.requestId,
+                    chunkIndex: index + 1,
+                    chunkCount: chunks.length,
+                    textLength: chunk.length,
+                    error: error instanceof Error
+                        ? (error.stack ?? error.message)
+                        : String(error),
+                });
+                throw error instanceof Error ? error : new Error(String(error));
+            }
+        }
+        return sent;
+    }
+    async sendChatMessage(telegramChatId, text, options, meta) {
+        return this.sendTelegramMessageWithRetry(telegramChatId, text, options, meta);
+    }
+    async replyText(ctx, text, meta, options = {}) {
+        let attempt = 0;
+        while (true) {
+            attempt += 1;
+            try {
+                return await ctx.reply(text, options);
+            }
+            catch (error) {
+                if (!(error instanceof grammy_1.GrammyError) || error.error_code !== 429) {
+                    throw error;
+                }
+                const retryAfterSeconds = Math.max(1, error.parameters.retry_after ?? 1);
+                this.host.logger.warn("Telegram rate limit hit while replying, cooling down", {
+                    kind: meta.kind,
+                    sessionId: meta.sessionId,
+                    requestId: meta.requestId,
+                    attempt,
+                    retryAfterSeconds,
+                    description: error.description,
+                });
+                await new Promise((resolve) => setTimeout(resolve, retryAfterSeconds * 1000));
+            }
+        }
+    }
+    async editText(ctx, text, meta, options = {}) {
+        let attempt = 0;
+        while (true) {
+            attempt += 1;
+            try {
+                await ctx.editMessageText(text, options);
+                return;
+            }
+            catch (error) {
+                if (error instanceof grammy_1.GrammyError) {
+                    if (error.description.includes("message is not modified")) {
+                        return;
+                    }
+                    if (error.error_code === 429) {
+                        const retryAfterSeconds = Math.max(1, error.parameters.retry_after ?? 1);
+                        this.host.logger.warn("Telegram rate limit hit while editing message, cooling down", {
+                            kind: meta.kind,
+                            sessionId: meta.sessionId,
+                            requestId: meta.requestId,
+                            attempt,
+                            retryAfterSeconds,
+                            description: error.description,
+                        });
+                        await new Promise((resolve) => setTimeout(resolve, retryAfterSeconds * 1000));
+                        continue;
+                    }
+                }
+                throw error;
+            }
+        }
+    }
+    buildSizedBodyChunks(title, rawBody, safeLimit) {
+        const queue = [rawBody];
+        const bodyChunks = [];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current) {
+                continue;
+            }
+            const candidate = (0, transportUtils_1.renderMarkdownChunk)(`${title} (88/88)`, current);
+            if (candidate.length <= safeLimit) {
+                bodyChunks.push(current);
+                continue;
+            }
+            const midpoint = Math.floor(current.length / 2);
+            const splitAtNewline = current.lastIndexOf("\n", midpoint);
+            const splitIndex = splitAtNewline > 64 ? splitAtNewline : midpoint;
+            const head = current.slice(0, splitIndex).trim();
+            const tail = current.slice(splitIndex).trim();
+            if (!head || !tail) {
+                const hardLimit = Math.max(64, safeLimit - title.length - 96);
+                for (let index = 0; index < current.length; index += hardLimit) {
+                    const slice = current.slice(index, index + hardLimit).trim();
+                    if (slice) {
+                        bodyChunks.push(slice);
+                    }
+                }
+                continue;
+            }
+            queue.unshift(tail, head);
+        }
+        return bodyChunks;
+    }
+    async sendTelegramMessageWithRetry(telegramChatId, text, options = {}, meta) {
+        let attempt = 0;
+        while (true) {
+            attempt += 1;
+            try {
+                return await this.host.bot.api.sendMessage(telegramChatId, text, options);
+            }
+            catch (error) {
+                if (!(error instanceof grammy_1.GrammyError) || error.error_code !== 429) {
+                    throw error;
+                }
+                const retryAfterSeconds = Math.max(1, error.parameters.retry_after ?? 1);
+                this.host.logger.warn("Telegram rate limit hit, cooling down before retry", {
+                    kind: meta.kind,
+                    sessionId: meta.sessionId,
+                    requestId: meta.requestId,
+                    chunkIndex: meta.chunkIndex,
+                    chunkCount: meta.chunkCount,
+                    attempt,
+                    retryAfterSeconds,
+                    description: error.description,
+                });
+                await new Promise((resolve) => setTimeout(resolve, retryAfterSeconds * 1000));
+            }
+        }
+    }
+}
+exports.TransportOutputActions = TransportOutputActions;