smart-bot-factory 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

smart_bot_factory/core/globals.py

@@ -0,0 +1,68 @@
+"""
+Глобальные переменные для удобного доступа к компонентам бота
+"""
+
+from typing import Optional
+from ..integrations.supabase_client import SupabaseClient
+from ..integrations.openai_client import OpenAIClient
+from ..config import Config
+from ..admin.admin_manager import AdminManager
+from ..analytics.analytics_manager import AnalyticsManager
+from ..core.conversation_manager import ConversationManager
+from ..utils.prompt_loader import PromptLoader
+
+# Глобальные переменные (будут установлены при инициализации бота)
+supabase_client: Optional[SupabaseClient] = None
+openai_client: Optional[OpenAIClient] = None
+config: Optional[Config] = None
+admin_manager: Optional[AdminManager] = None
+analytics_manager: Optional[AnalyticsManager] = None
+conversation_manager: Optional[ConversationManager] = None
+prompt_loader: Optional[PromptLoader] = None
+bot: Optional[object] = None  # aiogram Bot
+dp: Optional[object] = None   # aiogram Dispatcher
+
+def set_globals(**kwargs):
+    """Устанавливает глобальные переменные"""
+    global supabase_client, openai_client, config, admin_manager
+    global analytics_manager, conversation_manager, prompt_loader, bot, dp
+    
+    for key, value in kwargs.items():
+        if key in globals():
+            globals()[key] = value
+
+def get_supabase_client() -> Optional[SupabaseClient]:
+    """Получает клиент Supabase"""
+    return supabase_client
+
+def get_openai_client() -> Optional[OpenAIClient]:
+    """Получает клиент OpenAI"""
+    return openai_client
+
+def get_config() -> Optional[Config]:
+    """Получает конфигурацию"""
+    return config
+
+def get_admin_manager() -> Optional[AdminManager]:
+    """Получает менеджер админов"""
+    return admin_manager
+
+def get_analytics_manager() -> Optional[AnalyticsManager]:
+    """Получает менеджер аналитики"""
+    return analytics_manager
+
+def get_conversation_manager() -> Optional[ConversationManager]:
+    """Получает менеджер разговоров"""
+    return conversation_manager
+
+def get_prompt_loader() -> Optional[PromptLoader]:
+    """Получает загрузчик промптов"""
+    return prompt_loader
+
+def get_bot() -> Optional[object]:
+    """Получает экземпляр бота"""
+    return bot
+
+def get_dp() -> Optional[object]:
+    """Получает диспетчер"""
+    return dp

smart_bot_factory/core/message_sender.py

