У меня есть проблема. В телеграмм есть ограничение по объёму отправки текста. Функция для блта уже написана, её можешь увидеть ниже, её менять не нужно.
Проблема заключается в том, что когда пользователь отправляет слишком большой запрос, телеграмм разделяет текст на несколько сообщений.
Можешь сделать так, чтобы бот понимал это разделение. У меня есть идея как это можно сделать. 
Нужно создать функцию которая в течении примерно 2 секунд, будет ожидать новых сообщений пользователя. 
И если в течении этих двух секунд, пользователь напишет сообщение, то таймер сбрасывается и начинается сначала, а запрос добавляется в user_message или подобную переменную.
Если в течении 2-х секунд пользователь не отправляет сообщение, то бот принимает запрос и выполняет с ним уже действие.

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    user_id = update.effective_user.id
    
    # Проверка, разрешен ли доступ пользователю
    if user_id not in ALLOWED_USER_IDS:
        await update.message.reply_text("Извините, у вас нет доступа к этому боту.")
        return

    user_message = update.message.text

    # Получение истории чата пользователя или инициализация новой
    history = chat_histories.get(user_id, [])

    try:
        # Вызов API /predict
        result = client.predict(
            inputs=user_message,
            top_p=1,
            temperature=1,
            chat_counter=len(history),
            chatbot=history,
            api_name="/predict"
        )

        # Разбор результата
        chatbot_output, chat_counter, status_code, reset_text = result

        # Извлечение последнего ответа бота
        if chatbot_output and len(chatbot_output) > 0:
            last_message = chatbot_output[-1]
            if isinstance(last_message, list) and len(last_message) == 2:
                bot_reply = last_message[1]
            else:
                bot_reply = "Произошла непредвиденная ошибка."
        else:
            bot_reply = "Произошла непредвиденная ошибка."

        # Обновление истории чата
        history.append((user_message, bot_reply))
        chat_histories[user_id] = history

        # Отправка ответа пользователю
        def tokenize(message):
            tokens = []
            pos = 0
            length = len(message)
            while pos < length:
                if message[pos] == '<':
                    # Это тег
                    end_tag_pos = message.find('>', pos)
                    if end_tag_pos == -1:
                        # Неполный тег, считаем остальное текстом
                        tokens.append(('text', message[pos:]))
                        break
                    else:
                        token_content = message[pos+1:end_tag_pos]
                        # Проверяем, является ли это закрывающим тегом
                        if token_content.startswith('/'):
                            tag_name = token_content[1:].split()[0]
                            tokens.append(('end_tag', tag_name, '<'+token_content+'>'))
                        else:
                            # Тег может содержать атрибуты
                            tag_name = token_content.split()[0]
                            tokens.append(('start_tag', tag_name, '<'+token_content+'>'))
                        pos = end_tag_pos + 1
                else:
                    # Это текст
                    next_tag_pos = message.find('<', pos)
                    if next_tag_pos == -1:
                        # Больше нет тегов
                        tokens.append(('text', message[pos:]))
                        break
                    else:
                        tokens.append(('text', message[pos:next_tag_pos]))
                        pos = next_tag_pos
            return tokens

        def generate_closing_tags(open_tags):
            closing_tags = ''
            for start_tag in reversed(open_tags):
                # Получаем имя тега из стартового тега
                tag_content = start_tag[1:-1].strip()
                if ' ' in tag_content:
                    tag_name = tag_content.split(' ',1)[0]
                else:
                    tag_name = tag_content
                closing_tags += '</{}>'.format(tag_name)
            return closing_tags

        async def send_large_message(message, update):
            MAX_MESSAGE_LENGTH = 4000

            tokens = tokenize(message)
            open_tags = []
            current_part = ''
            current_length = 0
            parts = []

            for token in tokens:
                if token[0] == 'start_tag':
                    tag_name = token[1]
                    tag_string = token[2]
                    token_length = len(tag_string)
                    if current_length + token_length > MAX_MESSAGE_LENGTH:
                        # Закрываем теги и начинаем новую часть
                        closing_tags = generate_closing_tags(open_tags)
                        current_part += closing_tags
                        parts.append(current_part)
                        current_part = ''
                        current_length = 0
                        # Открываем теги снова
                        opening_tags = ''.join(open_tags)
                        current_part += opening_tags
                        current_length += len(opening_tags)
                    current_part += tag_string
                    current_length += token_length
                    open_tags.append(tag_string)
                elif token[0] == 'end_tag':
                    tag_name = token[1]
                    tag_string = token[2]
                    token_length = len(tag_string)
                    if current_length + token_length > MAX_MESSAGE_LENGTH:
                        # Закрываем теги и начинаем новую часть
                        closing_tags = generate_closing_tags(open_tags)
                        current_part += closing_tags
                        parts.append(current_part)
                        current_part = ''
                        current_length = 0
                        # Открываем теги снова
                        opening_tags = ''.join(open_tags)
                        current_part += opening_tags
                        current_length += len(opening_tags)
                    current_part += tag_string
                    current_length += token_length
                    if open_tags:
                        open_tags.pop()
                elif token[0] == 'text':
                    text_content = token[1]
                    text_length = len(text_content)
                    pos = 0
                    while pos < text_length:
                        remaining_space = MAX_MESSAGE_LENGTH - current_length
                        if remaining_space <= 0:
                            # Закрываем теги и начинаем новую часть
                            closing_tags = generate_closing_tags(open_tags)
                            current_part += closing_tags
                            parts.append(current_part)
                            current_part = ''
                            current_length = 0
                            # Открываем теги снова
                            opening_tags = ''.join(open_tags)
                            current_part += opening_tags
                            current_length += len(opening_tags)
                            remaining_space = MAX_MESSAGE_LENGTH - current_length
                        take_length = min(remaining_space, text_length - pos)
                        current_part += text_content[pos:pos+take_length]
                        current_length += take_length
                        pos += take_length
                else:
                    pass

            # Закрываем оставшиеся открытые теги и добавляем последнюю часть
            if open_tags:
                closing_tags = generate_closing_tags(open_tags)
                current_part += closing_tags
            if current_part:
                parts.append(current_part)

            # Отправляем части сообщения
            for part in parts:
                await update.message.reply_text(part, parse_mode='HTML')
                
        send_bot_reply = markdown_to_telegram_html(bot_reply)
        print(send_bot_reply)
        await send_large_message(send_bot_reply, update)

    except Exception as e:
        logger.error(f"Ошибка при обработке сообщения: {e}", exc_info=True)
        await update.message.reply_text("Извините, произошла ошибка при обработке вашего запроса.", parse_mode='HTML')