@markusylisiurunen/tau 0.3.35 → 0.3.37

package/dist/core/telegram/adapter.js

@@ -27,14 +27,23 @@ const TELEGRAM_MESSAGE_BYTE_BUFFER_RATIO = 0.95;
 const TELEGRAM_SAFE_MESSAGE_BYTES = Math.floor(TELEGRAM_MAX_MESSAGE_BYTES * TELEGRAM_MESSAGE_BYTE_BUFFER_RATIO);
 const TELEGRAM_RICH_MESSAGE_SAFE_BYTES = Math.floor(TELEGRAM_MAX_RICH_MESSAGE_BYTES * TELEGRAM_MESSAGE_BYTE_BUFFER_RATIO);
 const TELEGRAM_MESSAGE_SPLIT_DELAY_MS = 1000;
+const TELEGRAM_DELIVERY_ATTEMPT_TIMEOUT_MS = 30_000;
+const TELEGRAM_DELIVERY_RETRY_DELAYS_MS = [1000, 5000];
 const TELEGRAM_TYPING_REFRESH_MS = 4000;
 const ABORTED = Symbol("aborted");
+const TIMED_OUT = Symbol("timed-out");
 const CALLBACK_ACTION_PREFIX = "tau:action:";
 const MAX_TELEGRAM_ATTACHMENTS_PER_TURN = 10;
 const MAX_TELEGRAM_ATTACHMENT_FILE_BYTES = 20 * 1024 * 1024;
 const MAX_TELEGRAM_ATTACHMENT_TOTAL_BYTES = 50 * 1024 * 1024;
 const MAX_TELEGRAM_GROUP_PENDING_MESSAGES = 50;
 const TELEGRAM_ATTACHMENT_TEMP_DIR_PREFIX = "tau-telegram-attachments-";
