smart-bot-factory 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

smart_bot_factory/configs/growthmed-october-24/tests/quick_scenarios.yaml

@@ -2,65 +2,132 @@ scenarios:
   - name: "Быстрое решение по участию"
     steps:
       - user_input: "Привет, срочно нужна информация о конференции"
-        expected_keywords: ["привет", "информация", "конференци"]
-        forbidden_keywords: ["не спешите"]
+        expected_keywords:
+          - ["привет", "здравствуйте", "добро пожаловать", "добрый день"]
+          - ["информация", "данные", "подробности", "детали"]
+          - ["конференци", "мероприятие", "событие"]
+        forbidden_keywords: ["не спешите", "позже", "не торопитесь"]
         
       - user_input: "Завтра улетаю в командировку, успею зарегистрироваться?"
-        expected_keywords: ["успеете", "регистрация", "быстро"]
-        forbidden_keywords: ["поздно", "не успеете"]
+        expected_keywords:
+          - ["успеете", "успеете зарегистрироваться", "все получится"]
+          - ["регистрация", "запись", "участие"]
+          - ["быстро", "срочно", "экспресс", "ускоренно"]
+        forbidden_keywords: ["поздно", "не успеете", "время вышло"]
 
   - name: "Студент медвуза интересуется будущим"
     steps:
       - user_input: "Здравствуйте, я студент 5 курса медуниверситета"
-        expected_keywords: ["здравствуйте", "студент", "медицин"]
-        forbidden_keywords: ["рано для вас"]
+        expected_keywords:
+          - ["здравствуйте", "привет", "добро пожаловать"]
+          - ["студент", "обучающийся", "учащийся"]
+          - ["медицин", "медвуз", "университет", "медицинский"]
+        forbidden_keywords: ["рано для вас", "еще рано", "не подходит"]
         
       - user_input: "Стоит ли уже сейчас думать о бизнесе в медицине?"
-        expected_keywords: ["стоит", "перспектив", "будущее"]
-        forbidden_keywords: ["рано думать"]
+        expected_keywords:
+          - ["стоит", "правильно", "хорошая идея", "отличный подход"]
+          - ["перспектив", "возможности", "будущее", "карьера"]
+          - ["бизнес", "предпринимательство", "дело"]
+        forbidden_keywords: ["рано думать", "не стоит", "пока рано"]
         
       - user_input: "Есть ли льготы для студентов?"
-        expected_keywords: ["льготы", "студент", "скидк"]
-        forbidden_keywords: ["полная стоимость"]
+        expected_keywords:
+          - ["льготы", "скидки", "преференции", "льготные условия"]
+          - ["студент", "учащимся", "обучающимся"]
+          - ["специальные условия", "уменьшенная стоимость"]
+        forbidden_keywords: ["полная стоимость", "без скидок", "обычная цена"]
 
   - name: "Иностранный врач в России"
     steps:
       - user_input: "Hello, I am foreign doctor working in Moscow"
-        expected_keywords: ["hello", "добро пожаловать", "moscow"]
-        forbidden_keywords: ["только на русском"]
+        expected_keywords:
+          - ["hello", "hi", "добро пожаловать", "привет"]
+          - ["foreign", "иностранный", "зарубежный"]
+          - ["moscow", "москва", "россия"]
+        forbidden_keywords: ["только на русском", "only russian", "русский язык"]
         
       - user_input: "Is conference in English or Russian language?"
-        expected_keywords: ["language", "english", "translation"]
-        forbidden_keywords: ["только русский"]
+        expected_keywords:
+          - ["language", "язык", "english", "английский"]
+          - ["translation", "перевод", "переводим", "синхронный перевод"]
+          - ["both", "оба языка", "многоязычный"]
+        forbidden_keywords: ["только русский", "only russian", "без перевода"]
         
       - user_input: "I want to understand Russian medical business"