@@ -29,14 +29,14 @@ async def send_message_by_ai(
     try:
         # Импортируем необходимые компоненты
         from .bot_utils import parse_ai_response, process_events
-        from .config import Config
-        from .openai_client import OpenAIClient
-        from .supabase_client import SupabaseClient
-        from .prompt_loader import PromptLoader
+        from ..config import Config
+        from ..integrations.openai_client import OpenAIClient
+        from ..integrations.supabase_client import SupabaseClient
+        from ..utils.prompt_loader import PromptLoader
         from aiogram import Bot
 
         # Получаем компоненты из глобального контекста
-        from .handlers import get_global_var
+        from ..handlers.handlers import get_global_var
         bot = get_global_var('bot')
         supabase_client = get_global_var('supabase_client')
         openai_client = get_global_var('openai_client')
@@ -211,7 +211,7 @@ async def send_message_by_human(
     """
     try:
         # Импортируем необходимые компоненты
-        from .handlers import get_global_var
+        from ..handlers.handlers import get_global_var
         bot = get_global_var('bot')
         supabase_client = get_global_var('supabase_client')
         

smart_bot_factory/core/router.py

@@ -0,0 +1,172 @@
+"""
+Роутер для Smart Bot Factory - аналог aiogram Router
+"""
+
+from typing import Dict, List, Any, Callable, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+class Router:
+    """
+    Роутер для организации обработчиков событий, задач и глобальных обработчиков
+    """
+    
+    def __init__(self, name: str = None):
+        """
+        Инициализация роутера
+        
+        Args:
+            name: Имя роутера для логирования
+        """
+        self.name = name or f"Router_{id(self)}"
+        self._event_handlers: Dict[str, Dict[str, Any]] = {}
+        self._scheduled_tasks: Dict[str, Dict[str, Any]] = {}
+        self._global_handlers: Dict[str, Dict[str, Any]] = {}
+        
+        logger.info(f"🔄 Создан роутер: {self.name}")
+    
+    def event_handler(self, event_type: str, notify: bool = False, once_only: bool = True):
+        """
+        Декоратор для регистрации обработчика события в роутере
+        
+        Args:
+            event_type: Тип события
+            notify: Уведомлять ли админов
+            once_only: Выполнять ли только один раз
+        """
+        def decorator(func: Callable) -> Callable:
+            self._event_handlers[event_type] = {
+                'handler': func,
+                'name': func.__name__,
+                'notify': notify,
+                'once_only': once_only,
+                'router': self.name
+            }
+            
+            logger.info(f"📝 Роутер {self.name}: зарегистрирован обработчик события '{event_type}': {func.__name__}")
+            
+            from functools import wraps
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                try:
+                    return await func(*args, **kwargs)
+                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):
+        """
+        Декоратор для регистрации запланированной задачи в роутере
+        
+        Args:
+            task_name: Название задачи
+            notify: Уведомлять ли админов
+            smart_check: Использовать ли умную проверку
+            once_only: Выполнять ли только один раз
+        """
+        def decorator(func: Callable) -> Callable:
+            self._scheduled_tasks[task_name] = {
+                'handler': func,
+                'name': func.__name__,
+                'notify': notify,
+                'smart_check': smart_check,
+                'once_only': once_only,
+                'router': self.name
+            }
+            
+            logger.info(f"⏰ Роутер {self.name}: зарегистрирована задача '{task_name}': {func.__name__}")
+            
+            from functools import wraps
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                try:
+                    return await func(*args, **kwargs)
+                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):
+        """
+        Декоратор для регистрации глобального обработчика в роутере
+        
+        Args:
+            handler_type: Тип глобального обработчика
+            notify: Уведомлять ли админов
+            once_only: Выполнять ли только один раз
+        """
+        def decorator(func: Callable) -> Callable:
+            self._global_handlers[handler_type] = {
+                'handler': func,
+                'name': func.__name__,
+                'notify': notify,
+                'once_only': once_only,
+                'router': self.name
+            }
+            
+            logger.info(f"🌍 Роутер {self.name}: зарегистрирован глобальный обработчик '{handler_type}': {func.__name__}")
+            
+            from functools import wraps
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                try:
+                    return await func(*args, **kwargs)
+                except Exception as e:
+                    logger.error(f"Ошибка выполнения глобального обработчика '{handler_type}' в роутере {self.name}: {e}")
+                    raise
+            return wrapper
+        return decorator
+    
+    def get_event_handlers(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все обработчики событий роутера"""
+        return self._event_handlers.copy()
+    
+    def get_scheduled_tasks(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все запланированные задачи роутера"""
+        return self._scheduled_tasks.copy()
+    
+    def get_global_handlers(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все глобальные обработчики роутера"""
+        return self._global_handlers.copy()
+    
+    def get_all_handlers(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все обработчики роутера"""
+        all_handlers = {}
+        all_handlers.update(self._event_handlers)
+        all_handlers.update(self._scheduled_tasks)
+        all_handlers.update(self._global_handlers)
+        return all_handlers
+    
+    def include_router(self, router: 'Router'):
+        """
+        Включает другой роутер в текущий
+        
+        Args:
+            router: Роутер для включения
+        """
+        # Добавляем обработчики событий
+        for event_type, handler_info in router.get_event_handlers().items():
+            if event_type in self._event_handlers:
+                logger.warning(f"⚠️ Конфликт обработчиков событий '{event_type}' между роутерами {self.name} и {router.name}")
+            self._event_handlers[event_type] = handler_info
+        
+        # Добавляем запланированные задачи
+        for task_name, task_info in router.get_scheduled_tasks().items():
+            if task_name in self._scheduled_tasks:
+                logger.warning(f"⚠️ Конфликт задач '{task_name}' между роутерами {self.name} и {router.name}")
+            self._scheduled_tasks[task_name] = task_info
+        
+        # Добавляем глобальные обработчики
+        for handler_type, handler_info in router.get_global_handlers().items():
+            if handler_type in self._global_handlers:
+                logger.warning(f"⚠️ Конфликт глобальных обработчиков '{handler_type}' между роутерами {self.name} и {router.name}")
+            self._global_handlers[handler_type] = handler_info
+        
+        logger.info(f"🔗 Роутер {self.name}: включен роутер {router.name}")
+    
+    def __repr__(self):
+        return f"Router(name='{self.name}', events={len(self._event_handlers)}, tasks={len(self._scheduled_tasks)}, globals={len(self._global_handlers)})"

smart_bot_factory/core/router_manager.py

@@ -0,0 +1,165 @@
+"""
+Менеджер роутеров для Smart Bot Factory
+"""
+
+from typing import Dict, List, Any, Optional
+import logging
+from .router import Router
+
+logger = logging.getLogger(__name__)
+
+class RouterManager:
+    """
+    Менеджер для управления роутерами и их обработчиками
+    """
+    
+    def __init__(self):
+        self._routers: List[Router] = []
+        self._combined_handlers: Dict[str, Dict[str, Any]] = {
+            'event_handlers': {},
+            'scheduled_tasks': {},
+            'global_handlers': {}
+        }
+        
+        logger.info("🔄 Создан менеджер роутеров")
+    
+    def register_router(self, router: Router):
+        """
+        Регистрирует роутер в менеджере
+        
+        Args:
+            router: Роутер для регистрации
+        """
+        if router not in self._routers:
+            self._routers.append(router)
+            self._update_combined_handlers()
+            logger.info(f"✅ Зарегистрирован роутер: {router.name}")
+        else:
+            logger.warning(f"⚠️ Роутер {router.name} уже зарегистрирован")
+    
+    def unregister_router(self, router: Router):
+        """
+        Отменяет регистрацию роутера
+        
+        Args:
+            router: Роутер для отмены регистрации
+        """
+        if router in self._routers:
+            self._routers.remove(router)
+            self._update_combined_handlers()
+            logger.info(f"❌ Отменена регистрация роутера: {router.name}")
+        else:
+            logger.warning(f"⚠️ Роутер {router.name} не найден в зарегистрированных")
+    
+    def _update_combined_handlers(self):
+        """Обновляет объединенные обработчики всех роутеров"""
+        # Очищаем текущие обработчики
+        self._combined_handlers = {
+            'event_handlers': {},
+            'scheduled_tasks': {},
+            'global_handlers': {}
+        }
+        
+        # Собираем обработчики из всех роутеров
+        for router in self._routers:
+            # Обработчики событий
+            for event_type, handler_info in router.get_event_handlers().items():
+                if event_type in self._combined_handlers['event_handlers']:
+                    existing_router = self._combined_handlers['event_handlers'][event_type]['router']
+                    logger.warning(f"⚠️ Конфликт обработчиков событий '{event_type}' между роутерами {existing_router} и {router.name}")
+                self._combined_handlers['event_handlers'][event_type] = handler_info
+            
+            # Запланированные задачи
+            for task_name, task_info in router.get_scheduled_tasks().items():
+                if task_name in self._combined_handlers['scheduled_tasks']:
+                    existing_router = self._combined_handlers['scheduled_tasks'][task_name]['router']
+                    logger.warning(f"⚠️ Конфликт задач '{task_name}' между роутерами {existing_router} и {router.name}")
+                self._combined_handlers['scheduled_tasks'][task_name] = task_info
+            
+            # Глобальные обработчики
+            for handler_type, handler_info in router.get_global_handlers().items():
+                if handler_type in self._combined_handlers['global_handlers']:
+                    existing_router = self._combined_handlers['global_handlers'][handler_type]['router']
+                    logger.warning(f"⚠️ Конфликт глобальных обработчиков '{handler_type}' между роутерами {existing_router} и {router.name}")
+                self._combined_handlers['global_handlers'][handler_type] = handler_info
+        
+        total_handlers = (len(self._combined_handlers['event_handlers']) + 
+                         len(self._combined_handlers['scheduled_tasks']) + 
+                         len(self._combined_handlers['global_handlers']))
+        
+        logger.info(f"📊 Обновлены объединенные обработчики: {total_handlers} обработчиков из {len(self._routers)} роутеров")
+    
+    def get_event_handlers(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все обработчики событий"""
+        return self._combined_handlers['event_handlers'].copy()
+    
+    def get_scheduled_tasks(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все запланированные задачи"""
+        return self._combined_handlers['scheduled_tasks'].copy()
+    
+    def get_global_handlers(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все глобальные обработчики"""
+        return self._combined_handlers['global_handlers'].copy()
+    
+    def get_all_handlers(self) -> Dict[str, Dict[str, Any]]:
+        """Получает все обработчики всех типов"""
+        all_handlers = {}
+        all_handlers.update(self._combined_handlers['event_handlers'])
+        all_handlers.update(self._combined_handlers['scheduled_tasks'])
+        all_handlers.update(self._combined_handlers['global_handlers'])
+        return all_handlers
+    
+    def get_handlers_for_prompt(self) -> str:
+        """Возвращает описание всех обработчиков для добавления в промпт ИИ"""
+        prompt_parts: List[str] = []
+        
+        if not any(self._combined_handlers.values()):
+            return ""
+        
+        if self._combined_handlers['event_handlers']:
+            prompt_parts.append("ДОСТУПНЫЕ ОБРАБОТЧИКИ СОБЫТИЙ:")
+            for event_type, handler_info in self._combined_handlers['event_handlers'].items():
+                router_name = handler_info.get('router', 'unknown')
+                prompt_parts.append(f"- {event_type}: {handler_info['name']} (роутер: {router_name})")
+        
+        if self._combined_handlers['scheduled_tasks']:
+            prompt_parts.append("\nДОСТУПНЫЕ ЗАДАЧИ ДЛЯ ПЛАНИРОВАНИЯ:")
+            for task_name, task_info in self._combined_handlers['scheduled_tasks'].items():
+                router_name = task_info.get('router', 'unknown')
+                prompt_parts.append(f"- {task_name}: {task_info['name']} (роутер: {router_name})")
+        
+        if self._combined_handlers['global_handlers']:
+            prompt_parts.append("\nДОСТУПНЫЕ ГЛОБАЛЬНЫЕ ОБРАБОТЧИКИ:")
+            for handler_type, handler_info in self._combined_handlers['global_handlers'].items():
+                router_name = handler_info.get('router', 'unknown')
+                prompt_parts.append(f"- {handler_type}: {handler_info['name']} (роутер: {router_name})")
+        
+        return "\n".join(prompt_parts)
+    
+    def get_router_by_name(self, name: str) -> Optional[Router]:
+        """Получает роутер по имени"""
+        for router in self._routers:
+            if router.name == name:
+                return router
+        return None
+    
+    def get_router_stats(self) -> Dict[str, Any]:
+        """Получает статистику по роутерам"""
+        stats = {
+            "total_routers": len(self._routers),
+            "routers": []
+        }
+        
+        for router in self._routers:
+            router_stats = {
+                "name": router.name,
+                "event_handlers": len(router.get_event_handlers()),
+                "scheduled_tasks": len(router.get_scheduled_tasks()),
+                "global_handlers": len(router.get_global_handlers())
+            }
+            stats["routers"].append(router_stats)
+        
+        return stats
+    
+    def __repr__(self):
+        return f"RouterManager(routers={len(self._routers)}, handlers={len(self.get_all_handlers())})"

smart_bot_factory/creation/__init__.py

@@ -3,6 +3,5 @@ Creation модули smart_bot_factory
 """
 
 from ..creation.bot_builder import BotBuilder
-from ..creation.bot_testing import main as bot_testing_main
 
-__all__ = ['BotBuilder', 'bot_testing_main']
+__all__ = ['BotBuilder']

smart_bot_factory/creation/bot_builder.py

@@ -14,8 +14,10 @@ from ..integrations.openai_client import OpenAIClient
 from ..integrations.supabase_client import SupabaseClient
 from ..core.conversation_manager import ConversationManager
 from ..admin.admin_manager import AdminManager
+from ..analytics.analytics_manager import AnalyticsManager
 from ..utils.prompt_loader import PromptLoader
 from ..core.decorators import get_handlers_for_prompt
+from ..core.router_manager import RouterManager
 
 logger = logging.getLogger(__name__)
 
@@ -42,7 +44,9 @@ class BotBuilder:
         self.supabase_client: Optional[SupabaseClient] = None
         self.conversation_manager: Optional[ConversationManager] = None
         self.admin_manager: Optional[AdminManager] = None
+        self.analytics_manager: Optional[AnalyticsManager] = None
         self.prompt_loader: Optional[PromptLoader] = None
+        self.router_manager: Optional[RouterManager] = None
         
         # Флаги инициализации
         self._initialized = False
@@ -146,10 +150,24 @@ class BotBuilder:
         await self.admin_manager.sync_admins_from_config()
         logger.info(f"✅ Admin Manager инициализирован")
         
+        # Analytics Manager
+        self.analytics_manager = AnalyticsManager(self.supabase_client)
+        logger.info(f"✅ Analytics Manager инициализирован")
+        
         # Conversation Manager
-        self.conversation_manager = ConversationManager(self.supabase_client, self.admin_manager)
+        parse_mode = os.environ.get('MESSAGE_PARSE_MODE', 'Markdown')
+        admin_session_timeout_minutes = int(os.environ.get('ADMIN_SESSION_TIMEOUT_MINUTES', '30'))
+        
+        self.conversation_manager = ConversationManager(self.supabase_client, self.admin_manager, parse_mode, admin_session_timeout_minutes)
         logger.info(f"✅ Conversation Manager инициализирован")
         
+        # Router Manager (создаем только если еще не создан)
+        if not self.router_manager:
+            self.router_manager = RouterManager()
+            logger.info(f"✅ Router Manager инициализирован")
+        else:
+            logger.info(f"✅ Router Manager уже был создан ранее")
+        
         # Prompt Loader
         self.prompt_loader = PromptLoader(
             prompts_dir=self.config.PROMT_FILES_DIR
@@ -164,7 +182,11 @@ class BotBuilder:
         logger.info(f"🔧 Обновление промптов с информацией об обработчиках")
         
         # Получаем информацию о доступных обработчиках
-        event_handlers_info = get_handlers_for_prompt()
+        # Сначала пробуем получить из роутеров, если нет - из старых декораторов
+        if self.router_manager:
+            event_handlers_info = self.router_manager.get_handlers_for_prompt()
+        else:
+            event_handlers_info = get_handlers_for_prompt()
         
         # Если есть обработчики, добавляем их в системный промпт
         if event_handlers_info:
@@ -192,6 +214,7 @@ class BotBuilder:
                 "supabase_client": self.supabase_client is not None,
                 "conversation_manager": self.conversation_manager is not None,
                 "admin_manager": self.admin_manager is not None,
+                "analytics_manager": self.analytics_manager is not None,
                 "prompt_loader": self.prompt_loader is not None
             },
             "tools": {
@@ -199,6 +222,57 @@ class BotBuilder:
             }
         }
     
+    def set_global_vars_in_module(self, module_name: str):
+        """
+        Устанавливает глобальные переменные в указанном модуле для удобного доступа
+        
+        Args:
+            module_name: Имя модуля (например, 'valera', 'my_bot')
+        """
+        try:
+            import sys
+            import importlib
+            
+            # Получаем модуль бота
+            bot_module = sys.modules.get(module_name)
+            if not bot_module:
+                logger.warning(f"⚠️ Модуль '{module_name}' не найден для установки глобальных переменных")
+                return
+            
+            # Устанавливаем глобальные переменные
+            bot_module.supabase_client = self.supabase_client
+            bot_module.openai_client = self.openai_client
+            bot_module.config = self.config
+            bot_module.admin_manager = self.admin_manager
+            bot_module.analytics_manager = self.analytics_manager
+            bot_module.conversation_manager = self.conversation_manager
+            bot_module.prompt_loader = self.prompt_loader
+            
+            logger.info(f"✅ Глобальные переменные установлены в модуле '{module_name}'")
+            
+        except Exception as e:
+            logger.warning(f"⚠️ Не удалось установить глобальные переменные в модуле '{module_name}': {e}")
+    
+    def register_router(self, router):
+        """
+        Регистрирует роутер в менеджере роутеров
+        
+        Args:
+            router: Роутер для регистрации
+        """
+        # Если RouterManager еще не инициализирован, создаем его
+        if not self.router_manager:
+            from ..core.router_manager import RouterManager
+            self.router_manager = RouterManager()
+            logger.info(f"✅ Router Manager создан для регистрации роутера '{router.name}'")
+        
+        self.router_manager.register_router(router)
+        logger.info(f"✅ Роутер '{router.name}' зарегистрирован в боте {self.bot_id}")
+    
+    def get_router_manager(self) -> RouterManager:
+        """Получает менеджер роутеров"""
+        return self.router_manager
+    
     async def start(self):
         """
         Запускает бота (аналог main.py)
@@ -242,6 +316,7 @@ class BotBuilder:
                 handlers_module.openai_client = self.openai_client
                 handlers_module.prompt_loader = self.prompt_loader
                 handlers_module.admin_manager = self.admin_manager
+                handlers_module.analytics_manager = self.analytics_manager
                 handlers_module.conversation_manager = self.conversation_manager
                 logger.info("✅ Глобальные переменные установлены в handlers")
             except Exception as e:
@@ -256,6 +331,7 @@ class BotBuilder:
                 admin_logic_module.openai_client = self.openai_client
                 admin_logic_module.prompt_loader = self.prompt_loader
                 admin_logic_module.admin_manager = self.admin_manager
+                admin_logic_module.analytics_manager = self.analytics_manager
                 admin_logic_module.conversation_manager = self.conversation_manager
                 logger.info("✅ Глобальные переменные установлены в admin_logic")
             except Exception as e:
@@ -271,6 +347,7 @@ class BotBuilder:
                 bot_utils_module.openai_client = self.openai_client
                 bot_utils_module.prompt_loader = self.prompt_loader
                 bot_utils_module.admin_manager = self.admin_manager
+                bot_utils_module.analytics_manager = self.analytics_manager
                 bot_utils_module.conversation_manager = self.conversation_manager
                 logger.info("✅ Глобальные переменные установлены в bot_utils")
             except Exception as e:
@@ -301,6 +378,37 @@ class BotBuilder:
             setup_admin_handlers(dp)    # Админские команды (/админ, /стат, /чат)
             setup_handlers(dp)          # Основные пользовательские обработчики
             
+            # Устанавливаем глобальные переменные в модуле бота для удобного доступа
+            self.set_global_vars_in_module(self.bot_id)
+            
+            # Устанавливаем глобальные переменные в core.globals для внутреннего использования
+            from ..core.globals import set_globals
+            set_globals(
+                supabase_client=self.supabase_client,
+                openai_client=self.openai_client,
+                config=self.config,
+                admin_manager=self.admin_manager,
+                analytics_manager=self.analytics_manager,
+                conversation_manager=self.conversation_manager,
+                prompt_loader=self.prompt_loader,
+                bot=bot,
+                dp=dp
+            )
+            
+            # Устанавливаем клиенты в clients модуль для пользователей
+            from ..clients import set_clients
+            set_clients(
+                supabase=self.supabase_client,
+                openai=self.openai_client
+            )
+            
+            # Устанавливаем роутер-менеджер в декораторы
+            if self.router_manager:
+                from ..core.decorators import set_router_manager
+                set_router_manager(self.router_manager)
+            
+            # Фоновые задачи выполняются через asyncio.create_task в decorators.py
+            
             # Логируем информацию о запуске
             logger.info(f"✅ Бот {self.bot_id} запущен и готов к работе!")
             logger.info(f"   📊 Изоляция данных: bot_id = {self.config.BOT_ID}")
@@ -308,12 +416,12 @@ class BotBuilder:
             logger.info(f"   📝 Загружено промптов: {len(self.config.PROMPT_FILES)}")
             
             # Четкое сообщение о запуске
-            print(f"\nБОТ {self.bot_id.upper()} УСПЕШНО ЗАПУЩЕН!")
-            print(f"Telegram Bot ID: {self.config.BOT_ID}")
-            print(f"Админов: {len(self.config.ADMIN_TELEGRAM_IDS)}")
-            print(f"Промптов: {len(self.config.PROMPT_FILES)}")
-            print(f"Ожидание сообщений...")
-            print(f"Для остановки нажмите Ctrl+C\n")
+            print(f"\n🤖 БОТ {self.bot_id.upper()} УСПЕШНО ЗАПУЩЕН!")
+            print(f"📱 Telegram Bot ID: {self.config.BOT_ID}")
+            print(f"👑 Админов: {len(self.config.ADMIN_TELEGRAM_IDS)}")
+            print(f"📝 Промптов: {len(self.config.PROMPT_FILES)}")
+            print(f"⏳ Ожидание сообщений...")
+            print(f"⏹️ Для остановки нажмите Ctrl+C\n")
             
             # Запуск polling (бесконечная обработка сообщений)
             await dp.start_polling(bot)