sendChatActionFn: SendChatActionFn;

logger: TelegramSendChatActionLogger;

maxConsecutive401?: number;

/**

* Best-effort per-chat/action coalescing window. Kept opt-in so tests and

* non-typing callers can preserve exact sendChatAction semantics.

*/

minIntervalMs?: number;

now?: () => number;

};

}: CreateTelegramSendChatActionHandlerParams): TelegramSendChatActionHandler {

let consecutive401Failures = 0;

let suspended = false;

const pendingKeys = new Set<string>();

const lastAttemptAtByKey = new Map<string, number>();

const blockedUntilByKey = new Map<string, number>();

const reset = () => {

consecutive401Failures = 0;

suspended = false;

pendingKeys.clear();

lastAttemptAtByKey.clear();

blockedUntilByKey.clear();

};

const coalesceKey = (chatId: number | string, action: ChatAction) =>

// The Telegram API throttler keys group traffic by chat_id, not thread ID.

// Coalescing at the same level keeps topic typing cues from filling the

// shared outbound lane ahead of real replies.

`${String(chatId)}:${action}`;

const sendChatAction = async (

chatId: number | string,

action: ChatAction,

return;

}

const shouldCoalesce = Number.isFinite(minIntervalMs) && minIntervalMs > 0;

const key = shouldCoalesce ? coalesceKey(chatId, action) : undefined;

const key = minIntervalMs > 0 ? `${String(chatId)}:${action}` : undefined;

const attemptedAt = key ? now() : 0;

if (key) {

if (pendingKeys.has(key)) {

return;

}

const currentTime = now();

const lastAttemptAt = lastAttemptAtByKey.get(key);

if (lastAttemptAt !== undefined && currentTime - lastAttemptAt < minIntervalMs) {

const blockedUntil = blockedUntilByKey.get(key);

if (blockedUntil !== undefined && attemptedAt < blockedUntil) {

return;

}

pendingKeys.add(key);

lastAttemptAtByKey.set(key, currentTime);

blockedUntilByKey.set(key, Number.POSITIVE_INFINITY);

}

if (consecutive401Failures > 0) {

throw error;

} finally {

if (key) {

pendingKeys.delete(key);

blockedUntilByKey.set(key, attemptedAt + minIntervalMs);

}

}

};