@poolzin/pool-bot 2026.2.0 → 2026.2.2

package/dist/telegram/monitor.js

@@ -1,9 +1,10 @@
 import { run } from "@grammyjs/runner";
-import { loadConfig } from "../config/config.js";
 import { resolveAgentMaxConcurrent } from "../config/agent-limits.js";
+import { loadConfig } from "../config/config.js";
 import { computeBackoff, sleepWithAbort } from "../infra/backoff.js";
 import { formatErrorMessage } from "../infra/errors.js";
-import { formatDurationMs } from "../infra/format-duration.js";
+import { formatDurationPrecise } from "../infra/format-time/format-duration.js";
+import { registerUnhandledRejectionHandler } from "../infra/unhandled-rejections.js";
 import { resolveTelegramAccount } from "./accounts.js";
 import { resolveTelegramAllowedUpdates } from "./allowed-updates.js";
 import { createTelegramBot } from "./bot.js";
@@ -50,101 +51,125 @@ const isGetUpdatesConflict = (err) => {
         .toLowerCase();
     return haystack.includes("getupdates");
 };
-export async function monitorTelegramProvider(opts = {}) {
-    const cfg = opts.config ?? loadConfig();
-    const account = resolveTelegramAccount({
-        cfg,
-        accountId: opts.accountId,
-    });
-    const token = opts.token?.trim() || account.token;
-    if (!token) {
-        throw new Error(`Telegram bot token missing for account "${account.accountId}" (set channels.telegram.accounts.${account.accountId}.botToken/tokenFile or TELEGRAM_BOT_TOKEN for default).`);
+/** Check if error is a Grammy HttpError (used to scope unhandled rejection handling) */
+const isGrammyHttpError = (err) => {
+    if (!err || typeof err !== "object") {
+        return false;
     }
-    const proxyFetch = opts.proxyFetch ??
-        (account.config.proxy ? makeProxyFetch(account.config.proxy) : undefined);
-    let lastUpdateId = await readTelegramUpdateOffset({
-        accountId: account.accountId,
-    });
-    const persistUpdateId = async (updateId) => {
-        if (lastUpdateId !== null && updateId <= lastUpdateId)
-            return;
-        lastUpdateId = updateId;
-        try {
-            await writeTelegramUpdateOffset({
-                accountId: account.accountId,
-                updateId,
-            });
-        }
-        catch (err) {
-            (opts.runtime?.error ?? console.error)(`telegram: failed to persist update offset: ${String(err)}`);
+    return err.name === "HttpError";
+};
+export async function monitorTelegramProvider(opts = {}) {
+    const log = opts.runtime?.error ?? console.error;
+    // Register handler for Grammy HttpError unhandled rejections.
+    // This catches network errors that escape the polling loop's try-catch
+    // (e.g., from setMyCommands during bot setup).
+    // We gate on isGrammyHttpError to avoid suppressing non-Telegram errors.
+    const unregisterHandler = registerUnhandledRejectionHandler((err) => {
+        if (isGrammyHttpError(err) && isRecoverableTelegramNetworkError(err, { context: "polling" })) {
+            log(`[telegram] Suppressed network error: ${formatErrorMessage(err)}`);
+            return true; // handled - don't crash
         }
-    };
-    const bot = createTelegramBot({
-        token,
-        runtime: opts.runtime,
-        proxyFetch,
-        config: cfg,
-        accountId: account.accountId,
-        updateOffset: {
-            lastUpdateId,
-            onUpdateId: persistUpdateId,
-        },
+        return false;
     });
-    if (opts.useWebhook) {
-        await startTelegramWebhook({
-            token,
+    try {
+        const cfg = opts.config ?? loadConfig();
+        const account = resolveTelegramAccount({
+            cfg,
+            accountId: opts.accountId,
+        });
+        const token = opts.token?.trim() || account.token;
+        if (!token) {
+            throw new Error(`Telegram bot token missing for account "${account.accountId}" (set channels.telegram.accounts.${account.accountId}.botToken/tokenFile or TELEGRAM_BOT_TOKEN for default).`);
+        }
+        const proxyFetch = opts.proxyFetch ??
+            (account.config.proxy ? makeProxyFetch(account.config.proxy) : undefined);
+        let lastUpdateId = await readTelegramUpdateOffset({
             accountId: account.accountId,
-            config: cfg,
-            path: opts.webhookPath,
-            port: opts.webhookPort,
-            secret: opts.webhookSecret,
-            runtime: opts.runtime,
-            fetch: proxyFetch,
-            abortSignal: opts.abortSignal,
-            publicUrl: opts.webhookUrl,
         });
-        return;
-    }
-    // Use grammyjs/runner for concurrent update processing
-    let restartAttempts = 0;
-    while (!opts.abortSignal?.aborted) {
-        const runner = run(bot, createTelegramRunnerOptions(cfg));
-        const stopOnAbort = () => {
-            if (opts.abortSignal?.aborted) {
-                void runner.stop();
+        const persistUpdateId = async (updateId) => {
+            if (lastUpdateId !== null && updateId <= lastUpdateId)
+                return;
+            lastUpdateId = updateId;
+            try {
+                await writeTelegramUpdateOffset({
+                    accountId: account.accountId,
+                    updateId,
+                });
+            }
+            catch (err) {
+                (opts.runtime?.error ?? console.error)(`telegram: failed to persist update offset: ${String(err)}`);
             }
         };
-        opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
-        try {
-            // runner.task() returns a promise that resolves when the runner stops
-            await runner.task();
+        const bot = createTelegramBot({
+            token,
+            runtime: opts.runtime,
+            proxyFetch,
+            config: cfg,
+            accountId: account.accountId,
+            updateOffset: {
+                lastUpdateId,
+                onUpdateId: persistUpdateId,
+            },
+        });
+        if (opts.useWebhook) {
+            await startTelegramWebhook({
+                token,
+                accountId: account.accountId,
+                config: cfg,
+                path: opts.webhookPath,
+                port: opts.webhookPort,
+                secret: opts.webhookSecret,
+                runtime: opts.runtime,
+                fetch: proxyFetch,
+                abortSignal: opts.abortSignal,
+                publicUrl: opts.webhookUrl,
+            });
             return;
         }
-        catch (err) {
-            if (opts.abortSignal?.aborted) {
-                throw err;
-            }
-            const isConflict = isGetUpdatesConflict(err);
-            const isRecoverable = isRecoverableTelegramNetworkError(err, { context: "polling" });
-            if (!isConflict && !isRecoverable) {
-                throw err;
-            }
-            restartAttempts += 1;
-            const delayMs = computeBackoff(TELEGRAM_POLL_RESTART_POLICY, restartAttempts);
-            const reason = isConflict ? "getUpdates conflict" : "network error";
-            const errMsg = formatErrorMessage(err);
-            (opts.runtime?.error ?? console.error)(`Telegram ${reason}: ${errMsg}; retrying in ${formatDurationMs(delayMs)}.`);
+        // Use grammyjs/runner for concurrent update processing
+        let restartAttempts = 0;
+        while (!opts.abortSignal?.aborted) {
+            const runner = run(bot, createTelegramRunnerOptions(cfg));
+            const stopOnAbort = () => {
+                if (opts.abortSignal?.aborted) {
+                    void runner.stop();
+                }
+            };
+            opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
             try {
-                await sleepWithAbort(delayMs, opts.abortSignal);
+                // runner.task() returns a promise that resolves when the runner stops
+                await runner.task();
+                return;
             }
-            catch (sleepErr) {
-                if (opts.abortSignal?.aborted)
-                    return;
-                throw sleepErr;
+            catch (err) {
+                if (opts.abortSignal?.aborted) {
+                    throw err;
+                }
+                const isConflict = isGetUpdatesConflict(err);
+                const isRecoverable = isRecoverableTelegramNetworkError(err, { context: "polling" });
+                if (!isConflict && !isRecoverable) {
+                    throw err;
+                }
+                restartAttempts += 1;
+                const delayMs = computeBackoff(TELEGRAM_POLL_RESTART_POLICY, restartAttempts);
+                const reason = isConflict ? "getUpdates conflict" : "network error";
+                const errMsg = formatErrorMessage(err);
+                (opts.runtime?.error ?? console.error)(`Telegram ${reason}: ${errMsg}; retrying in ${formatDurationPrecise(delayMs)}.`);
+                try {
+                    await sleepWithAbort(delayMs, opts.abortSignal);
+                }
+                catch (sleepErr) {
+                    if (opts.abortSignal?.aborted)
+                        return;
+                    throw sleepErr;
+                }
+            }
+            finally {
+                opts.abortSignal?.removeEventListener("abort", stopOnAbort);
             }
         }
-        finally {
-            opts.abortSignal?.removeEventListener("abort", stopOnAbort);
-        }
+    }
+    finally {
+        unregisterHandler();
     }
 }

package/dist/telegram/send.js

@@ -23,6 +23,7 @@ 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 THREAD_NOT_FOUND_RE = /400:\s*Bad Request:\s*message thread not found/i;
 const diagLogger = createSubsystemLogger("telegram/diagnostic");
 function createTelegramHttpLogger(cfg) {
     const enabled = isDiagnosticFlagEnabled("telegram.http", cfg);
@@ -101,6 +102,26 @@ function normalizeMessageId(raw) {
     }
     throw new Error("Message id is required for Telegram actions");
 }
+function isTelegramThreadNotFoundError(err) {
+    return THREAD_NOT_FOUND_RE.test(formatErrorMessage(err));
+}
+function hasMessageThreadIdParam(params) {
+    if (!params)
+        return false;
+    const value = params.message_thread_id;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (typeof value === "string")
+        return value.trim().length > 0;
+    return false;
+}
+function removeMessageThreadIdParam(params) {
+    if (!params || !hasMessageThreadIdParam(params))
+        return params;
+    const next = { ...params };
+    delete next.message_thread_id;
+    return Object.keys(next).length > 0 ? next : undefined;
+}
 export function buildInlineKeyboard(buttons) {
     if (!buttons?.length)
         return undefined;
@@ -136,8 +157,17 @@ 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({
@@ -163,6 +193,21 @@ export async function sendMessageTelegram(to, text, opts = {}) {
             `Input was: ${JSON.stringify(to)}.`,
         ].join(" "));
     };
+    const sendWithThreadFallback = async (params, label, attempt) => {
+        try {
+            return await attempt(params, label);
+        }
+        catch (err) {
+            if (!hasMessageThreadIdParam(params) || !isTelegramThreadNotFoundError(err)) {
+                throw err;
+            }
+            if (opts.verbose) {
+                console.warn(`telegram ${label} failed with message_thread_id, retrying without thread: ${formatErrorMessage(err)}`);
+            }
+            const retriedParams = removeMessageThreadIdParam(params);
+            return await attempt(retriedParams, `${label}-threadless`);
+        }
+    };
     const textMode = opts.textMode ?? "markdown";
     const tableMode = resolveMarkdownTableMode({
         cfg,
@@ -174,36 +219,40 @@ export async function sendMessageTelegram(to, text, opts = {}) {
     const linkPreviewEnabled = account.config.linkPreview ?? true;
     const linkPreviewOptions = linkPreviewEnabled ? undefined : { is_disabled: true };
     const sendTelegramText = async (rawText, params, fallbackText) => {
-        const htmlText = renderHtmlText(rawText);
-        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);
-            if (PARSE_ERR_RE.test(errText)) {
-                if (opts.verbose) {
-                    console.warn(`telegram HTML parse failed, retrying as plain text: ${errText}`);
-                }
-                const fallback = fallbackText ?? rawText;
-                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);
-                });
+        return await sendWithThreadFallback(params, "message", async (effectiveParams, label) => {
+            const htmlText = renderHtmlText(rawText);
+            const baseParams = effectiveParams ? { ...effectiveParams } : {};
+            if (linkPreviewOptions) {
+                baseParams.link_preview_options = linkPreviewOptions;
             }
-            throw wrapChatNotFound(err);
+            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), label).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);
+                if (PARSE_ERR_RE.test(errText)) {
+                    if (opts.verbose) {
+                        console.warn(`telegram HTML parse failed, retrying as plain text: ${errText}`);
+                    }
+                    const fallback = fallbackText ?? rawText;
+                    const plainParams = hasBaseParams
+                        ? baseParams
+                        : undefined;
+                    return await requestWithDiag(() => plainParams
+                        ? api.sendMessage(chatId, fallback, plainParams)
+                        : api.sendMessage(chatId, fallback), `${label}-plain`).catch((err2) => {
+                        throw wrapChatNotFound(err2);
+                    });
+                }
+                throw wrapChatNotFound(err);
+            });
+            return res;
         });
-        return res;
     };
     if (mediaUrl) {
         const media = await loadWebMedia(mediaUrl, opts.maxBytes);
@@ -212,9 +261,21 @@ export async function sendMessageTelegram(to, text, opts = {}) {
             contentType: media.contentType,
             fileName: media.fileName,
         });
+        const isVideoNote = kind === "video" && opts.asVideoNote === true;
         const fileName = media.fileName ?? (isGif ? "animation.gif" : inferFilename(kind)) ?? "file";
         const file = new InputFile(media.buffer, fileName);
-        const { caption, followUpText } = splitTelegramCaption(text);
+        let caption;
+        let followUpText;
+        if (isVideoNote) {
+            // Video notes don't support captions; send any text as follow-up.
+            caption = undefined;
+            followUpText = text.trim() ? text : undefined;
+        }
+        else {
+            const split = splitTelegramCaption(text);
+            caption = split.caption;
+            followUpText = split.followUpText;
+        }
         const htmlCaption = caption ? renderHtmlText(caption) : undefined;
         // If text exceeds Telegram's caption limit, send media without caption
         // then send text as a separate follow-up message.
@@ -226,26 +287,32 @@ export async function sendMessageTelegram(to, text, opts = {}) {
             ...(!needsSeparateText && replyMarkup ? { reply_markup: replyMarkup } : {}),
         };
         const mediaParams = {
-            caption: htmlCaption,
-            ...(htmlCaption ? { parse_mode: "HTML" } : {}),
+            ...(htmlCaption ? { caption: htmlCaption, parse_mode: "HTML" } : {}),
             ...baseMediaParams,
             ...(opts.silent === true ? { disable_notification: true } : {}),
         };
         let result;
         if (isGif) {
-            result = await requestWithDiag(() => api.sendAnimation(chatId, file, mediaParams), "animation").catch((err) => {
+            result = await sendWithThreadFallback(mediaParams, "animation", async (effectiveParams, label) => requestWithDiag(() => api.sendAnimation(chatId, file, effectiveParams), label).catch((err) => {
                 throw wrapChatNotFound(err);
-            });
+            }));
         }
         else if (kind === "image") {
-            result = await requestWithDiag(() => api.sendPhoto(chatId, file, mediaParams), "photo").catch((err) => {
+            result = await sendWithThreadFallback(mediaParams, "photo", async (effectiveParams, label) => requestWithDiag(() => api.sendPhoto(chatId, file, effectiveParams), label).catch((err) => {
                 throw wrapChatNotFound(err);
-            });
+            }));
         }
         else if (kind === "video") {
-            result = await requestWithDiag(() => api.sendVideo(chatId, file, mediaParams), "video").catch((err) => {
-                throw wrapChatNotFound(err);
-            });
+            if (isVideoNote) {
+                result = await sendWithThreadFallback(mediaParams, "video_note", async (effectiveParams, label) => requestWithDiag(() => api.sendVideoNote(chatId, file, effectiveParams), label).catch((err) => {
+                    throw wrapChatNotFound(err);
+                }));
+            }
+            else {
+                result = await sendWithThreadFallback(mediaParams, "video", async (effectiveParams, label) => requestWithDiag(() => api.sendVideo(chatId, file, effectiveParams), label).catch((err) => {
+                    throw wrapChatNotFound(err);
+                }));
+            }
         }
         else if (kind === "audio") {
             const { useVoice } = resolveTelegramVoiceSend({
@@ -255,20 +322,20 @@ export async function sendMessageTelegram(to, text, opts = {}) {
                 logFallback: logVerbose,
             });
             if (useVoice) {
-                result = await requestWithDiag(() => api.sendVoice(chatId, file, mediaParams), "voice").catch((err) => {
+                result = await sendWithThreadFallback(mediaParams, "voice", async (effectiveParams, label) => requestWithDiag(() => api.sendVoice(chatId, file, effectiveParams), label).catch((err) => {
                     throw wrapChatNotFound(err);
-                });
+                }));
             }
             else {
-                result = await requestWithDiag(() => api.sendAudio(chatId, file, mediaParams), "audio").catch((err) => {
+                result = await sendWithThreadFallback(mediaParams, "audio", async (effectiveParams, label) => requestWithDiag(() => api.sendAudio(chatId, file, effectiveParams), label).catch((err) => {
                     throw wrapChatNotFound(err);
-                });
+                }));
             }
         }
         else {
-            result = await requestWithDiag(() => api.sendDocument(chatId, file, mediaParams), "document").catch((err) => {
+            result = await sendWithThreadFallback(mediaParams, "document", async (effectiveParams, label) => requestWithDiag(() => api.sendDocument(chatId, file, effectiveParams), label).catch((err) => {
                 throw wrapChatNotFound(err);
-            });
+            }));
         }
         const mediaMessageId = String(result?.message_id ?? "unknown");
         const resolvedChatId = String(result?.chat?.id ?? chatId);
@@ -508,10 +575,25 @@ export async function sendStickerTelegram(to, fileId, opts = {}) {
             `Input was: ${JSON.stringify(to)}.`,
         ].join(" "));
     };
+    const sendWithStickerThreadFallback = async (params, label, attempt) => {
+        try {
+            return await attempt(params, label);
+        }
+        catch (err) {
+            if (!hasMessageThreadIdParam(params) || !isTelegramThreadNotFoundError(err)) {
+                throw err;
+            }
+            if (opts.verbose) {
+                console.warn(`telegram ${label} failed with message_thread_id, retrying without thread: ${formatErrorMessage(err)}`);
+            }
+            const retriedParams = removeMessageThreadIdParam(params);
+            return await attempt(retriedParams, `${label}-threadless`);
+        }
+    };
     const stickerParams = hasThreadParams ? threadParams : undefined;
-    const result = await requestWithDiag(() => api.sendSticker(chatId, fileId.trim(), stickerParams), "sticker").catch((err) => {
+    const result = await sendWithStickerThreadFallback(stickerParams, "sticker", async (effectiveParams, label) => requestWithDiag(() => api.sendSticker(chatId, fileId.trim(), effectiveParams), label).catch((err) => {
         throw wrapChatNotFound(err);
-    });
+    }));
     const messageId = String(result?.message_id ?? "unknown");
     const resolvedChatId = String(result?.chat?.id ?? chatId);
     if (result?.message_id) {

package/dist/terminal/restore.js

@@ -0,0 +1,45 @@
+import { clearActiveProgressLine } from "./progress-line.js";
+const RESET_SEQUENCE = "\x1b[0m\x1b[?25h\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?2004l";
+function reportRestoreFailure(scope, err, reason) {
+    const suffix = reason ? ` (${reason})` : "";
+    const message = `[terminal] restore ${scope} failed${suffix}: ${String(err)}`;
+    try {
+        process.stderr.write(`${message}\n`);
+    }
+    catch (writeErr) {
+        console.error(`[terminal] restore reporting failed${suffix}: ${String(writeErr)}`);
+    }
+}
+export function restoreTerminalState(reason) {
+    try {
+        clearActiveProgressLine();
+    }
+    catch (err) {
+        reportRestoreFailure("progress line", err, reason);
+    }
+    const stdin = process.stdin;
+    if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+        try {
+            stdin.setRawMode(false);
+        }
+        catch (err) {
+            reportRestoreFailure("raw mode", err, reason);
+        }
+        if (typeof stdin.isPaused === "function" && stdin.isPaused()) {
+            try {
+                stdin.resume();
+            }
+            catch (err) {
+                reportRestoreFailure("stdin resume", err, reason);
+            }
+        }
+    }
+    if (process.stdout.isTTY) {
+        try {
+            process.stdout.write(RESET_SEQUENCE);
+        }
+        catch (err) {
+            reportRestoreFailure("stdout reset", err, reason);
+        }
+    }
+}

package/dist/test-helpers/state-dir-env.js

@@ -0,0 +1,16 @@
+export function snapshotStateDirEnv() {
+    return {
+        clawdbotStateDir: process.env.CLAWDBOT_STATE_DIR,
+    };
+}
+export function restoreStateDirEnv(snapshot) {
+    if (snapshot.clawdbotStateDir === undefined) {
+        delete process.env.CLAWDBOT_STATE_DIR;
+    }
+    else {
+        process.env.CLAWDBOT_STATE_DIR = snapshot.clawdbotStateDir;
+    }
+}
+export function setStateDirEnv(stateDir) {
+    process.env.CLAWDBOT_STATE_DIR = stateDir;
+}

package/dist/tts/tts.js

@@ -579,9 +579,15 @@ export const OPENAI_TTS_MODELS = ["gpt-4o-mini-tts", "tts-1", "tts-1-hd"];
  * Custom OpenAI-compatible TTS endpoint.
  * When set, model/voice validation is relaxed to allow non-OpenAI models.
  * Example: OPENAI_TTS_BASE_URL=http://localhost:8880/v1
+ *
+ * Note: Read at runtime (not module load) to support config.env loading.
  */
-const OPENAI_TTS_BASE_URL = (process.env.OPENAI_TTS_BASE_URL?.trim() || "https://api.openai.com/v1").replace(/\/+$/, "");
-const isCustomOpenAIEndpoint = OPENAI_TTS_BASE_URL !== "https://api.openai.com/v1";
+function getOpenAITtsBaseUrl() {
+    return (process.env.OPENAI_TTS_BASE_URL?.trim() || "https://api.openai.com/v1").replace(/\/+$/, "");
+}
+function isCustomOpenAIEndpoint() {
+    return getOpenAITtsBaseUrl() !== "https://api.openai.com/v1";
+}
 export const OPENAI_TTS_VOICES = [
     "alloy",
     "ash",
@@ -595,13 +601,13 @@ export const OPENAI_TTS_VOICES = [
 ];
 function isValidOpenAIModel(model) {
     // Allow any model when using custom endpoint (e.g., Kokoro, LocalAI)
-    if (isCustomOpenAIEndpoint)
+    if (isCustomOpenAIEndpoint())
         return true;
     return OPENAI_TTS_MODELS.includes(model);
 }
 function isValidOpenAIVoice(voice) {
     // Allow any voice when using custom endpoint (e.g., Kokoro Chinese voices)
-    if (isCustomOpenAIEndpoint)
+    if (isCustomOpenAIEndpoint())
         return true;
     return OPENAI_TTS_VOICES.includes(voice);
 }
@@ -679,7 +685,7 @@ async function summarizeText(params) {
     catch (err) {
         const error = err;
         if (error.name === "AbortError") {
-            throw new Error("Summarization timed out");
+            throw new Error("Summarization timed out", { cause: err });
         }
         throw err;
     }
@@ -754,7 +760,7 @@ async function openaiTTS(params) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        const response = await fetch(`${OPENAI_TTS_BASE_URL}/audio/speech`, {
+        const response = await fetch(`${getOpenAITtsBaseUrl()}/audio/speech`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${apiKey}`,