refactor(bot): extract connect flow and resolve code review issues

- Extract connect flow from pyrogram_handlers.py to connect_handler.py
- Transcribe all voice messages within a chat's history
- Fix auto-reply skip bug by checking _bot_draft_echoes in _is_user_typing
- Fix operator precedence bug for awaiting_prompt_input
- Add serialize_user_updates deadlock warning in bot_handlers.py
- Refactor and deduplicate prompt saving logic into _handle_prompt_save
- Change weak bot: object to bot: Bot typing in connect_handler.py
- Add missing client: Client type hint to _poll_qr_login
- Move clear_pending_input to connect_handler.py to break circular dependency
- Update settings_handler.py, styles_handler.py imports
- Delete bot sensitive messages properly in system_messages.py and connect_handler.py
- Add execution rule against combining commands to CONTRIBUTING.md
- Update tests/ to reflect recent architectural changes

Author: oponfil

CONTRIBUTING.md

@@ -103,6 +103,10 @@ feat(bot): add /start command with greeting message
 - Update README with /start usage
 ```
 
+### Execution Rule
+❌ It is strictly prohibited to combine commands (e.g. using `;` or `&&`).
+✅ Every command must be executed strictly one by one.
+
 ### PowerShell Workflow
 ```powershell
 # Write commit message to a file

README.md

@@ -15,7 +15,7 @@ Auto-replies work in private chats only. Draft instructions work everywhere.
 ## Security
 
 - By default, the bot **only writes drafts** and never sends messages on your behalf. Auto-sending is only possible when the auto-reply timer is explicitly enabled in `/settings`.
-- **Messages are not stored.** The bot doesn't save conversations — chat history is fetched via Telegram API on each event and is never persisted.
+- **Messages are not stored.** The bot doesn't save conversations — chat history is fetched via Telegram API on each event and is never persisted. The context is limited to the last 40 messages or 16,000 characters (whichever comes first); older messages are dropped.
 - **Saved Messages** (self-chat) and **Telegram service notifications** are fully ignored — the bot doesn't read, draft, or process messages in them. Additional chats can be excluded via `IGNORED_CHAT_IDS` in `config.py`.
 - Telegram sessions are encrypted with `Fernet` (`SESSION_ENCRYPTION_KEY`) before being stored in the database.
 
@@ -120,7 +120,7 @@ You can combine: `😈 tell her I miss her` — switches the style to Seducer an
 
 ### Voice Messages and Stickers
 
