@gguf/pigbot 0.0.1 → 0.0.2

package/dist/telegram/send.js

@@ -1,22 +1,58 @@
-import { Bot, InputFile } from "grammy";
+import { Bot, HttpError, InputFile } from "grammy";
 import { loadConfig } from "../config/config.js";
 import { logVerbose } from "../globals.js";
 import { recordChannelActivity } from "../infra/channel-activity.js";
-import { formatErrorMessage } from "../infra/errors.js";
+import { withTelegramApiErrorLogging } from "./api-logging.js";
+import { formatErrorMessage, formatUncaughtError } from "../infra/errors.js";
+import { isDiagnosticFlagEnabled } from "../infra/diagnostic-flags.js";
 import { createTelegramRetryRunner } from "../infra/retry-policy.js";
+import { redactSensitiveText } from "../logging/redact.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
 import { mediaKindFromMime } from "../media/constants.js";
 import { isGifMedia } from "../media/mime.js";
 import { loadWebMedia } from "../web/media.js";
 import { resolveTelegramAccount } from "./accounts.js";
 import { resolveTelegramFetch } from "./fetch.js";
+import { makeProxyFetch } from "./proxy.js";
 import { renderTelegramHtmlText } from "./format.js";
 import { resolveMarkdownTableMode } from "../config/markdown-tables.js";
+import { isRecoverableTelegramNetworkError } from "./network-errors.js";
 import { splitTelegramCaption } from "./caption.js";
 import { recordSentMessage } from "./sent-message-cache.js";
 import { parseTelegramTarget, stripTelegramInternalPrefixes } from "./targets.js";
 import { resolveTelegramVoiceSend } from "./voice.js";
 import { buildTelegramThreadParams } from "./bot/helpers.js";
 const PARSE_ERR_RE = /can't parse entities|parse entities|find end of the entity/i;
