@gguf/pigbot 0.0.1 → 0.0.2

package/dist/telegram/bot/delivery.js

@@ -1,5 +1,6 @@
-import { InputFile } from "grammy";
+import { GrammyError, InputFile } from "grammy";
 import { markdownToTelegramChunks, markdownToTelegramHtml, renderTelegramHtmlText, } from "../format.js";
+import { withTelegramApiErrorLogging } from "../api-logging.js";
 import { chunkMarkdownTextWithMode } from "../../auto-reply/chunk.js";
 import { splitTelegramCaption } from "../caption.js";
 import { danger, logVerbose } from "../../globals.js";
@@ -9,13 +10,15 @@ import { fetchRemoteMedia } from "../../media/fetch.js";
 import { isGifMedia } from "../../media/mime.js";
 import { saveMediaBuffer } from "../../media/store.js";
 import { loadWebMedia } from "../../web/media.js";
+import { buildInlineKeyboard } from "../send.js";
 import { resolveTelegramVoiceSend } from "../voice.js";
 import { buildTelegramThreadParams, resolveTelegramReplyId } from "./helpers.js";
+import { cacheSticker, getCachedSticker } from "../sticker-cache.js";
 const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i;
+const VOICE_FORBIDDEN_RE = /VOICE_MESSAGES_FORBIDDEN/;
 export async function deliverReplies(params) {
-    const { replies, chatId, runtime, bot, replyToMode, textLimit, messageThreadId } = params;
+    const { replies, chatId, runtime, bot, replyToMode, textLimit, messageThreadId, linkPreview, replyQuoteText, } = params;
     const chunkMode = params.chunkMode ?? "length";
-    const threadParams = buildTelegramThreadParams(messageThreadId);
     let hasReplied = false;
     const chunkText = (markdown) => {
         const markdownChunks = chunkMode === "newline"
@@ -51,14 +54,24 @@ export async function deliverReplies(params) {
             : reply.mediaUrl
                 ? [reply.mediaUrl]
                 : [];
+        const telegramData = reply.channelData?.telegram;
+        const replyMarkup = buildInlineKeyboard(telegramData?.buttons);
         if (mediaList.length === 0) {
             const chunks = chunkText(reply.text || "");
-            for (const chunk of chunks) {
+            for (let i = 0; i < chunks.length; i += 1) {
+                const chunk = chunks[i];
+                if (!chunk)
+                    continue;
+                // Only attach buttons to the first chunk.
+                const shouldAttachButtons = i === 0 && replyMarkup;
                 await sendTelegramText(bot, chatId, chunk.html, runtime, {
                     replyToMessageId: replyToId && (replyToMode === "all" || !hasReplied) ? replyToId : undefined,
+                    replyQuoteText,
                     messageThreadId,
                     textMode: "html",
                     plainText: chunk.text,
+                    linkPreview,
+                    replyMarkup: shouldAttachButtons ? replyMarkup : undefined,
                 });
                 if (replyToId && !hasReplied) {
                     hasReplied = true;
@@ -91,27 +104,36 @@ export async function deliverReplies(params) {
             }
             first = false;
             const replyToMessageId = replyToId && (replyToMode === "all" || !hasReplied) ? replyToId : undefined;
+            const shouldAttachButtonsToMedia = isFirstMedia && replyMarkup && !followUpText;
             const mediaParams = {
                 caption: htmlCaption,
-                reply_to_message_id: replyToMessageId,
                 ...(htmlCaption ? { parse_mode: "HTML" } : {}),
+                ...(shouldAttachButtonsToMedia ? { reply_markup: replyMarkup } : {}),
+                ...buildTelegramSendParams({
+                    replyToMessageId,
+                    messageThreadId,
+                    replyQuoteText,
+                }),
             };
-            if (threadParams) {
-                mediaParams.message_thread_id = threadParams.message_thread_id;
-            }
             if (isGif) {
-                await bot.api.sendAnimation(chatId, file, {
-                    ...mediaParams,
+                await withTelegramApiErrorLogging({
+                    operation: "sendAnimation",
+                    runtime,
+                    fn: () => bot.api.sendAnimation(chatId, file, { ...mediaParams }),
                 });
             }
             else if (kind === "image") {
-                await bot.api.sendPhoto(chatId, file, {
-                    ...mediaParams,
+                await withTelegramApiErrorLogging({
+                    operation: "sendPhoto",
+                    runtime,
+                    fn: () => bot.api.sendPhoto(chatId, file, { ...mediaParams }),
                 });
             }
             else if (kind === "video") {
-                await bot.api.sendVideo(chatId, file, {
-                    ...mediaParams,
+                await withTelegramApiErrorLogging({
+                    operation: "sendVideo",
+                    runtime,
+                    fn: () => bot.api.sendVideo(chatId, file, { ...mediaParams }),
                 });
             }
             else if (kind === "audio") {
@@ -125,20 +147,58 @@ export async function deliverReplies(params) {
                     // Voice message - displays as round playable bubble (opt-in via [[audio_as_voice]])
                     // Switch typing indicator to record_voice before sending.
                     await params.onVoiceRecording?.();
-                    await bot.api.sendVoice(chatId, file, {
-                        ...mediaParams,
-                    });
+                    try {
+                        await withTelegramApiErrorLogging({
+                            operation: "sendVoice",
+                            runtime,
+                            shouldLog: (err) => !isVoiceMessagesForbidden(err),
+                            fn: () => bot.api.sendVoice(chatId, file, { ...mediaParams }),
+                        });
+                    }
+                    catch (voiceErr) {
+                        // Fall back to text if voice messages are forbidden in this chat.
+                        // This happens when the recipient has Telegram Premium privacy settings
+                        // that block voice messages (Settings > Privacy > Voice Messages).
+                        if (isVoiceMessagesForbidden(voiceErr)) {
+                            const fallbackText = reply.text;
+                            if (!fallbackText || !fallbackText.trim()) {
+                                throw voiceErr;
+                            }
+                            logVerbose("telegram sendVoice forbidden (recipient has voice messages blocked in privacy settings); falling back to text");
+                            hasReplied = await sendTelegramVoiceFallbackText({
+                                bot,
+                                chatId,
+                                runtime,
+                                text: fallbackText,
+                                chunkText,
+                                replyToId,
+                                replyToMode,
+                                hasReplied,
+                                messageThreadId,
+                                linkPreview,
+                                replyMarkup,
+                                replyQuoteText,
+                            });
+                            // Skip this media item; continue with next.
+                            continue;
+                        }
+                        throw voiceErr;
+                    }
                 }
                 else {
                     // Audio file - displays with metadata (title, duration) - DEFAULT
-                    await bot.api.sendAudio(chatId, file, {
-                        ...mediaParams,
+                    await withTelegramApiErrorLogging({
+                        operation: "sendAudio",
+                        runtime,
+                        fn: () => bot.api.sendAudio(chatId, file, { ...mediaParams }),
                     });
                 }
             }
             else {
-                await bot.api.sendDocument(chatId, file, {
-                    ...mediaParams,
+                await withTelegramApiErrorLogging({
+                    operation: "sendDocument",
+                    runtime,
+                    fn: () => bot.api.sendDocument(chatId, file, { ...mediaParams }),
                 });
             }
             if (replyToId && !hasReplied) {
@@ -148,13 +208,16 @@ export async function deliverReplies(params) {
             // Chunk it in case it's extremely long (same logic as text-only replies).
             if (pendingFollowUpText && isFirstMedia) {
                 const chunks = chunkText(pendingFollowUpText);
-                for (const chunk of chunks) {
+                for (let i = 0; i < chunks.length; i += 1) {
+                    const chunk = chunks[i];
                     const replyToMessageIdFollowup = replyToId && (replyToMode === "all" || !hasReplied) ? replyToId : undefined;
                     await sendTelegramText(bot, chatId, chunk.html, runtime, {
                         replyToMessageId: replyToMessageIdFollowup,
                         messageThreadId,
                         textMode: "html",
                         plainText: chunk.text,
+                        linkPreview,
+                        replyMarkup: i === 0 ? replyMarkup : undefined,
                     });
                     if (replyToId && !hasReplied) {
                         hasReplied = true;
@@ -167,6 +230,81 @@ export async function deliverReplies(params) {
 }
 export async function resolveMedia(ctx, maxBytes, token, proxyFetch) {
     const msg = ctx.message;
+    // Handle stickers separately - only static stickers (WEBP) are supported
+    if (msg.sticker) {
+        const sticker = msg.sticker;
+        // Skip animated (TGS) and video (WEBM) stickers - only static WEBP supported
+        if (sticker.is_animated || sticker.is_video) {
+            logVerbose("telegram: skipping animated/video sticker (only static stickers supported)");
+            return null;
+        }
+        if (!sticker.file_id)
+            return null;
+        try {
+            const file = await ctx.getFile();
+            if (!file.file_path) {
+                logVerbose("telegram: getFile returned no file_path for sticker");
+                return null;
+            }
+            const fetchImpl = proxyFetch ?? globalThis.fetch;
+            if (!fetchImpl) {
+                logVerbose("telegram: fetch not available for sticker download");
+                return null;
+            }
+            const url = `https://api.telegram.org/file/bot${token}/${file.file_path}`;
+            const fetched = await fetchRemoteMedia({
+                url,
+                fetchImpl,
+                filePathHint: file.file_path,
+            });
+            const saved = await saveMediaBuffer(fetched.buffer, fetched.contentType, "inbound", maxBytes);
+            // Check sticker cache for existing description
+            const cached = sticker.file_unique_id ? getCachedSticker(sticker.file_unique_id) : null;
+            if (cached) {
+                logVerbose(`telegram: sticker cache hit for ${sticker.file_unique_id}`);
+                const fileId = sticker.file_id ?? cached.fileId;
+                const emoji = sticker.emoji ?? cached.emoji;
+                const setName = sticker.set_name ?? cached.setName;
+                if (fileId !== cached.fileId || emoji !== cached.emoji || setName !== cached.setName) {
+                    // Refresh cached sticker metadata on hits so sends/searches use latest file_id.
+                    cacheSticker({
+                        ...cached,
+                        fileId,
+                        emoji,
+                        setName,
+                    });
+                }
+                return {
+                    path: saved.path,
+                    contentType: saved.contentType,
+                    placeholder: "<media:sticker>",
+                    stickerMetadata: {
+                        emoji,
+                        setName,
+                        fileId,
+                        fileUniqueId: sticker.file_unique_id,
+                        cachedDescription: cached.description,
+                    },
+                };
+            }
+            // Cache miss - return metadata for vision processing
+            return {
+                path: saved.path,
+                contentType: saved.contentType,
+                placeholder: "<media:sticker>",
+                stickerMetadata: {
+                    emoji: sticker.emoji ?? undefined,
+                    setName: sticker.set_name ?? undefined,
+                    fileId: sticker.file_id,
+                    fileUniqueId: sticker.file_unique_id,
+                },
+            };
+        }
+        catch (err) {
+            logVerbose(`telegram: failed to process sticker: ${String(err)}`);
+            return null;
+        }
+    }
     const m = msg.photo?.[msg.photo.length - 1] ?? msg.video ?? msg.document ?? msg.audio ?? msg.voice;
     if (!m?.file_id)
         return null;
@@ -194,11 +332,46 @@ export async function resolveMedia(ctx, maxBytes, token, proxyFetch) {
         placeholder = "<media:audio>";
     return { path: saved.path, contentType: saved.contentType, placeholder };
 }
+function isVoiceMessagesForbidden(err) {
+    if (err instanceof GrammyError) {
+        return VOICE_FORBIDDEN_RE.test(err.description);
+    }
+    return VOICE_FORBIDDEN_RE.test(formatErrorMessage(err));
+}
+async function sendTelegramVoiceFallbackText(opts) {
+    const chunks = opts.chunkText(opts.text);
+    let hasReplied = opts.hasReplied;
+    for (let i = 0; i < chunks.length; i += 1) {
+        const chunk = chunks[i];
+        await sendTelegramText(opts.bot, opts.chatId, chunk.html, opts.runtime, {
+            replyToMessageId: opts.replyToId && (opts.replyToMode === "all" || !hasReplied) ? opts.replyToId : undefined,
+            replyQuoteText: opts.replyQuoteText,
+            messageThreadId: opts.messageThreadId,
+            textMode: "html",
+            plainText: chunk.text,
+            linkPreview: opts.linkPreview,
+            replyMarkup: i === 0 ? opts.replyMarkup : undefined,
+        });
+        if (opts.replyToId && !hasReplied) {
+            hasReplied = true;
+        }
+    }
+    return hasReplied;
+}
 function buildTelegramSendParams(opts) {
     const threadParams = buildTelegramThreadParams(opts?.messageThreadId);
     const params = {};
+    const quoteText = opts?.replyQuoteText?.trim();
     if (opts?.replyToMessageId) {
-        params.reply_to_message_id = opts.replyToMessageId;
+        if (quoteText) {
+            params.reply_parameters = {
+                message_id: Math.trunc(opts.replyToMessageId),
+                quote: quoteText,
+            };
+        }
+        else {
+            params.reply_to_message_id = opts.replyToMessageId;
+        }
     }
     if (threadParams) {
         params.message_thread_id = threadParams.message_thread_id;
@@ -208,14 +381,25 @@ function buildTelegramSendParams(opts) {
 async function sendTelegramText(bot, chatId, text, runtime, opts) {
     const baseParams = buildTelegramSendParams({
         replyToMessageId: opts?.replyToMessageId,
+        replyQuoteText: opts?.replyQuoteText,
         messageThreadId: opts?.messageThreadId,
     });
+    // Add link_preview_options when link preview is disabled.
+    const linkPreviewEnabled = opts?.linkPreview ?? true;
+    const linkPreviewOptions = linkPreviewEnabled ? undefined : { is_disabled: true };
     const textMode = opts?.textMode ?? "markdown";
     const htmlText = textMode === "html" ? text : markdownToTelegramHtml(text);
     try {
-        const res = await bot.api.sendMessage(chatId, htmlText, {
-            parse_mode: "HTML",
-            ...baseParams,
+        const res = await withTelegramApiErrorLogging({
+            operation: "sendMessage",
+            runtime,
+            shouldLog: (err) => !PARSE_ERR_RE.test(formatErrorMessage(err)),
+            fn: () => bot.api.sendMessage(chatId, htmlText, {
+                parse_mode: "HTML",
+                ...(linkPreviewOptions ? { link_preview_options: linkPreviewOptions } : {}),
+                ...(opts?.replyMarkup ? { reply_markup: opts.replyMarkup } : {}),
+                ...baseParams,
+            }),
         });
         return res.message_id;
     }
@@ -224,8 +408,14 @@ async function sendTelegramText(bot, chatId, text, runtime, opts) {
         if (PARSE_ERR_RE.test(errText)) {
             runtime.log?.(`telegram HTML parse failed; retrying without formatting: ${errText}`);
             const fallbackText = opts?.plainText ?? text;
-            const res = await bot.api.sendMessage(chatId, fallbackText, {
-                ...baseParams,
+            const res = await withTelegramApiErrorLogging({
+                operation: "sendMessage",
+                runtime,
+                fn: () => bot.api.sendMessage(chatId, fallbackText, {
+                    ...(linkPreviewOptions ? { link_preview_options: linkPreviewOptions } : {}),
+                    ...(opts?.replyMarkup ? { reply_markup: opts.replyMarkup } : {}),
+                    ...baseParams,
+                }),
             });
             return res.message_id;
         }

package/dist/telegram/bot/helpers.js

@@ -115,33 +115,43 @@ export function resolveTelegramReplyId(raw) {
 }
 export function describeReplyTarget(msg) {
     const reply = msg.reply_to_message;
-    if (!reply)
-        return null;
-    const replyBody = (reply.text ?? reply.caption ?? "").trim();
-    let body = replyBody;
-    if (!body) {
-        if (reply.photo)
-            body = "<media:image>";
-        else if (reply.video)
-            body = "<media:video>";
-        else if (reply.audio || reply.voice)
-            body = "<media:audio>";
-        else if (reply.document)
-            body = "<media:document>";
-        else {
-            const locationData = extractTelegramLocation(reply);
-            if (locationData)
-                body = formatLocationText(locationData);
+    const quote = msg.quote;
+    let body = "";
+    let kind = "reply";
+    if (quote?.text) {
+        body = quote.text.trim();
+        if (body) {
+            kind = "quote";
+        }
+    }
+    if (!body && reply) {
+        const replyBody = (reply.text ?? reply.caption ?? "").trim();
+        body = replyBody;
+        if (!body) {
+            if (reply.photo)
+                body = "<media:image>";
+            else if (reply.video)
+                body = "<media:video>";
+            else if (reply.audio || reply.voice)
+                body = "<media:audio>";
+            else if (reply.document)
+                body = "<media:document>";
+            else {
+                const locationData = extractTelegramLocation(reply);
+                if (locationData)
+                    body = formatLocationText(locationData);
+            }
         }
     }
     if (!body)
         return null;
-    const sender = buildSenderName(reply);
+    const sender = reply ? buildSenderName(reply) : undefined;
     const senderLabel = sender ? `${sender}` : "unknown sender";
     return {
-        id: reply.message_id ? String(reply.message_id) : undefined,
+        id: reply?.message_id ? String(reply.message_id) : undefined,
         sender: senderLabel,
         body,
+        kind,
     };
 }
 function normalizeForwardedUserLabel(user) {

package/dist/telegram/bot-handlers.js

@@ -1,10 +1,15 @@
 // @ts-nocheck
 import { hasControlCommand } from "../auto-reply/command-detection.js";
 import { createInboundDebouncer, resolveInboundDebounceMs, } from "../auto-reply/inbound-debounce.js";
+import { buildCommandsPaginationKeyboard } from "../auto-reply/reply/commands-info.js";
+import { buildCommandsMessagePaginated } from "../auto-reply/status.js";
+import { listSkillCommandsForAgents } from "../auto-reply/skill-commands.js";
+import { resolveDefaultAgentId } from "../agents/agent-scope.js";
 import { loadConfig } from "../config/config.js";
 import { writeConfigFile } from "../config/io.js";
 import { danger, logVerbose, warn } from "../globals.js";
 import { resolveMedia } from "./bot/delivery.js";
+import { withTelegramApiErrorLogging } from "./api-logging.js";
 import { resolveTelegramForumThreadId } from "./bot/helpers.js";
 import { firstDefined, isSenderAllowed, normalizeAllowFromWithStore } from "./bot-access.js";
 import { MEDIA_GROUP_TIMEOUT_MS } from "./bot-updates.js";
@@ -12,6 +17,7 @@ import { migrateTelegramGroupConfig } from "./group-migration.js";
 import { resolveTelegramInlineButtonsScope } from "./inline-buttons.js";
 import { readTelegramAllowFromStore } from "./pairing-store.js";
 import { resolveChannelConfigWrites } from "../channels/plugins/config-writes.js";
+import { buildInlineKeyboard } from "./send.js";
 export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, mediaMaxBytes, telegramCfg, groupAllowFrom, resolveGroupPolicy, resolveTelegramGroupConfig, shouldSkipUpdate, processMessage, logger, }) => {
     const TELEGRAM_TEXT_FRAGMENT_START_THRESHOLD_CHARS = 4000;
     const TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS = 1500;
@@ -75,7 +81,11 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
             for (const { ctx } of entry.messages) {
                 const media = await resolveMedia(ctx, mediaMaxBytes, opts.token, opts.proxyFetch);
                 if (media) {
-                    allMedia.push({ path: media.path, contentType: media.contentType });
+                    allMedia.push({
+                        path: media.path,
+                        contentType: media.contentType,
+                        stickerMetadata: media.stickerMetadata,
+                    });
                 }
             }
             const storeAllowFrom = await readTelegramAllowFromStore().catch(() => []);
@@ -131,7 +141,11 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
         if (shouldSkipUpdate(ctx))
             return;
         // Answer immediately to prevent Telegram from retrying while we process
-        await bot.api.answerCallbackQuery(callback.id).catch(() => { });
+        await withTelegramApiErrorLogging({
+            operation: "answerCallbackQuery",
+            runtime,
+            fn: () => bot.api.answerCallbackQuery(callback.id),
+        }).catch(() => { });
         try {
             const data = (callback.data ?? "").trim();
             const callbackMessage = callback.message;
@@ -248,6 +262,37 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                         return;
                 }
             }
+            const paginationMatch = data.match(/^commands_page_(\d+|noop)(?::(.+))?$/);
+            if (paginationMatch) {
+                const pageValue = paginationMatch[1];
+                if (pageValue === "noop")
+                    return;
+                const page = Number.parseInt(pageValue, 10);
+                if (Number.isNaN(page) || page < 1)
+                    return;
+                const agentId = paginationMatch[2]?.trim() || resolveDefaultAgentId(cfg) || undefined;
+                const skillCommands = listSkillCommandsForAgents({
+                    cfg,
+                    agentIds: agentId ? [agentId] : undefined,
+                });
+                const result = buildCommandsMessagePaginated(cfg, skillCommands, {
+                    page,
+                    surface: "telegram",
+                });
+                const keyboard = result.totalPages > 1
+                    ? buildInlineKeyboard(buildCommandsPaginationKeyboard(result.currentPage, result.totalPages, agentId))
+                    : undefined;
+                try {
+                    await bot.api.editMessageText(callbackMessage.chat.id, callbackMessage.message_id, result.text, keyboard ? { reply_markup: keyboard } : undefined);
+                }
+                catch (editErr) {
+                    const errStr = String(editErr);
+                    if (!errStr.includes("message is not modified")) {
+                        throw editErr;
+                    }
+                }
+                return;
+            }
             const syntheticMessage = {
                 ...callbackMessage,
                 from: callback.from,
@@ -484,17 +529,34 @@ export const registerTelegramHandlers = ({ cfg, accountId, bot, opts, runtime, m
                 const errMsg = String(mediaErr);
                 if (errMsg.includes("exceeds") && errMsg.includes("MB limit")) {
                     const limitMb = Math.round(mediaMaxBytes / (1024 * 1024));
-                    await bot.api
-                        .sendMessage(chatId, `⚠️ File too large. Maximum size is ${limitMb}MB.`, {
-                        reply_to_message_id: msg.message_id,
-                    })
-                        .catch(() => { });
+                    await withTelegramApiErrorLogging({
+                        operation: "sendMessage",
+                        runtime,
+                        fn: () => bot.api.sendMessage(chatId, `⚠️ File too large. Maximum size is ${limitMb}MB.`, {
+                            reply_to_message_id: msg.message_id,
+                        }),
+                    }).catch(() => { });
                     logger.warn({ chatId, error: errMsg }, "media exceeds size limit");
                     return;
                 }
                 throw mediaErr;
             }
-            const allMedia = media ? [{ path: media.path, contentType: media.contentType }] : [];
+            // Skip sticker-only messages where the sticker was skipped (animated/video)
+            // These have no media and no text content to process.
+            const hasText = Boolean((msg.text ?? msg.caption ?? "").trim());
+            if (msg.sticker && !media && !hasText) {
+                logVerbose("telegram: skipping sticker-only message (unsupported sticker type)");
+                return;
+            }
+            const allMedia = media
+                ? [
+                    {
+                        path: media.path,
+                        contentType: media.contentType,
+                        stickerMetadata: media.stickerMetadata,
+                    },
+                ]
+                : [];
             const senderId = msg.from?.id ? String(msg.from.id) : "";
             const conversationKey = resolvedThreadId != null ? `${chatId}:topic:${resolvedThreadId}` : String(chatId);
             const debounceKey = senderId