-When a voice message is received, the bot automatically transcribes it via Telegram Premium `TranscribeAudio` and generates a draft reply based on the text. Requires Telegram Premium on the connected account (or trial attempts for free users).
+All voice messages in the chat history — from both sides (yours and the contact's) — are automatically transcribed via Telegram Premium `TranscribeAudio` and included in the AI context as text. Multiple voice messages are transcribed in parallel. If transcription fails (e.g. no Premium), the message is included as `[voice message]` so the AI still knows a voice was sent. Requires Telegram Premium on the connected account (or trial attempts for free users).
 
 Stickers are processed by emoji — the bot sees the sticker's emoji in the conversation context and generates an appropriate reply.
 

bot.py

@@ -25,12 +25,16 @@
 from clients import pyrogram_client  # noqa: E402
 from handlers.bot_handlers import on_start, on_start_connect_callback, on_text  # noqa: E402
 from handlers.pyrogram_handlers import (  # noqa: E402
-    on_disconnect, on_connect, on_status, handle_connect_text,
-    on_connect_qr_callback, on_confirm_phone_callback, on_cancel_phone_callback, on_connect_cancel_callback,
+    on_disconnect, on_status,
     on_disconnect_confirm_callback, on_disconnect_cancel_callback,
     on_pyrogram_message, on_pyrogram_draft,
     poll_missed_messages,
 )
+from handlers.connect_handler import (  # noqa: E402
+    on_connect, handle_connect_text,
+    on_connect_qr_callback, on_confirm_phone_callback, on_cancel_phone_callback, on_connect_cancel_callback,
+)
+
 from handlers.settings_handler import on_settings, on_settings_callback  # noqa: E402
 from handlers.styles_handler import (  # noqa: E402
     on_auto_reply_callback, on_chat_prompt_callback, on_chat_prompt_cancel_callback,

clients/pyrogram_client.py

@@ -8,7 +8,7 @@
 import pyrogram
 from pyrogram.handlers import MessageHandler, RawUpdateHandler
 
-from config import PYROGRAM_API_ID, PYROGRAM_API_HASH, MAX_CONTEXT_MESSAGES, DEBUG_PRINT, VOICE_TRANSCRIPTION_TIMEOUT, POLL_MISSED_DIALOGS_LIMIT, STICKER_FALLBACK_EMOJI
+from config import PYROGRAM_API_ID, PYROGRAM_API_HASH, MAX_CONTEXT_MESSAGES, MAX_CONTEXT_CHARS, DEBUG_PRINT, VOICE_TRANSCRIPTION_TIMEOUT, POLL_MISSED_DIALOGS_LIMIT, STICKER_FALLBACK_EMOJI
 from utils.utils import get_timestamp
 
 
@@ -204,6 +204,9 @@ def is_active(user_id: int) -> bool:
 async def read_chat_history(user_id: int, chat_id: int, limit: int = MAX_CONTEXT_MESSAGES) -> list[dict]:
     """Читает последние сообщения из чата пользователя.
 
+    Голосовые сообщения транскрибируются параллельно через transcribe_voice().
+    Если транскрипция не удалась — подставляется '[voice message]'.
+
     Args:
         user_id: Telegram user ID
         chat_id: ID чата для чтения
@@ -217,13 +220,20 @@ async def read_chat_history(user_id: int, chat_id: int, limit: int = MAX_CONTEXT
         return []
 
     messages = []
+    # Индексы сообщений с голосовыми, для которых нужна транскрипция
+    voice_indices: list[int] = []
+    voice_msg_ids: list[int] = []
+
     try:
         async for msg in client.get_chat_history(chat_id, limit=limit):
             text = msg.text
             # Стикер → эмодзи как текстовое представление
             if not text and msg.sticker:
                 text = msg.sticker.emoji or STICKER_FALLBACK_EMOJI
-            if not text:
+            # Голосовое сообщение → отложим транскрипцию
+            if not text and msg.voice:
+                text = None  # placeholder, заполним после транскрипции
+            if not text and not msg.voice:
                 continue
 
             role = "user" if msg.from_user and msg.from_user.id == user_id else "other"
@@ -234,6 +244,8 @@ async def read_chat_history(user_id: int, chat_id: int, limit: int = MAX_CONTEXT
             date = msg.date
             if isinstance(date, datetime):
                 date = date.astimezone(timezone.utc)
+
+            idx = len(messages)
             messages.append({
                 "role": role,
                 "text": text,
@@ -243,9 +255,34 @@ async def read_chat_history(user_id: int, chat_id: int, limit: int = MAX_CONTEXT
                 "username": sender.username if sender else None,
             })
 
+            if msg.voice and text is None:
+                voice_indices.append(idx)
+                voice_msg_ids.append(msg.id)
+
+        # Транскрибируем все голосовые параллельно
+        if voice_indices:
+            transcriptions = await asyncio.gather(
+                *(transcribe_voice(user_id, chat_id, mid) for mid in voice_msg_ids),
+            )
+            for idx, transcription in zip(voice_indices, transcriptions):
+                messages[idx]["text"] = transcription or "[voice message]"
+
+            if DEBUG_PRINT:
+                ok_count = sum(1 for t in transcriptions if t)
+                print(
+                    f"{get_timestamp()} [PYROGRAM] Transcribed {ok_count}/{len(voice_indices)} "
+                    f"voice messages in chat {chat_id}"
+                )
+
         # Переворачиваем — от старых к новым
         messages.reverse()
 
+        # Обрезаем по суммарной длине текста (убираем старые сообщения)
+        total_chars = sum(len(m["text"] or "") for m in messages)
+        while messages and total_chars > MAX_CONTEXT_CHARS:
+            removed = messages.pop(0)
+            total_chars -= len(removed["text"] or "")
+
         if DEBUG_PRINT:
             print(f"{get_timestamp()} [PYROGRAM] Read {len(messages)} messages from chat {chat_id}")
 
@@ -526,10 +563,18 @@ async def send_message(user_id: int, chat_id: int, text: str) -> bool:
         print(f"{get_timestamp()} [PYROGRAM] ERROR sending message in chat {chat_id}: {e}")
         return False
 
+# Кэш транскрипций: {user_id: {(chat_id, msg_id): text_or_None}}
+# Предотвращает повторные API-вызовы для одних и тех же голосовых.
+_transcription_cache: dict[int, dict[tuple[int, int], str | None]] = defaultdict(dict)
+_TRANSCRIPTION_CACHE_MAX = 200  # Макс. записей на пользователя
+
 
 async def transcribe_voice(user_id: int, chat_id: int, msg_id: int) -> str | None:
     """Транскрибирует голосовое сообщение через Telegram Premium TranscribeAudio.
 
+    Результат кэшируется — повторные вызовы для того же сообщения
+    не обращаются к Telegram API.
+
     Args:
         user_id: Telegram user ID
         chat_id: ID чата
@@ -538,10 +583,18 @@ async def transcribe_voice(user_id: int, chat_id: int, msg_id: int) -> str | Non
     Returns:
         Текст транскрипции или None при ошибке
     """
+    # Проверяем кэш
+    cache_key = (chat_id, msg_id)
+    user_cache = _transcription_cache[user_id]
+    if cache_key in user_cache:
+        return user_cache[cache_key]
+
     client = _active_clients.get(user_id)
     if not client:
         return None
 
+    result_text: str | None = None
+
     try:
         peer = await client.resolve_peer(chat_id)
         result = await client.invoke(
@@ -555,40 +608,46 @@ async def transcribe_voice(user_id: int, chat_id: int, msg_id: int) -> str | Non
         if not result.pending:
             if DEBUG_PRINT:
                 print(f"{get_timestamp()} [PYROGRAM] Transcribed voice in chat {chat_id}: {len(result.text)} chars")
-            return result.text or None
-
-        # Ждём UpdateTranscribedAudio через polling
-        final_text = result.text or ""
-
-        deadline = asyncio.get_event_loop().time() + VOICE_TRANSCRIPTION_TIMEOUT
-        while asyncio.get_event_loop().time() < deadline:
-            await asyncio.sleep(1)
-            # Повторяем запрос — Telegram вернёт обновлённый результат
-            try:
-                result = await client.invoke(
-                    raw.functions.messages.TranscribeAudio(
-                        peer=peer,
-                        msg_id=msg_id,
+            result_text = result.text or None
+        else:
+            # Ждём UpdateTranscribedAudio через polling
+            final_text = result.text or ""
+
+            deadline = asyncio.get_event_loop().time() + VOICE_TRANSCRIPTION_TIMEOUT
+            while asyncio.get_event_loop().time() < deadline:
+                await asyncio.sleep(1)
+                # Повторяем запрос — Telegram вернёт обновлённый результат
+                try:
+                    result = await client.invoke(
+                        raw.functions.messages.TranscribeAudio(
+                            peer=peer,
+                            msg_id=msg_id,
+                        )
                     )
-                )
-                if not result.pending:
-                    final_text = result.text or ""
+                    if not result.pending:
+                        final_text = result.text or ""
+                        break
+                    final_text = result.text or final_text
+                except Exception:
                     break
-                final_text = result.text or final_text
-            except Exception:
-                break
 
-        if final_text:
-            if DEBUG_PRINT:
-                print(f"{get_timestamp()} [PYROGRAM] Transcribed voice in chat {chat_id}: {len(final_text)} chars")
-            return final_text
-
-        return None
+            if final_text:
+                if DEBUG_PRINT:
+                    print(f"{get_timestamp()} [PYROGRAM] Transcribed voice in chat {chat_id}: {len(final_text)} chars")
+                result_text = final_text
 
     except Exception as e:
         error_str = str(e)
         if "PREMIUM_ACCOUNT_REQUIRED" in error_str:
             print(f"{get_timestamp()} [PYROGRAM] WARNING: voice transcription requires Premium in chat {chat_id}")
         else:
             print(f"{get_timestamp()} [PYROGRAM] ERROR transcribing voice in chat {chat_id}: {e}")
-        return None
+
+    # Сохраняем в кэш (включая None для ошибок)
+    user_cache[cache_key] = result_text
+    if len(user_cache) > _TRANSCRIPTION_CACHE_MAX:
+        # Удаляем самую старую запись
+        oldest = next(iter(user_cache))
+        del user_cache[oldest]
+
+    return result_text

config.py

@@ -74,6 +74,7 @@
 
 # ====== КОНТЕКСТ ======
 MAX_CONTEXT_MESSAGES = 40  # Макс. кол-во сообщений из чата для контекста
+MAX_CONTEXT_CHARS = 16000  # Макс. суммарная длина текста в истории (символы)
 
 # ====== QR LOGIN ======
 QR_LOGIN_TIMEOUT_SECONDS = 120  # Таймаут ожидания сканирования QR-кода (секунды)

handlers/bot_handlers.py

@@ -16,7 +16,7 @@
 from utils.telegram_rating import extract_rating_from_chat
 from system_messages import get_system_message, SYSTEM_MESSAGES
 from clients import pyrogram_client
-from handlers.pyrogram_handlers import on_connect
+from handlers.connect_handler import on_connect
 
 
 @serialize_user_updates
@@ -63,7 +63,13 @@ async def on_start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 
 
 async def on_start_connect_callback(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
-    """Callback кнопки 'Connect' из приветственного сообщения."""
+    """Callback кнопки 'Connect' из приветственного сообщения.
+    
+    ВНИМАНИЕ: Без декоратора @serialize_user_updates!
+    Функция только убирает кнопку и делегирует вызов в on_connect, который
+    уже удерживает этот lock. Так как asyncio.Lock не reentrant, добавление
+    декоратора сюда приведёт к вечной блокировке (deadlock) для пользователя.
+    """
     query = update.callback_query
     await query.answer()
 
@@ -87,14 +93,45 @@ async def on_text(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     message_text = m.text or ""
     awaiting_prompt_input = (
         context.user_data.get("awaiting_prompt")
-        or context.user_data.get("awaiting_chat_prompt") is not None
+        or (context.user_data.get("awaiting_chat_prompt") is not None)
     )
     if not message_text.strip() and not awaiting_prompt_input:
         return
 
     await _process_text(update, context, u, m, message_text)
 
 
+async def _handle_prompt_save(
+    u: User, m: Message, context: ContextTypes.DEFAULT_TYPE, prompt_text: str, max_length: int,
+    save_coro, msg_saved: str, msg_trunc: str, is_clearing: bool = False, msg_cleared: str | None = None
+) -> None:
+    """Вспомогательная функция для сохранения промпта и отправки уведомления."""
+    was_truncated = len(prompt_text) > max_length
+    if was_truncated:
+        prompt_text = prompt_text[:max_length]
+
+    saved = await save_coro
+    if not saved:
+        error_msg = await get_system_message(u.language_code, "error")
+        await m.reply_text(error_msg)
+        return
+
+    context.user_data.pop("awaiting_chat_prompt", None)
+    context.user_data.pop("awaiting_prompt", None)
+
+    if is_clearing and msg_cleared:
+        msg_key = msg_cleared
+    else:
+        msg_key = msg_trunc if was_truncated else msg_saved
+
+    msg = await get_system_message(u.language_code, msg_key)
+    if was_truncated:
+        msg = msg.format(max_length=max_length)
+    await m.reply_text(msg)
+    if DEBUG_PRINT:
+        print(f"{get_timestamp()} [BOT] Prompt saved for user {u.id}: {len(prompt_text)} chars")
+
+
 async def _process_text(
     update: Update, context: ContextTypes.DEFAULT_TYPE,
     u: User, m: Message, message_text: str,
@@ -105,56 +142,25 @@ async def _process_text(
     if chat_prompt_chat_id is not None:
         prompt_text = message_text.strip()
         is_clearing_prompt = prompt_text == ""
-        was_truncated = len(prompt_text) > CHAT_PROMPT_MAX_LENGTH
-        if was_truncated:
-            prompt_text = prompt_text[:CHAT_PROMPT_MAX_LENGTH]
-
-        saved = await update_chat_prompt(
-            u.id,
-            chat_prompt_chat_id,
-            None if is_clearing_prompt else prompt_text,
+        
+        save_coro = update_chat_prompt(
+            u.id, chat_prompt_chat_id, None if is_clearing_prompt else prompt_text[:CHAT_PROMPT_MAX_LENGTH]
+        )
+        await _handle_prompt_save(
+            u, m, context, prompt_text, CHAT_PROMPT_MAX_LENGTH, save_coro,
+            msg_saved="settings_prompt_saved", msg_trunc="settings_prompt_truncated",
+            is_clearing=is_clearing_prompt, msg_cleared="settings_prompt_cleared"
         )
-        if not saved:
-            error_msg = await get_system_message(u.language_code, "error")
-            await m.reply_text(error_msg)
-            return
-
-        context.user_data.pop("awaiting_chat_prompt", None)
-        context.user_data.pop("awaiting_prompt", None)
-        if is_clearing_prompt:
-            message_key = "settings_prompt_cleared"
-        else:
-            message_key = "settings_prompt_truncated" if was_truncated else "settings_prompt_saved"
-        msg = await get_system_message(u.language_code, message_key)
-        if was_truncated:
-            msg = msg.format(max_length=CHAT_PROMPT_MAX_LENGTH)
-        await m.reply_text(msg)
-        if DEBUG_PRINT:
-            print(f"{get_timestamp()} [BOT] Chat prompt saved for user {u.id}, chat {chat_prompt_chat_id}: {len(prompt_text)} chars")
         return
 
     # Проверяем: пользователь вводит кастомный промпт?
     if context.user_data.get("awaiting_prompt"):
         prompt_text = message_text.strip()
-        was_truncated = len(prompt_text) > USER_PROMPT_MAX_LENGTH
-        if was_truncated:
-            prompt_text = prompt_text[:USER_PROMPT_MAX_LENGTH]
-
-        saved = await update_user_settings(u.id, {"custom_prompt": prompt_text})
-        if not saved:
-            error_msg = await get_system_message(u.language_code, "error")
-            await m.reply_text(error_msg)
-            return
-
-        context.user_data.pop("awaiting_prompt", None)
-        context.user_data.pop("awaiting_chat_prompt", None)
-        message_key = "settings_prompt_truncated" if was_truncated else "settings_prompt_saved"
-        msg = await get_system_message(u.language_code, message_key)
-        if was_truncated:
-            msg = msg.format(max_length=USER_PROMPT_MAX_LENGTH)
-        await m.reply_text(msg)
-        if DEBUG_PRINT:
-            print(f"{get_timestamp()} [BOT] Custom prompt saved for user {u.id}: {len(prompt_text)} chars")
+        save_coro = update_user_settings(u.id, {"custom_prompt": prompt_text[:USER_PROMPT_MAX_LENGTH]})
+        await _handle_prompt_save(
+            u, m, context, prompt_text, USER_PROMPT_MAX_LENGTH, save_coro,
+            msg_saved="settings_prompt_saved", msg_trunc="settings_prompt_truncated",
+        )
         return
 
     try: