smart-bot-factory 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

smart_bot_factory/admin/admin_logic.py

@@ -29,6 +29,11 @@ async def cancel_handler(message: Message, state: FSMContext):
     # Получаем текущий state
     current_state = await state.get_state()
     
+    # Очищаем временные файлы если это создание события
+    if current_state and current_state.startswith('AdminStates:create_event'):
+        from .admin_events import cleanup_temp_files
+        await cleanup_temp_files(state)
+    
     # Очищаем state
     await state.clear()
     

smart_bot_factory/core/bot_utils.py

@@ -1,7 +1,6 @@
 import asyncio
 import json
 import logging
-import re
 from datetime import datetime
 from aiogram import Router
 from aiogram.filters import Command
@@ -170,8 +169,13 @@ def parse_ai_response_method2(ai_response: str) -> tuple[str, dict]:
         logger.warning(f"Ошибка резервного метода: {e}")
         return ai_response, {}
 
-async def process_events(session_id: str, events: list, user_id: int):
-    """Обрабатывает события из ответа ИИ"""
+async def process_events(session_id: str, events: list, user_id: int) -> bool:
+    """
+    Обрабатывает события из ответа ИИ
+    
+    Returns:
+        bool: True если нужно отправить сообщение от ИИ, False если не нужно
+    """
     
     # Проверяем кастомный процессор
     custom_processor = get_global_var('custom_event_processor')
@@ -180,11 +184,14 @@ async def process_events(session_id: str, events: list, user_id: int):
         # Используем кастомную функцию обработки событий
         logger.info(f"🔄 Используется кастомная обработка событий: {custom_processor.__name__}")
         await custom_processor(session_id, events, user_id)
-        return
+        return True  # По умолчанию отправляем сообщение
     
     # Стандартная обработка
     supabase_client = get_global_var('supabase_client')
     
+    # Флаг для отслеживания, нужно ли отправлять сообщение от ИИ
+    should_send_ai_response = True
+    
     for event in events:
         try:
             event_type = event.get('тип', '')
@@ -200,7 +207,6 @@ async def process_events(session_id: str, events: list, user_id: int):
             
             # Определяем категорию события и сохраняем в БД
             event_id = None
-            should_execute_immediately = False
             should_notify = False
             
             try:
@@ -228,8 +234,14 @@ async def process_events(session_id: str, events: list, user_id: int):
                     
                     event_handler_info = event_handlers.get(event_type, {})
                     once_only = event_handler_info.get('once_only', True)
+                    send_ai_response_flag = event_handler_info.get('send_ai_response', True)
                     
-                    logger.info(f"   🔍 Обработчик '{event_type}': once_only={once_only}")
+                    logger.info(f"   🔍 Обработчик '{event_type}': once_only={once_only}, send_ai_response={send_ai_response_flag}")
+                    
+                    # Проверяем флаг send_ai_response ИЗ ДЕКОРАТОРА
+                    if not send_ai_response_flag:
+                        should_send_ai_response = False
+                        logger.warning(f"   🔇🔇🔇 ОБРАБОТЧИК '{event_type}' ЗАПРЕТИЛ ОТПРАВКУ СООБЩЕНИЯ ОТ ИИ (send_ai_response=False) 🔇🔇🔇")
                     
                     # Если once_only=True - проверяем в БД наличие выполненных событий
                     if once_only:
@@ -256,7 +268,7 @@ async def process_events(session_id: str, events: list, user_id: int):
                     logger.info(f"   🎯 Немедленно выполняем user_event: '{event_type}'")
                     
                     try:
-                        # Выполняем СНАЧАЛА
+                        # Выполняем событие
                         result = await execute_event_handler(event_type, user_id, event_info)
                         
                         # Сохраняем в БД УЖЕ со статусом completed (избегаем дублирования)
@@ -275,7 +287,6 @@ async def process_events(session_id: str, events: list, user_id: int):
                         event_id = response.data[0]['id']
                         
                         should_notify = event_handler_info.get('notify', False)