-        expected_keywords: ["business", "russian", "understand"]
-        forbidden_keywords: ["сложно будет"]
+        expected_keywords:
+          - ["business", "бизнес", "предпринимательство"]
+          - ["russian", "российский", "россии"]
+          - ["understand", "понять", "изучить", "разобраться"]
+        forbidden_keywords: ["сложно будет", "difficult", "не получится"]
 
   - name: "Пенсионер-врач ищет активность"
     steps:
       - user_input: "Добрый день, я врач на пенсии уже 3 года"
-        expected_keywords: ["добрый день", "пенси", "врач"]
-        forbidden_keywords: ["не актуально"]
+        expected_keywords:
+          - ["добрый день", "здравствуйте", "привет"]
+          - ["пенси", "пенсионер", "на пенсии", "отставной"]
+          - ["врач", "доктор", "медицинский работник"]
+        forbidden_keywords: ["не актуально", "не подходит", "слишком поздно"]
         
       - user_input: "Хочу быть в курсе современных тенденций"
-        expected_keywords: ["современн", "тенденци", "актуальн"]
-        forbidden_keywords: ["устарело"]
+        expected_keywords:
+          - ["современн", "актуальн", "новейш", "передов"]
+          - ["тенденци", "тренды", "направления", "развитие"]
+          - ["курс", "информирован", "знания", "обучение"]
+        forbidden_keywords: ["устарело", "не актуально", "пропустили время"]
         
       - user_input: "Подходит ли конференция для неработающих врачей?"
-        expected_keywords: ["подходит", "для всех", "врачей"]
-        forbidden_keywords: ["только для практикующих"]
+        expected_keywords:
+          - ["подходит", "идеально", "отлично", "рекомендуем"]
+          - ["для всех", "всем", "любому", "каждому"]
+          - ["врачей", "специалистов", "медиков", "докторов"]
+        forbidden_keywords: ["только для практикующих", "не подходит", "не рекомендуется"]
 
   - name: "Технический директор медцентра"
     steps:
       - user_input: "Здравствуйте, я отвечаю за IT в медицинском центре"
-        expected_keywords: ["здравствуйте", "it", "медицинск"]
-        forbidden_keywords: ["не ваша тема"]
+        expected_keywords:
+          - ["здравствуйте", "привет", "добро пожаловать"]
+          - ["it", "информационные технологии", "технологии", "айти"]
+          - ["медицинск", "медицинский", "клиника", "медцентр"]
+        forbidden_keywords: ["не ваша тема", "не подходит", "не актуально"]
         
       - user_input: "Есть ли секции по цифровизации медицины?"
-        expected_keywords: ["цифровизация", "технологи", "it"]
-        forbidden_keywords: ["только бизнес"]
+        expected_keywords:
+          - ["цифровизация", "цифровые технологии", "информатизация"]
+          - ["технологи", "инновации", "современные решения"]
+          - ["it", "программирование", "автоматизация"]
+        forbidden_keywords: ["только бизнес", "без технологий", "не рассматриваем"]
         
       - user_input: "Интересуют телемедицина и электронные карты"
-        expected_keywords: ["телемедицина", "электронн", "карты"]
-        forbidden_keywords: ["не рассматриваем"]
+        expected_keywords:
+          - ["телемедицина", "удаленная медицина", "дистанционные консультации"]
+          - ["электронн", "цифровые", "компьютерные"]
+          - ["карты", "медицинские карты", "история болезни"]
+        forbidden_keywords: ["не рассматриваем", "не актуально", "не обсуждаем"]
+
+  - name: "Смешанный формат синонимов - демонстрация новых возможностей"
+    steps:
+      - user_input: "Здравствуйте, хочу узнать подробности о мероприятии"
+        expected_keywords:
+          - "здравствуйте"                                    # Одиночное слово
+          - ["хочу", "интересуюсь", "планирую"]             # Группа синонимов
+          - ["подробности", "детали", "информация"]         # Еще одна группа синонимов
+          - "мероприятие"                                    # Еще одно одиночное слово
+        forbidden_keywords: []
+
+      - user_input: "Когда будет конференция и сколько стоит участие?"
+        expected_keywords:
+          - ["когда", "дата", "время", "расписание"]         # Группа синонимов
+          - "конференция"                                    # Одиночное слово  
+          - ["стоит", "цена", "стоимость", "сколько"]       # Группа синонимов
+          - ["участие", "регистрация", "вход"]              # Группа синонимов
+        forbidden_keywords: ["не знаю", "неизвестно", "не определились"]
+
+      - user_input: "Есть ли скидки для студентов и врачей?"
+        expected_keywords:
+          - ["скидки", "льготы", "преференции"]             # Группа синонимов
+          - "студентов"                                      # Одиночное слово
+          - ["врачей", "докторов", "медиков"]               # Группа синонимов
+        forbidden_keywords: ["полная стоимость", "без скидок"]