+const diagLogger = createSubsystemLogger("telegram/diagnostic");
+function createTelegramHttpLogger(cfg) {
+    const enabled = isDiagnosticFlagEnabled("telegram.http", cfg);
+    if (!enabled) {
+        return () => { };
+    }
+    return (label, err) => {
+        if (!(err instanceof HttpError))
+            return;
+        const detail = redactSensitiveText(formatUncaughtError(err.error ?? err));
+        diagLogger.warn(`telegram http error (${label}): ${detail}`);
+    };
+}
+function resolveTelegramClientOptions(account) {
+    const proxyUrl = account.config.proxy?.trim();
+    const proxyFetch = proxyUrl ? makeProxyFetch(proxyUrl) : undefined;
+    const fetchImpl = resolveTelegramFetch(proxyFetch, {
+        network: account.config.network,
+    });
+    const timeoutSeconds = typeof account.config.timeoutSeconds === "number" &&
+        Number.isFinite(account.config.timeoutSeconds)
+        ? Math.max(1, Math.floor(account.config.timeoutSeconds))
+        : undefined;
+    return fetchImpl || timeoutSeconds
+        ? {
+            ...(fetchImpl ? { fetch: fetchImpl } : {}),
+            ...(timeoutSeconds ? { timeoutSeconds } : {}),
+        }
+        : undefined;
+}
 function resolveToken(explicit, params) {
     if (explicit?.trim())
         return explicit.trim();
@@ -91,17 +127,7 @@ export async function sendMessageTelegram(to, text, opts = {}) {
     const chatId = normalizeChatId(target.chatId);
     // Use provided api or create a new Bot instance. The nullish coalescing
     // operator ensures api is always defined (Bot.api is always non-null).
-    const fetchImpl = resolveTelegramFetch();
-    const timeoutSeconds = typeof account.config.timeoutSeconds === "number" &&
-        Number.isFinite(account.config.timeoutSeconds)
-        ? Math.max(1, Math.floor(account.config.timeoutSeconds))
-        : undefined;
-    const client = fetchImpl || timeoutSeconds
-        ? {
-            ...(fetchImpl ? { fetch: fetchImpl } : {}),
-            ...(timeoutSeconds ? { timeoutSeconds } : {}),
-        }
-        : undefined;
+    const client = resolveTelegramClientOptions(account);
     const api = opts.api ?? new Bot(token, client ? { client } : undefined).api;
     const mediaUrl = opts.mediaUrl?.trim();
     const replyMarkup = buildInlineKeyboard(opts.buttons);
@@ -110,14 +136,32 @@ export async function sendMessageTelegram(to, text, opts = {}) {
     const messageThreadId = opts.messageThreadId != null ? opts.messageThreadId : target.messageThreadId;
     const threadIdParams = buildTelegramThreadParams(messageThreadId);
     const threadParams = threadIdParams ? { ...threadIdParams } : {};
+    const quoteText = opts.quoteText?.trim();
     if (opts.replyToMessageId != null) {
-        threadParams.reply_to_message_id = Math.trunc(opts.replyToMessageId);
+        if (quoteText) {
+            threadParams.reply_parameters = {
+                message_id: Math.trunc(opts.replyToMessageId),
+                quote: quoteText,
+            };
+        }
+        else {
+            threadParams.reply_to_message_id = Math.trunc(opts.replyToMessageId);
+        }
     }
     const hasThreadParams = Object.keys(threadParams).length > 0;
     const request = createTelegramRetryRunner({
         retry: opts.retry,
         configRetry: account.config.retry,
         verbose: opts.verbose,
+        shouldRetry: (err) => isRecoverableTelegramNetworkError(err, { context: "send" }),
+    });
+    const logHttpError = createTelegramHttpLogger(cfg);
+    const requestWithDiag = (fn, label) => withTelegramApiErrorLogging({
+        operation: label ?? "request",
+        fn: () => request(fn, label),
+    }).catch((err) => {
+        logHttpError(label ?? "request", err);
+        throw err;
     });
     const wrapChatNotFound = (err) => {
         if (!/400: Bad Request: chat not found/i.test(formatErrorMessage(err)))
@@ -135,17 +179,22 @@ export async function sendMessageTelegram(to, text, opts = {}) {
         accountId: account.accountId,
     });
     const renderHtmlText = (value) => renderTelegramHtmlText(value, { textMode, tableMode });
+    // Resolve link preview setting from config (default: enabled).
+    const linkPreviewEnabled = account.config.linkPreview ?? true;
+    const linkPreviewOptions = linkPreviewEnabled ? undefined : { is_disabled: true };
     const sendTelegramText = async (rawText, params, fallbackText) => {
         const htmlText = renderHtmlText(rawText);
-        const sendParams = params
-            ? {
-                parse_mode: "HTML",
-                ...params,
-            }
-            : {
-                parse_mode: "HTML",
-            };
-        const res = await request(() => api.sendMessage(chatId, htmlText, sendParams), "message").catch(async (err) => {
+        const baseParams = params ? { ...params } : {};
+        if (linkPreviewOptions) {
+            baseParams.link_preview_options = linkPreviewOptions;
+        }
+        const hasBaseParams = Object.keys(baseParams).length > 0;
+        const sendParams = {
+            parse_mode: "HTML",
+            ...baseParams,
+            ...(opts.silent === true ? { disable_notification: true } : {}),
+        };
+        const res = await requestWithDiag(() => api.sendMessage(chatId, htmlText, sendParams), "message").catch(async (err) => {
             // Telegram rejects malformed HTML (e.g., unsupported tags or entities).
             // When that happens, fall back to plain text so the message still delivers.
             const errText = formatErrorMessage(err);
@@ -154,8 +203,8 @@ export async function sendMessageTelegram(to, text, opts = {}) {
                     console.warn(`telegram HTML parse failed, retrying as plain text: ${errText}`);
                 }
                 const fallback = fallbackText ?? rawText;
-                const plainParams = params && Object.keys(params).length > 0 ? { ...params } : undefined;
-                return await request(() => plainParams
+                const plainParams = hasBaseParams ? baseParams : undefined;
+                return await requestWithDiag(() => plainParams
                     ? api.sendMessage(chatId, fallback, plainParams)
                     : api.sendMessage(chatId, fallback), "message-plain").catch((err2) => {
                     throw wrapChatNotFound(err2);
@@ -189,20 +238,21 @@ export async function sendMessageTelegram(to, text, opts = {}) {
             caption: htmlCaption,
             ...(htmlCaption ? { parse_mode: "HTML" } : {}),
             ...baseMediaParams,
+            ...(opts.silent === true ? { disable_notification: true } : {}),
         };
         let result;
         if (isGif) {
-            result = await request(() => api.sendAnimation(chatId, file, mediaParams), "animation").catch((err) => {
+            result = await requestWithDiag(() => api.sendAnimation(chatId, file, mediaParams), "animation").catch((err) => {
                 throw wrapChatNotFound(err);
             });
         }
         else if (kind === "image") {
-            result = await request(() => api.sendPhoto(chatId, file, mediaParams), "photo").catch((err) => {
+            result = await requestWithDiag(() => api.sendPhoto(chatId, file, mediaParams), "photo").catch((err) => {
                 throw wrapChatNotFound(err);
             });
         }
         else if (kind === "video") {
-            result = await request(() => api.sendVideo(chatId, file, mediaParams), "video").catch((err) => {
+            result = await requestWithDiag(() => api.sendVideo(chatId, file, mediaParams), "video").catch((err) => {
                 throw wrapChatNotFound(err);
             });
         }
@@ -214,18 +264,18 @@ export async function sendMessageTelegram(to, text, opts = {}) {
                 logFallback: logVerbose,
             });
             if (useVoice) {
-                result = await request(() => api.sendVoice(chatId, file, mediaParams), "voice").catch((err) => {
+                result = await requestWithDiag(() => api.sendVoice(chatId, file, mediaParams), "voice").catch((err) => {
                     throw wrapChatNotFound(err);
                 });
             }
             else {
-                result = await request(() => api.sendAudio(chatId, file, mediaParams), "audio").catch((err) => {
+                result = await requestWithDiag(() => api.sendAudio(chatId, file, mediaParams), "audio").catch((err) => {
                     throw wrapChatNotFound(err);
                 });
             }
         }
         else {
-            result = await request(() => api.sendDocument(chatId, file, mediaParams), "document").catch((err) => {
+            result = await requestWithDiag(() => api.sendDocument(chatId, file, mediaParams), "document").catch((err) => {
                 throw wrapChatNotFound(err);
             });
         }
@@ -287,15 +337,21 @@ export async function reactMessageTelegram(chatIdInput, messageIdInput, emoji, o
     const token = resolveToken(opts.token, account);
     const chatId = normalizeChatId(String(chatIdInput));
     const messageId = normalizeMessageId(messageIdInput);
-    const fetchImpl = resolveTelegramFetch();
-    const client = fetchImpl
-        ? { fetch: fetchImpl }
-        : undefined;
+    const client = resolveTelegramClientOptions(account);
     const api = opts.api ?? new Bot(token, client ? { client } : undefined).api;
     const request = createTelegramRetryRunner({
         retry: opts.retry,
         configRetry: account.config.retry,
         verbose: opts.verbose,
+        shouldRetry: (err) => isRecoverableTelegramNetworkError(err, { context: "send" }),
+    });
+    const logHttpError = createTelegramHttpLogger(cfg);
+    const requestWithDiag = (fn, label) => withTelegramApiErrorLogging({
+        operation: label ?? "request",
+        fn: () => request(fn, label),
+    }).catch((err) => {
+        logHttpError(label ?? "request", err);
+        throw err;
     });
     const remove = opts.remove === true;
     const trimmedEmoji = emoji.trim();
@@ -307,7 +363,7 @@ export async function reactMessageTelegram(chatIdInput, messageIdInput, emoji, o
     if (typeof api.setMessageReaction !== "function") {
         throw new Error("Telegram reactions are unavailable in this bot API.");
     }
-    await request(() => api.setMessageReaction(chatId, messageId, reactions), "reaction");
+    await requestWithDiag(() => api.setMessageReaction(chatId, messageId, reactions), "reaction");
     return { ok: true };
 }
 export async function deleteMessageTelegram(chatIdInput, messageIdInput, opts = {}) {
@@ -319,20 +375,90 @@ export async function deleteMessageTelegram(chatIdInput, messageIdInput, opts =
     const token = resolveToken(opts.token, account);
     const chatId = normalizeChatId(String(chatIdInput));
     const messageId = normalizeMessageId(messageIdInput);
-    const fetchImpl = resolveTelegramFetch();
-    const client = fetchImpl
-        ? { fetch: fetchImpl }
-        : undefined;
+    const client = resolveTelegramClientOptions(account);
     const api = opts.api ?? new Bot(token, client ? { client } : undefined).api;
     const request = createTelegramRetryRunner({
         retry: opts.retry,
         configRetry: account.config.retry,
         verbose: opts.verbose,
+        shouldRetry: (err) => isRecoverableTelegramNetworkError(err, { context: "send" }),
     });
-    await request(() => api.deleteMessage(chatId, messageId), "deleteMessage");
+    const logHttpError = createTelegramHttpLogger(cfg);
+    const requestWithDiag = (fn, label) => withTelegramApiErrorLogging({
+        operation: label ?? "request",
+        fn: () => request(fn, label),
+    }).catch((err) => {
+        logHttpError(label ?? "request", err);
+        throw err;
+    });
+    await requestWithDiag(() => api.deleteMessage(chatId, messageId), "deleteMessage");
     logVerbose(`[telegram] Deleted message ${messageId} from chat ${chatId}`);
     return { ok: true };
 }
+export async function editMessageTelegram(chatIdInput, messageIdInput, text, opts = {}) {
+    const cfg = opts.cfg ?? loadConfig();
+    const account = resolveTelegramAccount({
+        cfg,
+        accountId: opts.accountId,
+    });
+    const token = resolveToken(opts.token, account);
+    const chatId = normalizeChatId(String(chatIdInput));
+    const messageId = normalizeMessageId(messageIdInput);
+    const client = resolveTelegramClientOptions(account);
+    const api = opts.api ?? new Bot(token, client ? { client } : undefined).api;
+    const request = createTelegramRetryRunner({
+        retry: opts.retry,
+        configRetry: account.config.retry,
+        verbose: opts.verbose,
+    });
+    const logHttpError = createTelegramHttpLogger(cfg);
+    const requestWithDiag = (fn, label) => withTelegramApiErrorLogging({
+        operation: label ?? "request",
+        fn: () => request(fn, label),
+    }).catch((err) => {
+        logHttpError(label ?? "request", err);
+        throw err;
+    });
+    const textMode = opts.textMode ?? "markdown";
+    const tableMode = resolveMarkdownTableMode({
+        cfg,
+        channel: "telegram",
+        accountId: account.accountId,
+    });
+    const htmlText = renderTelegramHtmlText(text, { textMode, tableMode });
+    // Reply markup semantics:
+    // - buttons === undefined → don't send reply_markup (keep existing)
+    // - buttons is [] (or filters to empty) → send { inline_keyboard: [] } (remove)
+    // - otherwise → send built inline keyboard
+    const shouldTouchButtons = opts.buttons !== undefined;
+    const builtKeyboard = shouldTouchButtons ? buildInlineKeyboard(opts.buttons) : undefined;
+    const replyMarkup = shouldTouchButtons ? (builtKeyboard ?? { inline_keyboard: [] }) : undefined;
+    const editParams = {
+        parse_mode: "HTML",
+    };
+    if (replyMarkup !== undefined) {
+        editParams.reply_markup = replyMarkup;
+    }
+    await requestWithDiag(() => api.editMessageText(chatId, messageId, htmlText, editParams), "editMessage").catch(async (err) => {
+        // Telegram rejects malformed HTML. Fall back to plain text.
+        const errText = formatErrorMessage(err);
+        if (PARSE_ERR_RE.test(errText)) {
+            if (opts.verbose) {
+                console.warn(`telegram HTML parse failed, retrying as plain text: ${errText}`);
+            }
+            const plainParams = {};
+            if (replyMarkup !== undefined) {
+                plainParams.reply_markup = replyMarkup;
+            }
+            return await requestWithDiag(() => Object.keys(plainParams).length > 0
+                ? api.editMessageText(chatId, messageId, text, plainParams)
+                : api.editMessageText(chatId, messageId, text), "editMessage-plain");
+        }
+        throw err;
+    });
+    logVerbose(`[telegram] Edited message ${messageId} in chat ${chatId}`);
+    return { ok: true, messageId: String(messageId), chatId };
+}
 function inferFilename(kind) {
     switch (kind) {
         case "image":
@@ -345,3 +471,65 @@ function inferFilename(kind) {
             return "file.bin";
     }
 }
+/**
+ * Send a sticker to a Telegram chat by file_id.
+ * @param to - Chat ID or username (e.g., "123456789" or "@username")
+ * @param fileId - Telegram file_id of the sticker to send
+ * @param opts - Optional configuration
+ */
+export async function sendStickerTelegram(to, fileId, opts = {}) {
+    if (!fileId?.trim()) {
+        throw new Error("Telegram sticker file_id is required");
+    }
+    const cfg = loadConfig();
+    const account = resolveTelegramAccount({
+        cfg,
+        accountId: opts.accountId,
+    });
+    const token = resolveToken(opts.token, account);
+    const target = parseTelegramTarget(to);
+    const chatId = normalizeChatId(target.chatId);
+    const client = resolveTelegramClientOptions(account);
+    const api = opts.api ?? new Bot(token, client ? { client } : undefined).api;
+    const messageThreadId = opts.messageThreadId != null ? opts.messageThreadId : target.messageThreadId;
+    const threadIdParams = buildTelegramThreadParams(messageThreadId);
+    const threadParams = threadIdParams ? { ...threadIdParams } : {};
+    if (opts.replyToMessageId != null) {
+        threadParams.reply_to_message_id = Math.trunc(opts.replyToMessageId);
+    }
+    const hasThreadParams = Object.keys(threadParams).length > 0;
+    const request = createTelegramRetryRunner({
+        retry: opts.retry,
+        configRetry: account.config.retry,
+        verbose: opts.verbose,
+    });
+    const logHttpError = createTelegramHttpLogger(cfg);
+    const requestWithDiag = (fn, label) => request(fn, label).catch((err) => {
+        logHttpError(label ?? "request", err);
+        throw err;
+    });
+    const wrapChatNotFound = (err) => {
+        if (!/400: Bad Request: chat not found/i.test(formatErrorMessage(err)))
+            return err;
+        return new Error([
+            `Telegram send failed: chat not found (chat_id=${chatId}).`,
+            "Likely: bot not started in DM, bot removed from group/channel, group migrated (new -100… id), or wrong bot token.",
+            `Input was: ${JSON.stringify(to)}.`,
+        ].join(" "));
+    };
+    const stickerParams = hasThreadParams ? threadParams : undefined;
+    const result = await requestWithDiag(() => api.sendSticker(chatId, fileId.trim(), stickerParams), "sticker").catch((err) => {
+        throw wrapChatNotFound(err);
+    });
+    const messageId = String(result?.message_id ?? "unknown");
+    const resolvedChatId = String(result?.chat?.id ?? chatId);
+    if (result?.message_id) {
+        recordSentMessage(chatId, result.message_id);
+    }
+    recordChannelActivity({
+        channel: "telegram",
+        accountId: account.accountId,
+        direction: "outbound",
+    });
+    return { messageId, chatId: resolvedChatId };
+}

package/dist/telegram/sticker-cache.js

@@ -0,0 +1,202 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { STATE_DIR } from "../config/paths.js";
+import { loadJsonFile, saveJsonFile } from "../infra/json-file.js";
+import { logVerbose } from "../globals.js";
+import { findModelInCatalog, loadModelCatalog, modelSupportsVision, } from "../agents/model-catalog.js";
+import { resolveApiKeyForProvider } from "../agents/model-auth.js";
+import { resolveDefaultModelForAgent } from "../agents/model-selection.js";
+import { resolveAutoImageModel } from "../media-understanding/runner.js";
+const CACHE_FILE = path.join(STATE_DIR, "telegram", "sticker-cache.json");
+const CACHE_VERSION = 1;
+function loadCache() {
+    const data = loadJsonFile(CACHE_FILE);
+    if (!data || typeof data !== "object") {
+        return { version: CACHE_VERSION, stickers: {} };
+    }
+    const cache = data;
+    if (cache.version !== CACHE_VERSION) {
+        // Future: handle migration if needed
+        return { version: CACHE_VERSION, stickers: {} };
+    }
+    return cache;
+}
+function saveCache(cache) {
+    saveJsonFile(CACHE_FILE, cache);
+}
+/**
+ * Get a cached sticker by its unique ID.
+ */
+export function getCachedSticker(fileUniqueId) {
+    const cache = loadCache();
+    return cache.stickers[fileUniqueId] ?? null;
+}
+/**
+ * Add or update a sticker in the cache.
+ */
+export function cacheSticker(sticker) {
+    const cache = loadCache();
+    cache.stickers[sticker.fileUniqueId] = sticker;
+    saveCache(cache);
+}
+/**
+ * Search cached stickers by text query (fuzzy match on description + emoji + setName).
+ */
+export function searchStickers(query, limit = 10) {
+    const cache = loadCache();
+    const queryLower = query.toLowerCase();
+    const results = [];
+    for (const sticker of Object.values(cache.stickers)) {
+        let score = 0;
+        const descLower = sticker.description.toLowerCase();
+        // Exact substring match in description
+        if (descLower.includes(queryLower)) {
+            score += 10;
+        }
+        // Word-level matching
+        const queryWords = queryLower.split(/\s+/).filter(Boolean);
+        const descWords = descLower.split(/\s+/);
+        for (const qWord of queryWords) {
+            if (descWords.some((dWord) => dWord.includes(qWord))) {
+                score += 5;
+            }
+        }
+        // Emoji match
+        if (sticker.emoji && query.includes(sticker.emoji)) {
+            score += 8;
+        }
+        // Set name match
+        if (sticker.setName?.toLowerCase().includes(queryLower)) {
+            score += 3;
+        }
+        if (score > 0) {
+            results.push({ sticker, score });
+        }
+    }
+    return results
+        .sort((a, b) => b.score - a.score)
+        .slice(0, limit)
+        .map((r) => r.sticker);
+}
+/**
+ * Get all cached stickers (for debugging/listing).
+ */
+export function getAllCachedStickers() {
+    const cache = loadCache();
+    return Object.values(cache.stickers);
+}
+/**
+ * Get cache statistics.
+ */
+export function getCacheStats() {
+    const cache = loadCache();
+    const stickers = Object.values(cache.stickers);
+    if (stickers.length === 0) {
+        return { count: 0 };
+    }
+    const sorted = [...stickers].sort((a, b) => new Date(a.cachedAt).getTime() - new Date(b.cachedAt).getTime());
+    return {
+        count: stickers.length,
+        oldestAt: sorted[0]?.cachedAt,
+        newestAt: sorted[sorted.length - 1]?.cachedAt,
+    };
+}
+const STICKER_DESCRIPTION_PROMPT = "Describe this sticker image in 1-2 sentences. Focus on what the sticker depicts (character, object, action, emotion). Be concise and objective.";
+const VISION_PROVIDERS = ["openai", "anthropic", "google", "minimax"];
+/**
+ * Describe a sticker image using vision API.
+ * Auto-detects an available vision provider based on configured API keys.
+ * Returns null if no vision provider is available.
+ */
+export async function describeStickerImage(params) {
+    const { imagePath, cfg, agentDir, agentId } = params;
+    const defaultModel = resolveDefaultModelForAgent({ cfg, agentId });
+    let activeModel = undefined;
+    let catalog = [];
+    try {
+        catalog = await loadModelCatalog({ config: cfg });
+        const entry = findModelInCatalog(catalog, defaultModel.provider, defaultModel.model);
+        const supportsVision = modelSupportsVision(entry);
+        if (supportsVision) {
+            activeModel = { provider: defaultModel.provider, model: defaultModel.model };
+        }
+    }
+    catch {
+        // Ignore catalog failures; fall back to auto selection.
+    }
+    const hasProviderKey = async (provider) => {
+        try {
+            await resolveApiKeyForProvider({ provider, cfg, agentDir });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const selectCatalogModel = (provider) => {
+        const entries = catalog.filter((entry) => entry.provider.toLowerCase() === provider.toLowerCase() && modelSupportsVision(entry));
+        if (entries.length === 0)
+            return undefined;
+        const defaultId = provider === "openai"
+            ? "gpt-5-mini"
+            : provider === "anthropic"
+                ? "claude-opus-4-5"
+                : provider === "google"
+                    ? "gemini-3-flash-preview"
+                    : "MiniMax-VL-01";
+        const preferred = entries.find((entry) => entry.id === defaultId);
+        return preferred ?? entries[0];
+    };
+    let resolved = null;
+    if (activeModel &&
+        VISION_PROVIDERS.includes(activeModel.provider) &&
+        (await hasProviderKey(activeModel.provider))) {
+        resolved = activeModel;
+    }
+    if (!resolved) {
+        for (const provider of VISION_PROVIDERS) {
+            if (!(await hasProviderKey(provider)))
+                continue;
+            const entry = selectCatalogModel(provider);
+            if (entry) {
+                resolved = { provider, model: entry.id };
+                break;
+            }
+        }
+    }
+    if (!resolved) {
+        resolved = await resolveAutoImageModel({
+            cfg,
+            agentDir,
+            activeModel,
+        });
+    }
+    if (!resolved?.model) {
+        logVerbose("telegram: no vision provider available for sticker description");
+        return null;
+    }
+    const { provider, model } = resolved;
+    logVerbose(`telegram: describing sticker with ${provider}/${model}`);
+    try {
+        const buffer = await fs.readFile(imagePath);
+        // Dynamic import to avoid circular dependency
+        const { describeImageWithModel } = await import("../media-understanding/providers/image.js");
+        const result = await describeImageWithModel({
+            buffer,
+            fileName: "sticker.webp",
+            mime: "image/webp",
+            prompt: STICKER_DESCRIPTION_PROMPT,
+            cfg,
+            agentDir: agentDir ?? "",
+            provider,
+            model,
+            maxTokens: 150,
+            timeoutMs: 30000,
+        });
+        return result.text;
+    }
+    catch (err) {
+        logVerbose(`telegram: failed to describe sticker: ${String(err)}`);
+        return null;
+    }
+}

package/dist/telegram/webhook-set.js

@@ -1,21 +1,28 @@
 import { Bot } from "grammy";
 import { resolveTelegramFetch } from "./fetch.js";
+import { withTelegramApiErrorLogging } from "./api-logging.js";
 export async function setTelegramWebhook(opts) {
-    const fetchImpl = resolveTelegramFetch();
+    const fetchImpl = resolveTelegramFetch(undefined, { network: opts.network });
     const client = fetchImpl
         ? { fetch: fetchImpl }
         : undefined;
     const bot = new Bot(opts.token, client ? { client } : undefined);
-    await bot.api.setWebhook(opts.url, {
-        secret_token: opts.secret,
-        drop_pending_updates: opts.dropPendingUpdates ?? false,
+    await withTelegramApiErrorLogging({
+        operation: "setWebhook",
+        fn: () => bot.api.setWebhook(opts.url, {
+            secret_token: opts.secret,
+            drop_pending_updates: opts.dropPendingUpdates ?? false,
+        }),
     });
 }
 export async function deleteTelegramWebhook(opts) {
-    const fetchImpl = resolveTelegramFetch();
+    const fetchImpl = resolveTelegramFetch(undefined, { network: opts.network });
     const client = fetchImpl
         ? { fetch: fetchImpl }
         : undefined;
     const bot = new Bot(opts.token, client ? { client } : undefined);
-    await bot.api.deleteWebhook();
+    await withTelegramApiErrorLogging({
+        operation: "deleteWebhook",
+        fn: () => bot.api.deleteWebhook(),
+    });
 }

package/dist/telegram/webhook.js

@@ -6,6 +6,7 @@ import { defaultRuntime } from "../runtime.js";
 import { logWebhookError, logWebhookProcessed, logWebhookReceived, startDiagnosticHeartbeat, stopDiagnosticHeartbeat, } from "../logging/diagnostic.js";
 import { resolveTelegramAllowedUpdates } from "./allowed-updates.js";
 import { createTelegramBot } from "./bot.js";
+import { withTelegramApiErrorLogging } from "./api-logging.js";
 export async function startTelegramWebhook(opts) {
     const path = opts.path ?? "/telegram-webhook";
     const healthPath = opts.healthPath ?? "/healthz";
@@ -70,9 +71,13 @@ export async function startTelegramWebhook(opts) {
         }
     });
     const publicUrl = opts.publicUrl ?? `http://${host === "0.0.0.0" ? "localhost" : host}:${port}${path}`;
-    await bot.api.setWebhook(publicUrl, {
-        secret_token: opts.secret,
-        allowed_updates: resolveTelegramAllowedUpdates(),
+    await withTelegramApiErrorLogging({
+        operation: "setWebhook",
+        runtime,
+        fn: () => bot.api.setWebhook(publicUrl, {
+            secret_token: opts.secret,
+            allowed_updates: resolveTelegramAllowedUpdates(),
+        }),
     });
     await new Promise((resolve) => server.listen(port, host, resolve));
     runtime.log?.(`webhook listening on ${publicUrl}`);

package/dist/terminal/links.js

@@ -1,5 +1,5 @@
 import { formatTerminalLink } from "../utils.js";
-export const DOCS_ROOT = "https://docs.clawd.bot";
+export const DOCS_ROOT = "https://docs.molt.bot";
 export function formatDocsLink(path, label, opts) {
     const trimmed = path.trim();
     const url = trimmed.startsWith("http")