-                        should_execute_immediately = True
                         
                         logger.info(f"   ✅ Событие {event_id} выполнено и сохранено как completed")
                         
@@ -298,8 +309,18 @@ async def process_events(session_id: str, events: list, user_id: int):
                 # Если не user_event, пробуем как запланированную задачу
                 elif event_type in scheduled_tasks:
                     try:
+                        # Достаем метаданные задачи
+                        task_info = scheduled_tasks.get(event_type, {})
+                        send_ai_response_flag = task_info.get('send_ai_response', True)
+                        
+                        logger.info(f"   ⏰ Планируем scheduled_task: '{event_type}', send_ai_response={send_ai_response_flag}")
+                        
+                        # Проверяем флаг send_ai_response ИЗ ДЕКОРАТОРА
+                        if not send_ai_response_flag:
+                            should_send_ai_response = False
+                            logger.warning(f"   🔇🔇🔇 ЗАДАЧА '{event_type}' ЗАПРЕТИЛА ОТПРАВКУ СООБЩЕНИЯ ОТ ИИ (send_ai_response=False) 🔇🔇🔇")
+                        
                         # Используем новую логику - время берется из декоратора
-                        logger.info(f"   ⏰ Планируем scheduled_task: '{event_type}' с данными: '{event_info}'")
                         result = await execute_scheduled_task_from_event(user_id, event_type, event_info, session_id)
                         event_id = result.get('event_id', 'unknown')
                         should_notify = result.get('notify', False)
@@ -354,6 +375,10 @@ async def process_events(session_id: str, events: list, user_id: int):
         except Exception as e:
             logger.error(f"❌ Ошибка обработки события {event}: {e}")
             logger.exception("Стек ошибки:")
+    
+    # Возвращаем флаг, нужно ли отправлять сообщение от ИИ
+    logger.warning(f"🔊🔊🔊 ИТОГОВЫЙ ФЛАГ send_ai_response: {should_send_ai_response} 🔊🔊🔊")
+    return should_send_ai_response
 
 async def notify_admins_about_event(user_id: int, event: dict):
     """Отправляем уведомление админам о событии с явным указанием ID пользователя"""

smart_bot_factory/core/decorators.py

@@ -377,7 +377,7 @@ _global_handlers: Dict[str, Dict[str, Any]] = {}
 # Глобальный менеджер роутеров
 _router_manager = None
 
-def event_handler(event_type: str, notify: bool = False, once_only: bool = True):
+def event_handler(event_type: str, notify: bool = False, once_only: bool = True, send_ai_response: bool = True):
     """
     Декоратор для регистрации обработчика события
     
@@ -385,18 +385,19 @@ def event_handler(event_type: str, notify: bool = False, once_only: bool = True)
         event_type: Тип события (например, 'appointment_booking', 'phone_collection')
         notify: Уведомлять ли админов о выполнении события (по умолчанию False)
         once_only: Обрабатывать ли событие только один раз (по умолчанию True)
+        send_ai_response: Отправлять ли сообщение от ИИ после обработки события (по умолчанию True)
     
     Example:
-        # Обработчик только один раз (по умолчанию)
+        # Обработчик с отправкой сообщения от ИИ
         @event_handler("appointment_booking", notify=True)
         async def book_appointment(user_id: int, appointment_data: dict):
             # Логика записи на прием
             return {"status": "success", "appointment_id": "123"}
         
-        # Обработчик может выполняться многократно
-        @event_handler("phone_collection", once_only=False)
+        # Обработчик БЕЗ отправки сообщения от ИИ
+        @event_handler("phone_collection", once_only=False, send_ai_response=False)
         async def collect_phone(user_id: int, phone_data: dict):
-            # Логика сбора телефона
+            # Логика сбора телефона - ИИ не отправит сообщение
             return {"status": "phone_collected"}
     """
     def decorator(func: Callable) -> Callable:
@@ -404,7 +405,8 @@ def event_handler(event_type: str, notify: bool = False, once_only: bool = True)
             'handler': func,
             'name': func.__name__,
             'notify': notify,
-            'once_only': once_only
+            'once_only': once_only,
+            'send_ai_response': send_ai_response
         }
         
         logger.info(f"📝 Зарегистрирован обработчик события '{event_type}': {func.__name__}")
@@ -416,15 +418,17 @@ def event_handler(event_type: str, notify: bool = False, once_only: bool = True)
                 result = await func(*args, **kwargs)
                 logger.info(f"✅ Обработчик '{event_type}' выполнен успешно")
                 
-                # Автоматически добавляем флаг notify к результату
+                # Автоматически добавляем флаги notify и send_ai_response к результату
                 if isinstance(result, dict):
                     result['notify'] = notify
+                    result['send_ai_response'] = send_ai_response
                 else:
                     # Если результат не словарь, создаем словарь
                     result = {
                         'status': 'success',
                         'result': result,
-                        'notify': notify
+                        'notify': notify,
+                        'send_ai_response': send_ai_response
                     }
                 
                 return result
@@ -435,7 +439,7 @@ def event_handler(event_type: str, notify: bool = False, once_only: bool = True)
         return wrapper
     return decorator
 
-def schedule_task(task_name: str, notify: bool = False, smart_check: bool = True, once_only: bool = True, delay: Union[str, int] = None, event_type: Union[str, Callable] = None):
+def schedule_task(task_name: str, notify: bool = False, smart_check: bool = True, once_only: bool = True, delay: Union[str, int] = None, event_type: Union[str, Callable] = None, send_ai_response: bool = True):
     """
     Декоратор для регистрации задачи, которую можно запланировать на время
     
@@ -448,6 +452,7 @@ def schedule_task(task_name: str, notify: bool = False, smart_check: bool = True
         event_type: Источник времени события - ОПЦИОНАЛЬНО:
             - str: Тип события для поиска в БД (например, 'appointment_booking')
             - Callable: Функция для получения datetime (например, async def(user_id, user_data) -> datetime)
+        send_ai_response: Отправлять ли сообщение от ИИ после выполнения задачи (по умолчанию True)
     
     Example:
         # Обычная задача с фиксированным временем
@@ -509,7 +514,8 @@ def schedule_task(task_name: str, notify: bool = False, smart_check: bool = True
             'smart_check': smart_check,
             'once_only': once_only,
             'default_delay': default_delay_seconds,
-            'event_type': event_type  # Новое поле для типа события
+            'event_type': event_type,  # Новое поле для типа события
+            'send_ai_response': send_ai_response
         }
         
         if event_type:
@@ -524,15 +530,17 @@ def schedule_task(task_name: str, notify: bool = False, smart_check: bool = True
                 result = await func(*args, **kwargs)
                 logger.info(f"✅ Задача '{task_name}' выполнена успешно")
                 
-                # Автоматически добавляем флаг notify к результату
+                # Автоматически добавляем флаги notify и send_ai_response к результату
                 if isinstance(result, dict):
                     result['notify'] = notify
+                    result['send_ai_response'] = send_ai_response
                 else:
                     # Если результат не словарь, создаем словарь
                     result = {
                         'status': 'success',
                         'result': result,
-                        'notify': notify
+                        'notify': notify,
+                        'send_ai_response': send_ai_response
                     }
                 
                 return result
@@ -543,7 +551,7 @@ def schedule_task(task_name: str, notify: bool = False, smart_check: bool = True
         return wrapper
     return decorator
 
-def global_handler(handler_type: str, notify: bool = False, once_only: bool = True, delay: Union[str, int] = None, event_type: Union[str, Callable] = None):
+def global_handler(handler_type: str, notify: bool = False, once_only: bool = True, delay: Union[str, int] = None, event_type: Union[str, Callable] = None, send_ai_response: bool = True):
     """
     Декоратор для регистрации глобального обработчика (для всех пользователей)
     