smart_bot_factory/core/bot_utils.py

@@ -1,6 +1,7 @@
 import asyncio
 import json
 import logging
+import re
 from datetime import datetime
 from aiogram import Router
 from aiogram.filters import Command
@@ -13,7 +14,13 @@ from aiogram.types import (
 from aiogram.utils.media_group import MediaGroupBuilder
 
 from pathlib import Path
-from ..core.decorators import execute_event_handler, execute_scheduled_task
+from ..core.decorators import (
+    execute_event_handler, 
+    save_immediate_event,
+    schedule_task_for_later_with_db,
+    schedule_global_handler_for_later_with_db,
+    update_event_result
+)
 
 # Функция для получения глобальных переменных
 def get_global_var(var_name):
@@ -24,6 +31,7 @@ def get_global_var(var_name):
 
 logger = logging.getLogger(__name__)
 
+
 # Создаем роутер для общих команд
 utils_router = Router()
 
@@ -182,28 +190,109 @@ async def process_events(session_id: str, events: list, user_id: int):
             logger.info(f"   📝 Тип: {event_type}")
             logger.info(f"   📄 Данные: {event_info}")
             
-            # Сохраняем в БД
-            await supabase_client.add_session_event(session_id, event_type, event_info)
-            logger.info(f"   ✅ Событие сохранено в БД")
-            
-            # Вызываем зарегистрированный обработчик события или задачи
+            # Определяем категорию события и сохраняем в БД
+            event_id = None
+            should_execute_immediately = False
             should_notify = False
+            
             try:
+                # Проверяем зарегистрированные обработчики через роутер-менеджер
+                from ..core.decorators import get_router_manager, _event_handlers, _scheduled_tasks, _global_handlers
+                
+                # Получаем обработчики из роутеров или fallback к старым декораторам
+                router_manager = get_router_manager()
+                if router_manager:
+                    event_handlers = router_manager.get_event_handlers()
+                    scheduled_tasks = router_manager.get_scheduled_tasks()
+                    global_handlers = router_manager.get_global_handlers()
+                    logger.debug(f"🔍 RouterManager найден: {len(global_handlers)} глобальных обработчиков")
+                else:
+                    event_handlers = _event_handlers
+                    scheduled_tasks = _scheduled_tasks
+                    global_handlers = _global_handlers
+                    logger.warning("⚠️ RouterManager не найден, используем старые декораторы")
+                
                 # Сначала пробуем как обычное событие
-                try:
-                    logger.info(f"   🎯 Вызываем обработчик события '{event_type}'")
-                    result = await execute_event_handler(event_type, user_id, event_info)
-                    logger.info(f"   ✅ Обработчик события вернул: {result}")
-                    
-                    should_notify = result.get('notify', False)
+                if event_type in event_handlers:
+                    try:
+                        logger.info(f"   🎯 Сохраняем как user_event: '{event_type}'")
+                        event_id = await save_immediate_event(event_type, user_id, event_info, session_id)
+                        should_execute_immediately = True
+                        logger.info(f"   💾 Событие сохранено в БД: {event_id}")
+                    except ValueError as e:
+                        if "once_only=True" in str(e):
+                            logger.info(f"   🔄 Событие '{event_type}' уже обрабатывалось, пропускаем")
+                            continue
+                        else:
+                            raise
+                
+                # Если не user_event, пробуем как запланированную задачу
+                elif event_type in scheduled_tasks:
+                    try:
+                        # Извлекаем время из event_info (AI должен передавать число секунд)
+                        try:
+                            delay_seconds = int(event_info)
+                        except ValueError:
+                            # Если не число, используем значение по умолчанию
+                            delay_seconds = 3600
+                            logger.warning(f"   ⚠️ Не удалось извлечь время из '{event_info}', используем 3600с")
                         
-                except ValueError:
-                    # Если обработчик события не найден, пробуем как запланированную задачу
-                    logger.info(f"   ⏰ Пробуем как запланированную задачу '{event_type}'")
-                    result = await execute_scheduled_task(event_type, user_id, event_info)
-                    logger.info(f"   ✅ Задача выполнена: {result}")
-                    
-                    should_notify = result.get('notify', False)
+                        logger.info(f"   ⏰ Сохраняем как scheduled_task: '{event_type}' через {delay_seconds}с")
+                        result = await schedule_task_for_later_with_db(event_type, user_id, event_info, delay_seconds, session_id)
+                        event_id = result['event_id']
+                        should_notify = result.get('notify', False)
+                        logger.info(f"   💾 Задача сохранена в БД: {event_id}")
+                        
+                    except Exception as e:
+                        if "once_only=True" in str(e):
+                            logger.info(f"   🔄 Задача '{event_type}' уже запланирована, пропускаем")
+                            continue
+                        else:
+                            logger.error(f"   ❌ Ошибка планирования scheduled_task '{event_type}': {e}")
+                            continue
+                
+                # Если не scheduled_task, пробуем как глобальный обработчик
+                elif event_type in global_handlers:
+                    try:
+                        # Извлекаем время из event_info (AI должен передавать число секунд)
+                        try:
+                            delay_seconds = int(event_info)
+                        except ValueError:
+                            # Если не число, используем значение по умолчанию
+                            delay_seconds = 3600
+                            logger.warning(f"   ⚠️ Не удалось извлечь время из '{event_info}', используем 3600с")
+                        
+                        logger.info(f"   🌍 Сохраняем как global_handler: '{event_type}' через {delay_seconds}с")
+                        result = await schedule_global_handler_for_later_with_db(event_type, delay_seconds, event_info)
+                        event_id = result['event_id']
+                        should_notify = result.get('notify', False)
+                        logger.info(f"   💾 Глобальное событие сохранено в БД: {event_id}")
+                        
+                    except Exception as e:
+                        if "once_only=True" in str(e):
+                            logger.info(f"   🔄 Глобальное событие '{event_type}' уже запланировано, пропускаем")
+                            continue
+                        else:
+                            logger.error(f"   ❌ Ошибка планирования global_handler '{event_type}': {e}")
+                            continue
+                
+                else:
+                    logger.warning(f"   ⚠️ Обработчик '{event_type}' не найден среди зарегистрированных")
+                    logger.debug(f"   🔍 Доступные обработчики:")
+                    logger.debug(f"      - event_handlers: {list(event_handlers.keys())}")
+                    logger.debug(f"      - scheduled_tasks: {list(scheduled_tasks.keys())}")
+                    logger.debug(f"      - global_handlers: {list(global_handlers.keys())}")
+                
+                # Выполняем немедленные события
+                if should_execute_immediately and event_id:
+                    try:
+                        result = await execute_event_handler(event_type, user_id, event_info)
+                        should_notify = result.get('notify', False)
+                        await update_event_result(event_id, 'completed', result)
+                        logger.info(f"   ✅ Событие выполнено: {result}")
+                    except Exception as e:
+                        await update_event_result(event_id, 'failed', None, str(e))
+                        logger.error(f"   ❌ Ошибка выполнения события: {e}")
                         
             except ValueError as e:
                 logger.warning(f"   ⚠️ Обработчик/задача не найдены: {e}")
@@ -312,34 +401,30 @@ async def send_message(message: Message, text: str, files_list: list = [], direc
         parse_mode = config.MESSAGE_PARSE_MODE if config.MESSAGE_PARSE_MODE != 'None' else None
         logger.info(f"   🔧 Parse mode: {parse_mode}")
         
-        # В режиме отладки не скрываем JSON
-        if config.DEBUG_MODE:
-            final_text = text
-            logger.info(f"   🐛 Отправляем полный текст (debug режим)")
-        else:
-            # Убираем JSON если он есть
-            final_text, json_metadata = parse_ai_response(text)
-            logger.info(f"   ✂️ После очистки JSON: {len(final_text)} символов")
-            
-            # Добавляем информацию о файлах и каталогах в конец сообщения
-            if json_metadata:
-                logger.info(f"   📊 Найден JSON: {json_metadata}")
-                
-                files_list = json_metadata.get('файлы', [])
-                directories_list = json_metadata.get('каталоги', [])
-                
-                files_info = []
-                if files_list:
-                    files_str = "\n".join(f"• {file}" for file in files_list)
-                    files_info.append(f"\n\n📎 Доступные файлы:\n{files_str}")
-                
-                if directories_list:
-                    dirs_str = "\n".join(f"• {directory}" for directory in directories_list)
-                    files_info.append(f"\n\n📂 Доступные каталоги:\n{dirs_str}")
-                
-                if files_info:
-                    final_text = final_text.strip() + "".join(files_info)
-                    logger.info(f"   ✨ Добавлена информация о {len(files_list)} файлах и {len(directories_list)} каталогах")
+        # Получаем user_id и импортируем supabase_client
+        user_id = message.from_user.id
+        supabase_client = get_global_var('supabase_client')
+        
+        # Текст уже готов, используем как есть
+        final_text = text
+        
+        # Работаем с переданными файлами и каталогами
+        logger.info(f"   📦 Передано файлов: {files_list}")
+        logger.info(f"   📂 Передано каталогов: {directories_list}")
+        
+        # Получаем список уже отправленных файлов и каталогов
+        sent_files = await supabase_client.get_sent_files(user_id)
+        sent_directories = await supabase_client.get_sent_directories(user_id)
+        
+        logger.info(f"   📋 Уже отправлено файлов: {sent_files}")
+        logger.info(f"   📋 Уже отправлено каталогов: {sent_directories}")
+        
+        # Фильтруем файлы и каталоги, которые уже отправлялись
+        actual_files_list = [f for f in files_list if f not in sent_files]
+        actual_directories_list = [d for d in directories_list if str(d) not in sent_directories]
+        
+        logger.info(f"   🆕 После фильтрации файлов: {actual_files_list}")
+        logger.info(f"   🆕 После фильтрации каталогов: {actual_directories_list}")
                     
         
         # Проверяем, что есть что отправлять
@@ -349,30 +434,36 @@ async def send_message(message: Message, text: str, files_list: list = [], direc
             final_text = "Ошибка формирования ответа. Попробуйте еще раз."
         
         logger.info(f"📱 Подготовка сообщения: {len(final_text)} символов")
+        logger.info(f"   📦 Файлов для обработки: {actual_files_list}")
+        logger.info(f"   📂 Каталогов для обработки: {actual_directories_list}")
         
         # Проверяем наличие файлов для отправки
-        if files_list or directories_list:
+        if actual_files_list or actual_directories_list:
             # Функция определения типа медиа по расширению
             def get_media_type(file_path: str) -> str:
                 ext = Path(file_path).suffix.lower()
                 if ext in {'.jpg', '.jpeg', '.png'}:
                     return 'photo'
-                elif ext in {'.mp4'}:
+                elif ext in {'.mp4', '.mov'}:
                     return 'video'
                 else:
                     return 'document'
             
             # Создаем списки для разных типов файлов
-            media_files = []  # для фото и видео
+            video_files = []  # для видео
+            photo_files = []  # для фото
             document_files = []  # для документов
             
             # Функция обработки файла
             def process_file(file_path: Path, source: str = ""):
                 if file_path.is_file():
                     media_type = get_media_type(str(file_path))
-                    if media_type in ('photo', 'video'):
-                        media_files.append((file_path, media_type))
-                        logger.info(f"   📸 Добавлен медиафайл{f' из {source}' if source else ''}: {file_path.name}")
+                    if media_type == 'video':
+                        video_files.append(file_path)
+                        logger.info(f"   🎥 Добавлено видео{f' из {source}' if source else ''}: {file_path.name}")
+                    elif media_type == 'photo':
+                        photo_files.append(file_path)
+                        logger.info(f"   📸 Добавлено фото{f' из {source}' if source else ''}: {file_path.name}")
                     else:
                         document_files.append(file_path)
                         logger.info(f"   📄 Добавлен документ{f' из {source}' if source else ''}: {file_path.name}")
@@ -380,54 +471,58 @@ async def send_message(message: Message, text: str, files_list: list = [], direc
                     logger.warning(f"   ⚠️ Файл не найден: {file_path}")
             
             # Обрабатываем прямые файлы
-            for file_name in files_list:
+            for file_name in actual_files_list:
                 try:
-                    # Получаем путь к папке бота
-                    config = get_global_var('config')
-                    bot_id = config.BOT_ID if config else "unknown"
-                    file_path = Path(f"bots/{bot_id}/files/{file_name}")
-                    process_file(file_path)
+                    process_file(Path(f"files/{file_name}"))
                 except Exception as e:
                     logger.error(f"   ❌ Ошибка обработки файла {file_name}: {e}")
             
             # Обрабатываем файлы из каталогов
-            for dir_name in directories_list:
-                # Получаем путь к каталогу относительно папки бота
-                config = get_global_var('config')
-                bot_id = config.BOT_ID if config else "unknown"
-                dir_path = Path(f"bots/{bot_id}/{dir_name}")
+            for dir_name in actual_directories_list:
+                dir_name = Path(dir_name)
                 try:
-                    if dir_path.is_dir():
-                        for file_path in dir_path.iterdir():
+                    if dir_name.is_dir():
+                        for file_path in dir_name.iterdir():
                             try:
-                                process_file(file_path, dir_path)
+                                process_file(file_path, dir_name)
                             except Exception as e:
                                 logger.error(f"   ❌ Ошибка обработки файла {file_path}: {e}")
                     else:
-                        logger.warning(f"   ⚠️ Каталог не найден: {dir_path}")
+                        logger.warning(f"   ⚠️ Каталог не найден: {dir_name}")
                 except Exception as e:
-                    logger.error(f"   ❌ Ошибка обработки каталога {dir_path}: {e}")
+                    logger.error(f"   ❌ Ошибка обработки каталога {dir_name}: {e}")
+            
+            # Списки для отслеживания реально отправленных файлов
+            sent_files_to_save = []
+            sent_dirs_to_save = []
             
-            # Отправляем сообщение с медиа (если есть)
-            if media_files:
-                # Создаем медиа-группу с фото/видео и текстом
-                media_group = MediaGroupBuilder(caption=final_text)
-                for file_path, media_type in media_files:
-                    if media_type == 'photo':
-                        media_group.add_photo(media=FSInputFile(str(file_path)))
-                    else:  # video
-                        media_group.add_video(media=FSInputFile(str(file_path)))
+            # 1. Отправляем видео (если есть)
+            if video_files:
+                video_group = MediaGroupBuilder()
+                for file_path in video_files:
+                    video_group.add_video(media=FSInputFile(str(file_path)))
                 
-                media = media_group.build()
-                if media:
-                    result = await message.answer_media_group(media=media)
-                    logger.info(f"   ✅ Отправлено сообщение с {len(media)} медиафайлами")
-            else:
-                # Если нет медиа, отправляем просто текст
-                result = await message.answer(final_text, parse_mode=parse_mode, **kwargs)
-                logger.info(f"   ✅ Отправлен текст сообщения")
+                videos = video_group.build()
+                if videos:
+                    await message.answer_media_group(media=videos)
+                    logger.info(f"   ✅ Отправлено {len(videos)} видео")
+            
+            # 2. Отправляем фото (если есть)
+            if photo_files:
+                photo_group = MediaGroupBuilder()
+                for file_path in photo_files:
+                    photo_group.add_photo(media=FSInputFile(str(file_path)))
+                
+                photos = photo_group.build()
+                if photos:
+                    await message.answer_media_group(media=photos)
+                    logger.info(f"   ✅ Отправлено {len(photos)} фото")
+            
+            # 3. Отправляем текст
+            result = await message.answer(final_text, parse_mode=parse_mode)
+            logger.info(f"   ✅ Отправлен текст сообщения")
             
-            # Отправляем документы отдельно (если есть)
+            # 4. Отправляем документы (если есть)
             if document_files:
                 doc_group = MediaGroupBuilder()
                 for file_path in document_files:
@@ -436,7 +531,32 @@ async def send_message(message: Message, text: str, files_list: list = [], direc
                 docs = doc_group.build()
                 if docs:
                     await message.answer_media_group(media=docs)
-                    logger.info(f"   ✅ Отправлена группа документов: {len(docs)} файлов")
+                    logger.info(f"   ✅ Отправлено {len(docs)} документов")
+            
+            # 5. Собираем список реально отправленных файлов и каталогов
+            # Если были отправлены файлы из actual_files_list - сохраняем их
+            if video_files or photo_files or document_files:
+                # Сохраняем прямые файлы из actual_files_list (если отправлены)
+                sent_files_to_save.extend(actual_files_list)
+                logger.info(f"   📝 Добавляем в список для сохранения файлы: {actual_files_list}")
+                # Сохраняем каталоги из actual_directories_list (если отправлены файлы из них)
+                sent_dirs_to_save.extend([str(d) for d in actual_directories_list])
+                logger.info(f"   📝 Добавляем в список для сохранения каталоги: {actual_directories_list}")
+            
+            # 6. Обновляем информацию в БД
+            if sent_files_to_save or sent_dirs_to_save:
+                try:
+                    if sent_files_to_save:
+                        logger.info(f"   💾 Сохраняем файлы в БД: {sent_files_to_save}")
+                        await supabase_client.add_sent_files(user_id, sent_files_to_save)
+                    if sent_dirs_to_save:
+                        logger.info(f"   💾 Сохраняем каталоги в БД: {sent_dirs_to_save}")
+                        await supabase_client.add_sent_directories(user_id, sent_dirs_to_save)
+                    logger.info(f"   ✅ Обновлена информация о отправленных файлах в БД")
+                except Exception as e:
+                    logger.error(f"   ❌ Ошибка обновления информации о файлах в БД: {e}")
+            else:
+                logger.info(f"   ℹ️ Нет новых файлов для сохранения в БД")
             
             return result
         else:
@@ -446,6 +566,14 @@ async def send_message(message: Message, text: str, files_list: list = [], direc
                 return result
         
     except Exception as e:
+        # Проверяем, является ли ошибка блокировкой бота
+        if "Forbidden: bot was blocked by the user" in str(e):
+            logger.warning(f"🚫 Бот заблокирован пользователем {user_id}")
+            return None
+        elif "TelegramForbiddenError" in str(type(e).__name__):
+            logger.warning(f"🚫 Бот заблокирован пользователем {user_id}")
+            return None
+        
         logger.error(f"❌ ОШИБКА в send_message: {e}")
         logger.exception("Полный стек ошибки send_message:")
         
@@ -456,6 +584,14 @@ async def send_message(message: Message, text: str, files_list: list = [], direc
             logger.info(f"✅ Запасное сообщение отправлено")
             return result
         except Exception as e2:
+            # Проверяем и здесь блокировку бота
+            if "Forbidden: bot was blocked by the user" in str(e2):
+                logger.warning(f"🚫 Бот заблокирован пользователем {user_id} (fallback)")
+                return None
+            elif "TelegramForbiddenError" in str(type(e2).__name__):
+                logger.warning(f"🚫 Бот заблокирован пользователем {user_id} (fallback)")
+                return None
+            
             logger.error(f"❌ Даже запасное сообщение не отправилось: {e2}")
             raise