+const TELEGRAM_REASONING_EFFORTS = [
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+];
 const NO_ACTIVE_SESSION_MESSAGE = "no active session. use /new.";
 const SUPPORTED_TEXT_ATTACHMENT_EXTENSIONS = new Set([
     ".txt",
@@ -350,29 +359,41 @@ function formatTelegramSender(user) {
     }
     return `id ${user.id}`;
 }
-function formatTelegramSessionName(session) {
-    return `${session.projectId} session ${session.id}`;
+function formatTelegramSessionName(sessionId, projectLabel) {
+    return `${projectLabel} session ${sessionId}`;
 }
 function formatProjectLabel(projectId, project) {
     return "projectIds" in project ? `${projectId} (${project.projectIds.join(", ")})` : projectId;
 }
 function formatSessionStatus(session, project, snapshot, preferredProjectId) {
-    const projectStatus = `project: ${formatProjectLabel(session.projectId, project)}.`;
+    const sessionName = formatTelegramSessionName(session.id, formatProjectLabel(session.projectId, project));
     const preferenceStatus = preferredProjectId && preferredProjectId !== session.projectId
-        ? ` new chats will use: ${preferredProjectId}.`
+        ? ` new chats will use ${preferredProjectId}.`
         : "";
-    if (session.state === "failed" && session.error) {
-        return `${projectStatus} your session ${session.id} failed. ${ensureTerminalPunctuation(session.error)}${preferenceStatus}`;
-    }
-    const status = `${projectStatus} your session ${session.id} is ${session.state}.`;
+    if (session.state === "failed") {
+        const errorStatus = session.error ? ` ${ensureTerminalPunctuation(session.error)}` : "";
+        return `your ${sessionName} failed.${errorStatus}${preferenceStatus}`;
+    }
+    const state = {
+        queued: "queued",
+        "preparing-workspace": "preparing its workspace",
+        running: "running",
+        "waiting-input": "waiting for input",
+    }[session.state];
+    const status = `your ${sessionName} is ${state}.`;
     if (!snapshot) {
         return `${status}${preferenceStatus}`;
     }
+    const goalStatus = snapshot.goal
+        ? snapshot.goal.status === "active"
+            ? " it is pursuing a goal."
+            : " its goal is blocked."
+        : "";
     const model = snapshot.bootstrap.model.name || snapshot.bootstrap.model.id;
     const reasoning = snapshot.settings.reasoning ?? "none";
     const context = formatTelegramContextUsage(snapshot);
     const cost = formatTelegramSessionCost(getTelegramSessionCostTotal(snapshot));
-    return `${status} it is using ${model} with ${reasoning} reasoning. context usage is ${context}. cumulative cost is ${cost}.${preferenceStatus}`;
+    return `${status}${goalStatus} it is using ${model} with ${reasoning} reasoning. context usage is ${context}. cumulative cost is ${cost}.${preferenceStatus}`;
 }
 function ensureTerminalPunctuation(text) {
     const trimmed = text.trim();
@@ -391,6 +412,17 @@ function formatTelegramContextUsage(snapshot) {
 function getTelegramSessionCostTotal(snapshot) {
     return snapshot.costTotal;
 }
+function supportsReasoningEffort(snapshot, reasoning) {
+    if (!snapshot.bootstrap.model.reasoning) {
+        return false;
+    }
+    const persona = snapshot.catalog.personas.find((candidate) => candidate.id === snapshot.settings.personaId);
+    if (!persona) {
+        return false;
+    }
+    const allowed = persona.allowedReasoningLevels;
+    return !allowed || allowed.length === 0 || allowed.includes(reasoning);
+}
 function formatTelegramSessionCost(total) {
     return `$${formatAdaptiveNumber(total, 2, 5)}`;
 }
@@ -443,17 +475,23 @@ function parseOrThrow(schema, raw, message) {
     }
     return parsed.data;
 }
+const TelegramFailureEnvelopeSchema = z.object({
+    ok: z.literal(false),
+    error_code: z.number().int(),
+    description: z.string(),
+    parameters: z
+        .object({
+        retry_after: z.number().int().nonnegative().optional(),
+    })
+        .optional(),
+});
 const TelegramEnvelopeSchema = z.discriminatedUnion("ok", [
     z.object({
         ok: z.literal(true),
         description: z.string().optional(),
         result: z.unknown(),
     }),
-    z.object({
-        ok: z.literal(false),
-        description: z.string().optional(),
-        result: z.unknown().optional(),
-    }),
+    TelegramFailureEnvelopeSchema,
 ]);
 const TelegramChatSchema = telegramObject({ id: z.number(), type: z.string() });
 const TelegramUserSchema = telegramPartialObject({
@@ -508,6 +546,26 @@ const TelegramGetFileResultSchema = z.object({ file_path: z.string() });
 const TelegramGetMeResultSchema = telegramObject({ username: z.string() });
 const TelegramAckResultSchema = z.literal(true);
 const MAX_TELEGRAM_ERROR_DETAIL_LENGTH = 500;
+export class TelegramRequestError extends Error {
+    retryable;
+    retryAfterMs;
+    constructor(message, options) {
+        super(message, { cause: options.cause });
+        this.name = "TelegramRequestError";
+        this.retryable = options.retryable;
+        this.retryAfterMs = options.retryAfterMs;
+    }
+}
+class TelegramDeliveryError extends Error {
+    attempts;
+    retryable;
+    constructor(cause, attempts, retryable) {
+        super(cause instanceof Error ? cause.message : String(cause), { cause });
+        this.name = "TelegramDeliveryError";
+        this.attempts = attempts;
+        this.retryable = retryable;
+    }
+}
 function getErrorCode(error) {
     if (typeof error !== "object" || error === null || !("code" in error)) {
         return undefined;
@@ -528,23 +586,38 @@ function truncateTelegramErrorDetail(detail) {
     }
     return `${detail.slice(0, MAX_TELEGRAM_ERROR_DETAIL_LENGTH)}…`;
 }
-async function readTelegramHttpErrorDetail(response) {
-    const responseText = (await response.text()).trim();
-    if (!responseText) {
-        return "";
+function isRetryableTelegramErrorCode(errorCode) {
+    return errorCode === 408 || errorCode === 429 || (errorCode >= 500 && errorCode <= 599);
+}
+function getTelegramRetryAfterMs(envelope) {
+    const retryAfterSeconds = envelope.parameters?.retry_after;
+    return retryAfterSeconds === undefined ? undefined : retryAfterSeconds * 1000;
+}
+function parseTelegramHttpError(responseText) {
+    const trimmedResponseText = responseText.trim();
+    if (!trimmedResponseText) {
+        return { detail: "" };
     }
     try {
-        const parsed = TelegramEnvelopeSchema.safeParse(JSON.parse(responseText));
-        if (parsed.success && parsed.data.description?.trim()) {
-            return truncateTelegramErrorDetail(parsed.data.description.trim());
+        const parsed = TelegramFailureEnvelopeSchema.safeParse(JSON.parse(trimmedResponseText));
+        if (parsed.success) {
+            return {
+                detail: truncateTelegramErrorDetail(parsed.data.description.trim()),
+                errorCode: parsed.data.error_code,
+                retryAfterMs: getTelegramRetryAfterMs(parsed.data),
+            };
         }
     }
     catch { }
-    return truncateTelegramErrorDetail(responseText);
+    return { detail: truncateTelegramErrorDetail(trimmedResponseText) };
+}
+function asPermanentTelegramRequestError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return new TelegramRequestError(message, { retryable: false, cause: error });
 }
 function createTelegramApi(botToken) {
     const apiUrl = `https://api.telegram.org/bot${botToken}`;
-    async function callTelegramMethod(method, payload, resultSchema) {
+    async function callTelegramMethod(method, payload, resultSchema, signal) {
         let response;
         try {
             response = await fetch(`${apiUrl}/${method}`, {
@@ -553,28 +626,68 @@ function createTelegramApi(botToken) {
                     "content-type": "application/json",
                 },
                 body: JSON.stringify(payload),
+                signal,
             });
         }
         catch (error) {
-            throw new Error(`telegram ${method} network request failed: ${formatTelegramNetworkError(error)}`);
+            throw new TelegramRequestError(`telegram ${method} network request failed: ${formatTelegramNetworkError(error)}`, { retryable: true, cause: error });
         }
         if (!response.ok) {
-            const detail = await readTelegramHttpErrorDetail(response);
-            throw new Error(`telegram ${method} failed: HTTP ${response.status}${detail ? `: ${detail}` : ""}`);
+            let responseText;
+            try {
+                responseText = await response.text();
+            }
+            catch (error) {
+                throw new TelegramRequestError(`telegram ${method} failed: HTTP ${response.status}: response body read failed: ${formatTelegramNetworkError(error)}`, {
+                    retryable: isRetryableTelegramErrorCode(response.status),
+                    cause: error,
+                });
+            }
+            const { detail, errorCode, retryAfterMs } = parseTelegramHttpError(responseText);
+            throw new TelegramRequestError(`telegram ${method} failed: HTTP ${response.status}${detail ? `: ${detail}` : ""}`, {
+                retryable: isRetryableTelegramErrorCode(response.status) ||
+                    (errorCode !== undefined && isRetryableTelegramErrorCode(errorCode)),
+                ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+            });
+        }
+        let responseText;
+        try {
+            responseText = await response.text();
+        }
+        catch (error) {
+            throw new TelegramRequestError(`telegram ${method} response body read failed: ${formatTelegramNetworkError(error)}`, { retryable: true, cause: error });
         }
         let raw;
         try {
-            raw = await response.json();
+            raw = JSON.parse(responseText);
         }
-        catch {
-            throw new Error(`telegram ${method} returned invalid JSON`);
+        catch (error) {
+            throw new TelegramRequestError(`telegram ${method} returned invalid JSON`, {
+                retryable: false,
+                cause: error,
+            });
+        }
+        let envelope;
+        try {
+            envelope = parseOrThrow(TelegramEnvelopeSchema, raw, `telegram ${method} returned an invalid response payload`);
+        }
+        catch (error) {
+            throw asPermanentTelegramRequestError(error);
         }
-        const envelope = parseOrThrow(TelegramEnvelopeSchema, raw, `telegram ${method} returned an invalid response payload`);
         if (!envelope.ok) {
-            const detail = envelope.description?.trim() ?? "";
-            throw new Error(`telegram ${method} request failed${detail ? `: ${detail}` : ""}`);
+            const detail = envelope.description.trim();
+            const retryAfterMs = getTelegramRetryAfterMs(envelope);
+            throw new TelegramRequestError(`telegram ${method} request failed${detail ? `: ${detail}` : ""}`, {
+                retryable: isRetryableTelegramErrorCode(envelope.error_code),
+                ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+            });
+        }
+        try {
+            return parseOrThrow(resultSchema, envelope.result, `telegram ${method} returned an invalid result`);
+        }
+        catch (error) {
+            throw asPermanentTelegramRequestError(error);
         }
-        return parseOrThrow(resultSchema, envelope.result, `telegram ${method} returned an invalid result`);
     }
     return {
         async getMe() {
@@ -592,7 +705,7 @@ function createTelegramApi(botToken) {
                 chat_id: chatId,
                 text,
                 ...(options?.replyMarkup ? { reply_markup: options.replyMarkup } : {}),
-            }, z.unknown());
+            }, z.unknown(), options.signal);
         },
         async sendRichMessage(chatId, markdown, options) {
             await callTelegramMethod("sendRichMessage", {
@@ -601,7 +714,7 @@ function createTelegramApi(botToken) {
                     markdown,
                 },
                 ...(options?.replyMarkup ? { reply_markup: options.replyMarkup } : {}),
-            }, z.unknown());
+            }, z.unknown(), options.signal);
         },
         async sendChatAction(chatId, action) {
             await callTelegramMethod("sendChatAction", {
@@ -681,6 +794,8 @@ class TelegramAdapterImpl {
     attachmentTempDirsBySession = new Map();
     updateQueueTailByKey = new Map();
     inFlightUpdateTasks = new Set();
+    notificationQueueTailByChat = new Map();
+    inFlightNotificationTasks = new Set();
     unsubscribeSessionEvents;
     loopPromise;
     nextUpdateOffset = 0;
@@ -750,6 +865,7 @@ class TelegramAdapterImpl {
         try {
             await this.loopPromise;
             await this.waitForInFlightUpdateTasks();
+            await Promise.allSettled(Array.from(this.inFlightNotificationTasks));
             for (const sessionId of Array.from(this.chatsBySession.keys())) {
                 this.stopTypingIndicators(sessionId);
             }
@@ -771,36 +887,38 @@ class TelegramAdapterImpl {
             {
                 command: "/new",
                 description: "start a new session",
-                usage: "/new",
                 callbackAction: "new",
                 handler: async (chatId, args, sourceMessageId) => this.handleNew(chatId, args, sourceMessageId),
             },
             {
                 command: "/status",
                 description: "show active session status",
-                usage: "/status",
                 callbackAction: "status",
                 handler: async (chatId) => this.handleStatus(chatId),
             },
             {
                 command: "/compact",
                 description: "compact session context",
-                usage: "/compact",
                 handler: async (chatId, args) => this.handleCompact(chatId, args),
             },
             {
                 command: "/interrupt",
                 description: "interrupt active run",
-                usage: "/interrupt",
                 callbackAction: "interrupt",
                 handler: async (chatId) => this.handleInterrupt(chatId),
             },
         ];
+        for (const reasoning of TELEGRAM_REASONING_EFFORTS) {
+            definitions.push({
+                command: `/effort_${reasoning}`,
+                description: `set reasoning effort to ${reasoning}`,
+                handler: async (chatId, args) => this.handleSetReasoning(chatId, reasoning, args),
+            });
+        }
         for (const projectId of this.allowedProjectIds) {
             definitions.push({
                 command: `/use_${projectId}`,
                 description: `use ${projectId} for new sessions`,
-                usage: `/use_${projectId}`,
                 handler: async (chatId, args) => this.handleUseProject(chatId, projectId, args),
             });
         }
@@ -901,14 +1019,14 @@ class TelegramAdapterImpl {
             timeoutSeconds: this.requestTimeoutSeconds,
             allowedUpdates: ["message", "callback_query"],
         }));
-        if (updates === undefined) {
+        if (updates === ABORTED) {
             return [];
         }
         return updates;
     }
     async raceWithAbort(promise) {
         if (this.abortController.signal.aborted) {
-            return undefined;
+            return ABORTED;
         }
         let abortListener;
         const abortPromise = new Promise((resolve) => {
@@ -921,7 +1039,7 @@ class TelegramAdapterImpl {
             this.abortController.signal.removeEventListener("abort", abortListener);
         }
         if (raceResult === ABORTED) {
-            return undefined;
+            return ABORTED;
         }
         if (!raceResult.ok) {
             throw raceResult.error;
@@ -1467,6 +1585,32 @@ class TelegramAdapterImpl {
             await this.reply(chatId, `failed to save project preference: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    async handleSetReasoning(chatId, reasoning, args) {
+        if (args.length > 0) {
+            await this.reply(chatId, `usage: /effort_${reasoning}`);
+            return;
+        }
+        const session = await this.requireActiveSession(chatId);
+        if (!session) {
+            return;
+        }
+        try {
+            const sessionManager = this.getSessionManagerForChat(chatId);
+            const snapshot = await sessionManager.getSessionSnapshot(session.id);
+            if (!snapshot) {
+                throw new TelegramSessionManagerError("not_ready", "session is still preparing");
+            }
+            if (!supportsReasoningEffort(snapshot, reasoning)) {
+                await this.reply(chatId, `reasoning effort ${reasoning} is not supported by this session.`);
+                return;
+            }
+            await sessionManager.setReasoning(session.id, reasoning);
+            await this.reply(chatId, `reasoning effort set to ${reasoning}.`);
+        }
+        catch (error) {
+            await this.reply(chatId, this.formatManagerError(error));
+        }
+    }
     async handleNew(chatId, args, sourceMessageId) {
         const parsed = this.resolveNewCommand(chatId, args);
         if ("error" in parsed) {
@@ -1495,7 +1639,7 @@ class TelegramAdapterImpl {
         const session = this.getActiveSession(chatId);
         if (!session) {
             await this.reply(chatId, preferredProjectId
-                ? `new chats will use: ${preferredProjectId}.`
+                ? `new chats will use ${preferredProjectId}.`
                 : "no active session. select a project with /use_<project>.");
             return;
         }
@@ -1544,10 +1688,10 @@ class TelegramAdapterImpl {
             const sessionManager = this.getSessionManagerForChat(chatId);
             const result = await sessionManager.interruptSession(session.id);
             if (!result.interrupted) {
-                await this.reply(chatId, `nothing is running in ${formatTelegramSessionName(result.session)}.`);
+                await this.reply(chatId, `nothing is running in ${formatTelegramSessionName(result.session.id, result.session.projectId)}.`);
                 return;
             }
-            await this.reply(chatId, `stopping ${formatTelegramSessionName(result.session)}.`);
+            await this.reply(chatId, `stopping ${formatTelegramSessionName(result.session.id, result.session.projectId)}.`);
         }
         catch (error) {
             await this.reply(chatId, this.formatManagerError(error));
@@ -1891,8 +2035,7 @@ class TelegramAdapterImpl {
                 return;
             }
             this.notifySession(event.sessionId, [
-                formatSessionHeadline(event.sessionId, "provision failed"),
-                `project: ${event.targetProjectId}`,
+                `provisioning ${event.targetProjectId} failed in your ${formatTelegramSessionName(event.sessionId, event.projectId)}.`,
                 truncateText(event.diagnostic, MAX_PROVISION_DIAGNOSTIC_CHARS),
                 "the session remains available.",
             ].join("\n"));
@@ -1975,19 +2118,19 @@ class TelegramAdapterImpl {
         }
         this.notifySession(event.sessionId, isVerbose
             ? [formatSessionHeadline(event.sessionId, "assistant message"), event.progress.text].join("\n")
-            : event.progress.text, { rich: true });
+            : event.progress.text, { rich: true, messageId: event.progress.messageId });
     }
     notifyLifecycle(sessionId, projectId, state) {
-        const stateLabel = {
-            started: "run started",
-            finished: "run finished",
-            failed: "run failed",
-        }[state];
+        const sessionName = formatTelegramSessionName(sessionId, projectId);
         if (state === "failed") {
-            this.notifySession(sessionId, `something went wrong in ${projectId} session ${sessionId}.`);
+            this.notifySession(sessionId, `something went wrong in your ${sessionName}.`);
             return;
         }
-        this.notifySession(sessionId, [formatSessionHeadline(sessionId, stateLabel), `project: ${projectId}`].join("\n"));
+        const stateLabel = {
+            started: "started a run",
+            finished: "finished its run",
+        }[state];
+        this.notifySession(sessionId, `your ${sessionName} ${stateLabel}.`);
     }
     notifySession(sessionId, text, options = {}) {
         const chatIds = this.chatsBySession.get(sessionId);
@@ -1995,14 +2138,44 @@ class TelegramAdapterImpl {
             return;
         }
         for (const chatId of chatIds) {
-            void this.reply(chatId, text, { rich: options.rich }).catch((error) => {
-                this.log("warn", "failed to send telegram notification", {
-                    chatId,
-                    cause: error instanceof Error ? error.message : String(error),
-                });
-            });
+            this.enqueueNotification(sessionId, chatId, text, options);
         }
     }
+    enqueueNotification(sessionId, chatId, text, options) {
+        const previousTask = this.notificationQueueTailByChat.get(chatId) ?? Promise.resolve();
+        const queuedTask = previousTask
+            .then(async () => {
+            if (this.abortController.signal.aborted) {
+                return;
+            }
+            await this.reply(chatId, text, { rich: options.rich });
+        })
+            .catch((error) => {
+            if (this.abortController.signal.aborted) {
+                return;
+            }
+            const deliveryError = error instanceof TelegramDeliveryError
+                ? error
+                : new TelegramDeliveryError(error, 1, false);
+            this.log("error", deliveryError.retryable
+                ? "telegram notification delivery retries exhausted"
+                : "failed to send telegram notification", {
+                sessionId,
+                chatId,
+                ...(options.rich === true ? { messageId: options.messageId } : {}),
+                attempts: deliveryError.attempts,
+                cause: deliveryError.message,
+            });
+        });
+        const trackedTask = queuedTask.finally(() => {
+            this.inFlightNotificationTasks.delete(trackedTask);
+            if (this.notificationQueueTailByChat.get(chatId) === trackedTask) {
+                this.notificationQueueTailByChat.delete(chatId);
+            }
+        });
+        this.notificationQueueTailByChat.set(chatId, trackedTask);
+        this.inFlightNotificationTasks.add(trackedTask);
+    }
     startTypingIndicators(sessionId) {
         const chatIds = this.chatsBySession.get(sessionId);
         if (!chatIds) {
@@ -2079,7 +2252,7 @@ class TelegramAdapterImpl {
         }
     }
     formatSessionReady(sessionId, projectId) {
-        return `all set, your ${projectId} session ${sessionId} is ready.`;
+        return `all set, your ${formatTelegramSessionName(sessionId, projectId)} is ready.`;
     }
     formatMessageQueued(sessionId) {
         return formatSessionHeadline(sessionId, "message queued");
@@ -2115,9 +2288,13 @@ class TelegramAdapterImpl {
     async replyWithRichMessage(chatId, text, replyMarkup) {
         const chunks = splitTelegramRichMessage(text);
         for (const [index, chunk] of chunks.entries()) {
-            await this.api.sendRichMessage(chatId, chunk, {
+            const result = await this.sendWithRetry((signal) => this.api.sendRichMessage(chatId, chunk, {
                 replyMarkup: index === chunks.length - 1 ? replyMarkup : undefined,
-            });
+                signal,
+            }));
+            if (result === ABORTED) {
+                return;
+            }
             if (index < chunks.length - 1) {
                 await this.wait(TELEGRAM_MESSAGE_SPLIT_DELAY_MS);
             }
@@ -2126,14 +2303,89 @@ class TelegramAdapterImpl {
     async replyWithPlainMessage(chatId, text, replyMarkup) {
         const chunks = splitTelegramMessage(text);
         for (const [index, chunk] of chunks.entries()) {
-            await this.api.sendMessage(chatId, chunk, {
+            const result = await this.sendWithRetry((signal) => this.api.sendMessage(chatId, chunk, {
                 replyMarkup: index === chunks.length - 1 ? replyMarkup : undefined,
-            });
+                signal,
+            }));
+            if (result === ABORTED) {
+                return;
+            }
             if (index < chunks.length - 1) {
                 await this.wait(TELEGRAM_MESSAGE_SPLIT_DELAY_MS);
             }
         }
     }
+    async sendWithRetry(send) {
+        for (let attempt = 1;; attempt += 1) {
+            try {
+                const result = await this.runDeliveryAttempt(send);
+                if (result === ABORTED) {
+                    return ABORTED;
+                }
+                return;
+            }
+            catch (error) {
+                if (this.abortController.signal.aborted) {
+                    return ABORTED;
+                }
+                const retryDelayMs = TELEGRAM_DELIVERY_RETRY_DELAYS_MS[attempt - 1];
+                const retryable = error instanceof TelegramRequestError && error.retryable;
+                if (!retryable || retryDelayMs === undefined) {
+                    throw new TelegramDeliveryError(error, attempt, retryable);
+                }
+                await this.wait(Math.max(retryDelayMs, error.retryAfterMs ?? 0));
+                if (this.abortController.signal.aborted) {
+                    return ABORTED;
+                }
+            }
+        }
+    }
+    async runDeliveryAttempt(send) {
+        if (this.abortController.signal.aborted) {
+            return ABORTED;
+        }
+        const attemptController = new AbortController();
+        let abortListener;
+        const abortPromise = new Promise((resolve) => {
+            abortListener = () => {
+                resolve(ABORTED);
+                attemptController.abort();
+            };
+            this.abortController.signal.addEventListener("abort", abortListener, { once: true });
+        });
+        let timeout;
+        const timeoutPromise = new Promise((resolve) => {
+            timeout = setTimeout(() => {
+                resolve(TIMED_OUT);
+                attemptController.abort();
+            }, TELEGRAM_DELIVERY_ATTEMPT_TIMEOUT_MS);
+            timeout.unref?.();
+        });
+        let sendPromise;
+        try {
+            sendPromise = send(attemptController.signal);
+        }
+        catch (error) {
+            sendPromise = Promise.reject(error);
+        }
+        const settled = sendPromise.then(() => ({ ok: true }), (error) => ({ ok: false, error }));
+        const raceResult = await Promise.race([settled, abortPromise, timeoutPromise]);
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+        if (abortListener) {
+            this.abortController.signal.removeEventListener("abort", abortListener);
+        }
+        if (raceResult === ABORTED) {
+            return ABORTED;
+        }
+        if (raceResult === TIMED_OUT) {
+            throw new TelegramRequestError(`telegram delivery attempt timed out after ${TELEGRAM_DELIVERY_ATTEMPT_TIMEOUT_MS / 1000} seconds`, { retryable: true });
+        }
+        if (!raceResult.ok) {
+            throw raceResult.error;
+        }
+    }
     async wait(durationMs) {
         if (durationMs <= 0 || this.abortController.signal.aborted) {
             return;