@@ -555,6 +563,7 @@ def global_handler(handler_type: str, notify: bool = False, once_only: bool = Tr
         event_type: Источник времени события - ОПЦИОНАЛЬНО:
             - str: Тип события для поиска в БД
             - Callable: Функция для получения datetime (например, async def(handler_data: str) -> datetime)
+        send_ai_response: Отправлять ли сообщение от ИИ после выполнения обработчика (по умолчанию True)
     
     Example:
         # Глобальный обработчик с задержкой
@@ -610,7 +619,8 @@ def global_handler(handler_type: str, notify: bool = False, once_only: bool = Tr
             'notify': notify,
             'once_only': once_only,
             'default_delay': default_delay_seconds,
-            'event_type': event_type  # Добавляем event_type для глобальных обработчиков
+            'event_type': event_type,  # Добавляем event_type для глобальных обработчиков
+            'send_ai_response': send_ai_response
         }
         
         logger.info(f"🌍 Зарегистрирован глобальный обработчик '{handler_type}': {func.__name__}")
@@ -622,15 +632,17 @@ def global_handler(handler_type: str, notify: bool = False, once_only: bool = Tr
                 result = await func(*args, **kwargs)
                 logger.info(f"✅ Глобальный обработчик '{handler_type}' выполнен успешно")
                 
-                # Автоматически добавляем флаг notify к результату
+                # Автоматически добавляем флаги notify и send_ai_response к результату
                 if isinstance(result, dict):
                     result['notify'] = notify
+                    result['send_ai_response'] = send_ai_response
                 else:
                     # Если результат не словарь, создаем словарь
                     result = {
                         'status': 'success',
                         'result': result,
-                        'notify': notify
+                        'notify': notify,
+                        'send_ai_response': send_ai_response
                     }
                 
                 return result
@@ -1747,15 +1759,15 @@ async def process_admin_event(event: Dict):
         for file_info in files_metadata:
             try:
                 file_bytes = await supabase_client.download_event_file(
-                    event_name=event_name,
-                    file_name=file_info['name']
+                    event_id=event_id,
+                    storage_path=file_info['storage_path']
                 )
                 
                 # Сохраняем в соответствующую папку
                 if file_info['stage'] == 'with_message':
-                    file_path = temp_with_msg / file_info['name']
+                    file_path = temp_with_msg / file_info['original_name']
                 else:
-                    file_path = temp_after_msg / file_info['name']
+                    file_path = temp_after_msg / file_info['original_name']
                 
                 with open(file_path, 'wb') as f:
                     f.write(file_bytes)
@@ -1794,8 +1806,11 @@ async def process_admin_event(event: Dict):
                     media_group = []
                     first_file = True
                     
-                    for file_info in files_with_msg:
-                        file_path = temp_with_msg / file_info['name']
+                    # Сортируем файлы по порядку
+                    sorted_files = sorted(files_with_msg, key=lambda x: x.get('order', 0))
+                    
+                    for file_info in sorted_files:
+                        file_path = temp_with_msg / file_info['original_name']
                         
                         if file_info['type'] == 'photo':
                             media = InputMediaPhoto(
@@ -1824,7 +1839,7 @@ async def process_admin_event(event: Dict):
                 files_after = [f for f in files_metadata if f['stage'] == 'after_message']
                 
                 for file_info in files_after:
-                    file_path = temp_after_msg / file_info['name']
+                    file_path = temp_after_msg / file_info['original_name']
                     
                     if file_info['type'] == 'document':
                         await bot.send_document(chat_id=telegram_id, document=FSInputFile(file_path))
@@ -1848,10 +1863,10 @@ async def process_admin_event(event: Dict):
         shutil.rmtree(temp_after_msg, ignore_errors=True)
         logger.info("🗑️ Временные папки очищены")
         
-        # 4.2. Удаляем файлы из Supabase Storage
+            # 4.2. Удаляем файлы из Supabase Storage
         try:
-            await supabase_client.delete_event_files(event_name)
-            logger.info(f"🗑️ Файлы события '{event_name}' удалены из Storage")
+            await supabase_client.delete_event_files(event_id)
+            logger.info(f"🗑️ Файлы события '{event_id}' удалены из Storage")
         except Exception as e:
             logger.error(f"❌ Ошибка удаления из Storage: {e}")
         

smart_bot_factory/core/message_sender.py

@@ -143,10 +143,10 @@ async def send_message_by_ai(
                 logger.info(f"✅ Этап и качество обновлены в БД")
             
             # Обрабатываем события
-            events = ai_metadata.get('события', [])
+            events = ai_metadata.get('събития', [])
             if events:
                 logger.info(f"🔔 Обрабатываем {len(events)} событий")
-                await process_events(session_id, events, user_id)
+                should_send_response = await process_events(session_id, events, user_id)
         
         # Сохраняем ответ ассистента
         await supabase_client.add_message(
@@ -165,6 +165,15 @@ async def send_message_by_ai(
         else:
             final_response = response_text
         
+        # Проверяем, нужно ли отправлять сообщение от ИИ
+        if 'should_send_response' in locals() and not should_send_response:
+            logger.info("🔇 События запретили отправку сообщения от ИИ (message_sender), пропускаем отправку")
+            return {
+                "status": "skipped",
+                "reason": "send_ai_response=False",
+                "user_id": user_id
+            }
+        
         # Отправляем ответ пользователю напрямую через бота
         await bot.send_message(
             chat_id=user_id,

smart_bot_factory/core/router.py

@@ -26,7 +26,7 @@ class EventRouter:
         
         logger.info(f"🔄 Создан роутер: {self.name}")
     
-    def event_handler(self, event_type: str, notify: bool = False, once_only: bool = True):
+    def event_handler(self, event_type: str, notify: bool = False, once_only: bool = True, send_ai_response: bool = True):
         """
         Декоратор для регистрации обработчика события в роутере
         
@@ -34,6 +34,7 @@ class EventRouter:
             event_type: Тип события
             notify: Уведомлять ли админов
             once_only: Выполнять ли только один раз
+            send_ai_response: Отправлять ли сообщение от ИИ после обработки события (по умолчанию True)
         """
         def decorator(func: Callable) -> Callable:
             self._event_handlers[event_type] = {
@@ -41,6 +42,7 @@ class EventRouter:
                 'name': func.__name__,
                 'notify': notify,
                 'once_only': once_only,
+                'send_ai_response': send_ai_response,
                 'router': self.name
             }
             
@@ -50,14 +52,29 @@ class EventRouter:
             @wraps(func)
             async def wrapper(*args, **kwargs):
                 try:
-                    return await func(*args, **kwargs)
+                    result = await func(*args, **kwargs)
+                    
+                    # Автоматически добавляем флаги notify и send_ai_response к результату
+                    if isinstance(result, dict):
+                        result['notify'] = notify
+                        result['send_ai_response'] = send_ai_response
+                    else:
+                        # Если результат не словарь, создаем словарь
+                        result = {
+                            'status': 'success',
+                            'result': result,
+                            'notify': notify,
+                            'send_ai_response': send_ai_response
+                        }
+                    
+                    return result
                 except Exception as e:
                     logger.error(f"Ошибка выполнения обработчика '{event_type}' в роутере {self.name}: {e}")
                     raise
             return wrapper
         return decorator
     
-    def schedule_task(self, task_name: str, notify: bool = False, smart_check: bool = True, once_only: bool = True, delay: Union[str, int] = None, event_type: Union[str, Callable] = None):
+    def schedule_task(self, task_name: str, notify: bool = False, smart_check: bool = True, once_only: bool = True, delay: Union[str, int] = None, event_type: Union[str, Callable] = None, send_ai_response: bool = True):
         """
         Декоратор для регистрации запланированной задачи в роутере
         
@@ -70,6 +87,7 @@ class EventRouter:
             event_type: Источник времени события - ОПЦИОНАЛЬНО:
                 - str: Тип события для поиска в БД (например, 'appointment_booking')
                 - Callable: Функция async def(user_id, user_data) -> datetime
+            send_ai_response: Отправлять ли сообщение от ИИ после выполнения задачи (по умолчанию True)
         """
         def decorator(func: Callable) -> Callable:
             # Время ОБЯЗАТЕЛЬНО должно быть указано
@@ -98,7 +116,8 @@ class EventRouter:
                 'once_only': once_only,
                 'router': self.name,
                 'default_delay': default_delay_seconds,
-                'event_type': event_type  # Новое поле для типа события
+                'event_type': event_type,  # Новое поле для типа события
+                'send_ai_response': send_ai_response
             }
             
             if event_type:
@@ -110,14 +129,29 @@ class EventRouter:
             @wraps(func)
             async def wrapper(*args, **kwargs):
                 try:
-                    return await func(*args, **kwargs)
+                    result = await func(*args, **kwargs)
+                    
+                    # Автоматически добавляем флаги notify и send_ai_response к результату
+                    if isinstance(result, dict):
+                        result['notify'] = notify
+                        result['send_ai_response'] = send_ai_response
+                    else:
+                        # Если результат не словарь, создаем словарь
+                        result = {
+                            'status': 'success',
+                            'result': result,
+                            'notify': notify,
+                            'send_ai_response': send_ai_response
+                        }
+                    
+                    return result
                 except Exception as e:
                     logger.error(f"Ошибка выполнения задачи '{task_name}' в роутере {self.name}: {e}")
                     raise
             return wrapper
         return decorator
     
-    def global_handler(self, handler_type: str, notify: bool = False, once_only: bool = True, delay: Union[str, int] = None, event_type: Union[str, Callable] = None):
+    def global_handler(self, handler_type: str, notify: bool = False, once_only: bool = True, delay: Union[str, int] = None, event_type: Union[str, Callable] = None, send_ai_response: bool = True):
         """
         Декоратор для регистрации глобального обработчика в роутере
         
@@ -126,6 +160,7 @@ class EventRouter:
             notify: Уведомлять ли админов
             once_only: Выполнять ли только один раз
             delay: Время задержки в удобном формате (например, "1h 30m", "45m", 3600) - ОБЯЗАТЕЛЬНО
+            send_ai_response: Отправлять ли сообщение от ИИ после выполнения обработчика (по умолчанию True)
         """
         def decorator(func: Callable) -> Callable:
             # Время ОБЯЗАТЕЛЬНО должно быть указано
@@ -150,7 +185,8 @@ class EventRouter:
                 'once_only': once_only,
                 'router': self.name,
                 'default_delay': default_delay_seconds,
-                'event_type': event_type  # Добавляем event_type для глобальных обработчиков
+                'event_type': event_type,  # Добавляем event_type для глобальных обработчиков
+                'send_ai_response': send_ai_response
             }
             
             logger.info(f"🌍 Роутер {self.name}: зарегистрирован глобальный обработчик '{handler_type}': {func.__name__}")
@@ -159,7 +195,22 @@ class EventRouter:
             @wraps(func)
             async def wrapper(*args, **kwargs):
                 try:
-                    return await func(*args, **kwargs)
+                    result = await func(*args, **kwargs)
+                    
+                    # Автоматически добавляем флаги notify и send_ai_response к результату
+                    if isinstance(result, dict):
+                        result['notify'] = notify
+                        result['send_ai_response'] = send_ai_response
+                    else:
+                        # Если результат не словарь, создаем словарь
+                        result = {
+                            'status': 'success',
+                            'result': result,
+                            'notify': notify,
+                            'send_ai_response': send_ai_response
+                        }
+                    
+                    return result
                 except Exception as e:
                     logger.error(f"Ошибка выполнения глобального обработчика '{handler_type}' в роутере {self.name}: {e}")
                     raise

smart_bot_factory/handlers/handlers.py

@@ -222,12 +222,18 @@ async def voice_handler(message: Message, state: FSMContext):
             # Распознаем через Whisper
             recognized_text = await openai_client.transcribe_audio(str(file_path))
             
-            # Удаляем временный файл
+            # Удаляем временный файл и папку
             try:
                 os.remove(file_path)
                 logger.info(f"🗑️ Временный файл удален: {file_path}")
+                
+                # Проверяем, пуста ли папка
+                if not any(temp_dir.iterdir()):
+                    temp_dir.rmdir()
+                    logger.info(f"🗑️ Временная папка удалена: {temp_dir}")
+                
             except Exception as e:
-                logger.warning(f"⚠️ Не удалось удалить временный файл: {e}")
+                logger.warning(f"⚠️ Не удалось удалить временные файлы: {e}")
             
             if not recognized_text:
                 await processing_msg.edit_text("❌ Не удалось распознать голос. Попробуйте еще раз.")
@@ -936,8 +942,8 @@ async def process_user_message(message: Message, state: FSMContext, session_id:
                     logger.info(f"   {idx}. {event_emoji} {event_type}: {event_info}")
 
                 # Обрабатываем события в системе
-                await process_events(session_id, events, message.from_user.id)
-                logger.info("   ✅ События обработаны")
+                should_send_response = await process_events(session_id, events, message.from_user.id)
+                logger.warning(f"   ✅ События обработаны, should_send_response = {should_send_response}")
         
         # Обрабатываем файлы и каталоги
         files_list = ai_metadata.get('файлы', [])
@@ -1001,6 +1007,14 @@ async def process_user_message(message: Message, state: FSMContext, session_id:
 
         logger.info(f"📱 Отправляем пользователю: {len(final_response)} символов")
         
+        # ============ ПРОВЕРКА: НУЖНО ЛИ ОТПРАВЛЯТЬ СООБЩЕНИЕ ОТ ИИ ============
+        # Проверяем флаг из событий (если события запретили отправку)
+        logger.warning(f"🔍 Проверка should_send_response: exists={('should_send_response' in locals())}, value={locals().get('should_send_response', 'NOT_SET')}")
+        
+        if 'should_send_response' in locals() and not should_send_response:
+            logger.warning("🔇🔇🔇 СОБЫТИЯ ЗАПРЕТИЛИ ОТПРАВКУ СООБЩЕНИЯ ОТ ИИ, ПРОПУСКАЕМ ОТПРАВКУ 🔇🔇🔇")
+            return
+        
         # ============ ХУК 5: ФИЛЬТРЫ ОТПРАВКИ ============
         send_filters = message_hooks.get('send_filters', [])
         for filter_func in send_filters:
@@ -1127,9 +1141,9 @@ async def process_voice_message(message: Message, state: FSMContext, session_id:
                     await supabase_client.update_session_stage(session_id, stage, quality)
                 
                 # Обрабатываем события
-                events = ai_metadata.get('события', [])
+                events = ai_metadata.get('події', [])
                 if events:
-                    await process_events(session_id, events, message.from_user.id)
+                    should_send_response = await process_events(session_id, events, message.from_user.id)
 
         # Сохраняем ответ ассистента
         await supabase_client.add_message(
@@ -1152,6 +1166,11 @@ async def process_voice_message(message: Message, state: FSMContext, session_id:
         files_list = ai_metadata.get('файлы', [])
         directories_list = ai_metadata.get('каталоги', [])
         
+        # Проверяем, нужно ли отправлять сообщение от ИИ
+        if 'should_send_response' in locals() and not should_send_response:
+            logger.info("🔇 События запретили отправку сообщения от ИИ (voice), пропускаем отправку")
+            return
+        
         # Отправляем ответ пользователю
         await send_message(message, final_response, files_list=files_list, directories_list=directories_list)
         logger.info(f"✅ Ответ отправлен пользователю {message.from_user.id}")