smart-bot-factory 0.1.0__py3-none-any.whl

smart_bot_factory/core/bot_builder.py

@@ -0,0 +1,337 @@
+"""
+Строитель ботов для Smart Bot Factory
+"""
+
+import os
+import sys
+import asyncio
+import logging
+from pathlib import Path
+from typing import Optional, Dict, Any, List
+
+from ..integrations import (
+    Config, OpenAIClient, SupabaseClient, 
+    ConversationManager, AdminManager, PromptLoader
+)
+from ..events.decorators import get_handlers_for_prompt
+
+logger = logging.getLogger(__name__)
+
+class BotBuilder:
+    """
+    Строитель ботов, который использует существующие файлы проекта
+    и добавляет новые возможности через декораторы
+    """
+    
+    def __init__(self, bot_id: str, config_dir: Optional[Path] = None):
+        """
+        Инициализация строителя бота
+        
+        Args:
+            bot_id: Идентификатор бота
+            config_dir: Путь к директории конфигурации (по умолчанию configs/bot_id)
+        """
+        self.bot_id = bot_id
+        self.config_dir = config_dir or Path("bots") / bot_id
+        
+        # Компоненты бота
+        self.config: Optional[Config] = None
+        self.openai_client: Optional[OpenAIClient] = None
+        self.supabase_client: Optional[SupabaseClient] = None
+        self.conversation_manager: Optional[ConversationManager] = None
+        self.admin_manager: Optional[AdminManager] = None
+        self.prompt_loader: Optional[PromptLoader] = None
+        
+        # Флаги инициализации
+        self._initialized = False
+        
+        logger.info(f"🏗️ Создан BotBuilder для бота: {bot_id}")
+    
+    async def build(self) -> 'BotBuilder':
+        """
+        Строит и инициализирует все компоненты бота
+        
+        Returns:
+            BotBuilder: Возвращает self для цепочки вызовов
+        """
+        if self._initialized:
+            logger.warning(f"⚠️ Бот {self.bot_id} уже инициализирован")
+            return self
+        
+        try:
+            logger.info(f"🚀 Начинаем сборку бота {self.bot_id}")
+            
+            # 1. Инициализируем конфигурацию
+            await self._init_config()
+            
+            # 2. Инициализируем клиенты
+            await self._init_clients()
+            
+            # 3. Инициализируем менеджеры
+            await self._init_managers()
+            
+            # 4. Обновляем промпты с информацией о доступных инструментах
+            await self._update_prompts_with_tools()
+            
+            self._initialized = True
+            logger.info(f"✅ Бот {self.bot_id} успешно собран и готов к работе")
+            
+            return self
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка при сборке бота {self.bot_id}: {e}")
+            raise
+    
+    async def _init_config(self):
+        """Инициализация конфигурации"""
+        logger.info(f"⚙️ Инициализация конфигурации для {self.bot_id}")
+        
+        # Устанавливаем BOT_ID в переменные окружения
+        os.environ['BOT_ID'] = self.bot_id
+        
+        # Загружаем .env файл если существует
+        env_file = self.config_dir / ".env"
+        if env_file.exists():
+            from dotenv import load_dotenv
+            load_dotenv(env_file)
+            logger.info(f"📄 Загружен .env файл: {env_file}")
+        
+        # Проверяем, установлен ли уже путь к промптам в файле запускалки
+        if "PROMT_FILES_DIR" in os.environ:
+            logger.info(f"📁 Путь к промптам уже установлен: {os.environ['PROMT_FILES_DIR']}")
+        else:
+            # Устанавливаем правильный путь к промптам ПОСЛЕ загрузки .env
+            # Берем значение из .env и добавляем к пути bots/bot-id/
+            prompts_subdir = os.environ.get("PROMT_FILES_DIR", "prompts")
+            logger.info(f"🔍 PROMT_FILES_DIR из .env: {prompts_subdir}")
+            logger.info(f"🔍 config_dir: {self.config_dir}")
+            
+            prompts_dir = self.config_dir / prompts_subdir
+            logger.info(f"🔍 Полный путь к промптам: {prompts_dir}")
+            logger.info(f"🔍 Существует ли папка: {prompts_dir.exists()}")
+            
+            # ВАЖНО: Устанавливаем правильный путь ДО создания Config
+            if prompts_dir.exists():
+                os.environ["PROMT_FILES_DIR"] = str(prompts_dir)
+                logger.info(f"📁 Установлен путь к промптам: {prompts_dir}")
+            else:
+                logger.error(f"❌ Папка с промптами не найдена: {prompts_dir}")
+                # Устанавливаем путь даже если папки нет, чтобы Config не упал
+                os.environ["PROMT_FILES_DIR"] = str(prompts_dir)
+        
+        # Создаем конфигурацию
+        logger.info(f"🔍 PROMT_FILES_DIR перед созданием Config: {os.environ.get('PROMT_FILES_DIR')}")
+        self.config = Config()
+        logger.info(f"✅ Конфигурация инициализирована")
+    
+    async def _init_clients(self):
+        """Инициализация клиентов"""
+        logger.info(f"🔌 Инициализация клиентов для {self.bot_id}")
+        
+        # OpenAI клиент
+        self.openai_client = OpenAIClient(
+            api_key=self.config.OPENAI_API_KEY,
+            model=self.config.OPENAI_MODEL,
+            max_tokens=self.config.OPENAI_MAX_TOKENS,
+            temperature=self.config.OPENAI_TEMPERATURE
+        )
+        logger.info(f"✅ OpenAI клиент инициализирован")
+        
+        # Supabase клиент
+        self.supabase_client = SupabaseClient(
+            url=self.config.SUPABASE_URL,
+            key=self.config.SUPABASE_KEY,
+            bot_id=self.bot_id
+        )
+        await self.supabase_client.initialize()
+        logger.info(f"✅ Supabase клиент инициализирован")
+    
+    async def _init_managers(self):
+        """Инициализация менеджеров"""
+        logger.info(f"👥 Инициализация менеджеров для {self.bot_id}")
+        
+        # Admin Manager
+        self.admin_manager = AdminManager(self.config, self.supabase_client)
+        await self.admin_manager.sync_admins_from_config()
+        logger.info(f"✅ Admin Manager инициализирован")
+        
+        # Conversation Manager
+        self.conversation_manager = ConversationManager(self.supabase_client, self.admin_manager)
+        logger.info(f"✅ Conversation Manager инициализирован")
+        
+        # Prompt Loader
+        self.prompt_loader = PromptLoader(
+            prompts_dir=self.config.PROMT_FILES_DIR,
+            prompt_files=self.config.PROMPT_FILES
+        )
+        await self.prompt_loader.validate_prompts()
+        logger.info(f"✅ Prompt Loader инициализирован")
+    
+    async def _update_prompts_with_tools(self):
+        """
+        Обновляет промпты информацией о доступных обработчиках событий
+        """
+        logger.info(f"🔧 Обновление промптов с информацией об обработчиках")
+        
+        # Получаем информацию о доступных обработчиках
+        event_handlers_info = get_handlers_for_prompt()
+        
+        # Если есть обработчики, добавляем их в системный промпт
+        if event_handlers_info:
+            # Сохраняем информацию о обработчиках для использования в handlers.py
+            self._tools_prompt = event_handlers_info
+            
+            logger.info(f"✅ Промпты обновлены с информацией об обработчиках")
+        else:
+            self._tools_prompt = ""
+            logger.info(f"ℹ️ Нет зарегистрированных обработчиков")
+    
+    def get_tools_prompt(self) -> str:
+        """Возвращает промпт с информацией об инструментах"""
+        return getattr(self, '_tools_prompt', '')
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Возвращает статус бота"""
+        return {
+            "bot_id": self.bot_id,
+            "initialized": self._initialized,
+            "config_dir": str(self.config_dir),
+            "components": {
+                "config": self.config is not None,
+                "openai_client": self.openai_client is not None,
+                "supabase_client": self.supabase_client is not None,
+                "conversation_manager": self.conversation_manager is not None,
+                "admin_manager": self.admin_manager is not None,
+                "prompt_loader": self.prompt_loader is not None
+            },
+            "tools": {
+                "event_handlers": len(get_handlers_for_prompt().split('\n')) if get_handlers_for_prompt() else 0
+            }
+        }
+    
+    async def start(self):
+        """
+        Запускает бота (аналог main.py)
+        """
+        if not self._initialized:
+            raise RuntimeError(f"Бот {self.bot_id} не инициализирован. Вызовите build() сначала")
+        
+        logger.info(f"🚀 Запускаем бота {self.bot_id}")
+        
+        try:
+            # Импортируем необходимые компоненты
+            from aiogram import Bot, Dispatcher
+            from aiogram.fsm.storage.memory import MemoryStorage
+            
+            # Создаем бота и диспетчер
+            bot = Bot(token=self.config.TELEGRAM_BOT_TOKEN)
+            storage = MemoryStorage()
+            dp = Dispatcher(storage=storage)
+            
+            # Инициализируем базу данных
+            await self.supabase_client.initialize()
+            
+            # Синхронизируем админов из конфигурации
+            await self.admin_manager.sync_admins_from_config()
+            
+            # Проверяем доступность промптов
+            prompts_status = await self.prompt_loader.validate_prompts()
+            logger.info(f"Статус промптов: {prompts_status}")
+            
+            # Устанавливаем глобальные переменные ДО импорта обработчиков
+            import sys
+            import importlib
+            
+            # Устанавливаем глобальные переменные в модулях handlers и admin_logic
+            try:
+                handlers_module = importlib.import_module('handlers')
+                handlers_module.config = self.config
+                handlers_module.bot = bot
+                handlers_module.dp = dp
+                handlers_module.supabase_client = self.supabase_client
+                handlers_module.openai_client = self.openai_client
+                handlers_module.prompt_loader = self.prompt_loader
+                handlers_module.admin_manager = self.admin_manager
+                handlers_module.conversation_manager = self.conversation_manager
+                logger.info("✅ Глобальные переменные установлены в handlers")
+            except Exception as e:
+                logger.warning(f"⚠️ Не удалось установить глобальные переменные в handlers: {e}")
+            
+            try:
+                admin_logic_module = importlib.import_module('admin_logic')
+                admin_logic_module.config = self.config
+                admin_logic_module.bot = bot
+                admin_logic_module.dp = dp
+                admin_logic_module.supabase_client = self.supabase_client
+                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.conversation_manager = self.conversation_manager
+                logger.info("✅ Глобальные переменные установлены в admin_logic")
+            except Exception as e:
+                logger.warning(f"⚠️ Не удалось установить глобальные переменные в admin_logic: {e}")
+            
+            # Также устанавливаем в bot_utils
+            try:
+                bot_utils_module = importlib.import_module('bot_utils')
+                bot_utils_module.config = self.config
+                bot_utils_module.bot = bot
+                bot_utils_module.dp = dp
+                bot_utils_module.supabase_client = self.supabase_client
+                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.conversation_manager = self.conversation_manager
+                logger.info("✅ Глобальные переменные установлены в bot_utils")
+            except Exception as e:
+                logger.warning(f"⚠️ Не удалось установить глобальные переменные в bot_utils: {e}")
+            
+            # Также устанавливаем в debug_routing
+            try:
+                debug_routing_module = importlib.import_module('debug_routing')
+                debug_routing_module.config = self.config
+                debug_routing_module.bot = bot
+                debug_routing_module.dp = dp
+                debug_routing_module.supabase_client = self.supabase_client
+                debug_routing_module.openai_client = self.openai_client
+                debug_routing_module.prompt_loader = self.prompt_loader
+                debug_routing_module.admin_manager = self.admin_manager
+                debug_routing_module.conversation_manager = self.conversation_manager
+                logger.info("✅ Глобальные переменные установлены в debug_routing")
+            except Exception as e:
+                logger.warning(f"⚠️ Не удалось установить глобальные переменные в debug_routing: {e}")
+            
+            # Теперь импортируем и настраиваем обработчики
+            from ..integrations import setup_handlers, setup_admin_handlers, setup_utils_handlers
+            
+            # Настраиваем обработчики запросов
+            setup_utils_handlers(dp)    # Утилитарные команды (/status, /help)
+            setup_admin_handlers(dp)    # Админские команды (/админ, /стат, /чат)
+            setup_handlers(dp)          # Основные пользовательские обработчики
+            
+            # Логируем информацию о запуске
+            logger.info(f"✅ Бот {self.bot_id} запущен и готов к работе!")
+            logger.info(f"   📊 Изоляция данных: bot_id = {self.config.BOT_ID}")
+            logger.info(f"   👑 Админов настроено: {len(self.config.ADMIN_TELEGRAM_IDS)}")
+            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")
+            
+            # Запуск polling (бесконечная обработка сообщений)
+            await dp.start_polling(bot)
+            
+        except Exception as e:
+            logger.error(f"❌ Ошибка при запуске бота {self.bot_id}: {e}")
+            import traceback
+            logger.error(f"Стек ошибки: {traceback.format_exc()}")
+            raise
+        finally:
+            # Очистка ресурсов при завершении
+            if 'bot' in locals():
+                await bot.session.close()

smart_bot_factory/events/__init__.py

@@ -0,0 +1,27 @@
+"""
+Система событий для Smart Bot Factory
+"""
+
+from .decorators import (
+    event_handler,
+    schedule_task,
+    get_event_handlers,
+    get_scheduled_tasks,
+    get_handlers_for_prompt,
+    execute_event_handler,
+    execute_scheduled_task,
+    schedule_task_for_later,
+    execute_scheduled_task_from_event
+)
+
+__all__ = [
+    'event_handler',
+    'schedule_task',
+    'get_event_handlers',
+    'get_scheduled_tasks', 
+    'get_handlers_for_prompt',
+    'execute_event_handler',
+    'execute_scheduled_task',
+    'schedule_task_for_later',
+    'execute_scheduled_task_from_event'
+]

smart_bot_factory/events/decorators.py

@@ -0,0 +1,229 @@
+"""
+Декораторы для обработчиков событий и временных задач
+"""
+
+import asyncio
+import logging
+from typing import Callable, Any, Dict, Optional
+from datetime import datetime, timedelta
+from functools import wraps
+
+logger = logging.getLogger(__name__)
+
+# Глобальный реестр обработчиков событий
+_event_handlers: Dict[str, Callable] = {}
+_scheduled_tasks: Dict[str, Dict[str, Any]] = {}
+
+def event_handler(event_type: str, description: str = ""):
+    """
+    Декоратор для регистрации обработчика события
+    
+    Args:
+        event_type: Тип события (например, 'appointment_booking', 'phone_collection')
+        description: Описание что делает обработчик (для добавления в промпт)
+    
+    Example:
+        @event_handler("appointment_booking", "Записывает пользователя на прием")
+        async def book_appointment(user_id: int, appointment_data: dict):
+            # Логика записи на прием
+            return {"status": "success", "appointment_id": "123"}
+    """
+    def decorator(func: Callable) -> Callable:
+        _event_handlers[event_type] = {
+            'handler': func,
+            'description': description,
+            'name': func.__name__
+        }
+        
+        logger.info(f"📝 Зарегистрирован обработчик события '{event_type}': {func.__name__}")
+        
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            try:
+                logger.info(f"🔧 Выполняем обработчик события '{event_type}'")
+                result = await func(*args, **kwargs)
+                logger.info(f"✅ Обработчик '{event_type}' выполнен успешно")
+                return result
+            except Exception as e:
+                logger.error(f"❌ Ошибка в обработчике '{event_type}': {e}")
+                raise
+        
+        return wrapper
+    return decorator
+
+def schedule_task(task_name: str, description: str = ""):
+    """
+    Декоратор для регистрации задачи, которую можно запланировать на время
+    
+    Args:
+        task_name: Название задачи (например, 'send_reminder', 'follow_up')
+        description: Описание задачи (для добавления в промпт)
+    
+    Example:
+        @schedule_task("send_reminder", "Отправляет напоминание пользователю")
+        async def send_reminder(user_id: int, message: str):
+            # Логика отправки напоминания
+            return {"status": "sent"}
+    """
+    def decorator(func: Callable) -> Callable:
+        _scheduled_tasks[task_name] = {
+            'handler': func,
+            'description': description,
+            'name': func.__name__
+        }
+        
+        logger.info(f"⏰ Зарегистрирована задача '{task_name}': {func.__name__}")
+        
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            try:
+                logger.info(f"⏰ Выполняем запланированную задачу '{task_name}'")
+                result = await func(*args, **kwargs)
+                logger.info(f"✅ Задача '{task_name}' выполнена успешно")
+                return result
+            except Exception as e:
+                logger.error(f"❌ Ошибка в задаче '{task_name}': {e}")
+                raise
+        
+        return wrapper
+    return decorator
+
+def get_event_handlers() -> Dict[str, Dict[str, Any]]:
+    """Возвращает все зарегистрированные обработчики событий"""
+    return _event_handlers.copy()
+
+def get_scheduled_tasks() -> Dict[str, Dict[str, Any]]:
+    """Возвращает все зарегистрированные задачи"""
+    return _scheduled_tasks.copy()
+
+def get_handlers_for_prompt() -> str:
+    """
+    Возвращает описание всех обработчиков для добавления в промпт
+    """
+    if not _event_handlers and not _scheduled_tasks:
+        return ""
+    
+    prompt_parts = []
+    
+    if _event_handlers:
+        prompt_parts.append("ДОСТУПНЫЕ ОБРАБОТЧИКИ СОБЫТИЙ:")
+        for event_type, handler_info in _event_handlers.items():
+            prompt_parts.append(f"- {event_type}: {handler_info['description']}")
+    
+    if _scheduled_tasks:
+        prompt_parts.append("\nДОСТУПНЫЕ ЗАДАЧИ ДЛЯ ПЛАНИРОВАНИЯ:")
+        for task_name, task_info in _scheduled_tasks.items():
+            prompt_parts.append(f"- {task_name}: {task_info['description']}")
+    
+    return "\n".join(prompt_parts)
+
+async def execute_event_handler(event_type: str, *args, **kwargs) -> Any:
+    """Выполняет обработчик события по типу"""
+    if event_type not in _event_handlers:
+        raise ValueError(f"Обработчик события '{event_type}' не найден")
+    
+    handler_info = _event_handlers[event_type]
+    return await handler_info['handler'](*args, **kwargs)
+
+async def execute_scheduled_task(task_name: str, *args, **kwargs) -> Any:
+    """Выполняет запланированную задачу по имени"""
+    if task_name not in _scheduled_tasks:
+        raise ValueError(f"Задача '{task_name}' не найдена")
+    
+    task_info = _scheduled_tasks[task_name]
+    return await task_info['handler'](*args, **kwargs)
+
+async def schedule_task_for_later(task_name: str, delay_seconds: int, *args, **kwargs):
+    """
+    Планирует выполнение задачи через указанное время
+    
+    Args:
+        task_name: Название задачи
+        delay_seconds: Задержка в секундах
+        *args, **kwargs: Аргументы для задачи
+    """
+    if task_name not in _scheduled_tasks:
+        raise ValueError(f"Задача '{task_name}' не найдена")
+    
+    logger.info(f"⏰ Планируем задачу '{task_name}' через {delay_seconds} секунд")
+    
+    async def delayed_task():
+        await asyncio.sleep(delay_seconds)
+        await execute_scheduled_task(task_name, *args, **kwargs)
+    
+    # Запускаем задачу в фоне
+    asyncio.create_task(delayed_task())
+    
+    return {
+        "status": "scheduled",
+        "task_name": task_name,
+        "delay_seconds": delay_seconds,
+        "scheduled_at": datetime.now().isoformat()
+    }
+
+async def execute_scheduled_task_from_event(user_id: int, task_name: str, event_info: str):
+    """
+    Выполняет запланированную задачу на основе события от ИИ
+    
+    Args:
+        user_id: ID пользователя
+        task_name: Название задачи
+        event_info: Информация от ИИ (содержит время и сообщение)
+    """
+    if task_name not in _scheduled_tasks:
+        raise ValueError(f"Задача '{task_name}' не найдена")
+    
+    # Парсим event_info для извлечения времени и сообщения
+    # Формат: "через 2 часа: напомнить о приеме"
+    try:
+        if ":" in event_info:
+            time_part, message = event_info.split(":", 1)
+            time_part = time_part.strip()
+            message = message.strip()
+        else:
+            time_part = event_info
+            message = "Напоминание"
+        
+        # Парсим время
+        delay_seconds = _parse_time_to_seconds(time_part)
+        
+        # Планируем задачу
+        result = await schedule_task_for_later(task_name, delay_seconds, user_id, message)
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Ошибка парсинга времени из event_info '{event_info}': {e}")
+        # Fallback - планируем через 1 час
+        return await schedule_task_for_later(task_name, 3600, user_id, event_info)
+
+def _parse_time_to_seconds(time_str: str) -> int:
+    """
+    Парсит строку времени в секунды
+    Поддерживает форматы:
+    - "через 2 часа"
+    - "через 30 минут" 
+    - "через 1 день"
+    - "через 2 часа 30 минут"
+    """
+    import re
+    
+    time_str = time_str.lower().strip()
+    
+    # Ищем часы
+    hours_match = re.search(r'(\d+)\s*час', time_str)
+    hours = int(hours_match.group(1)) if hours_match else 0
+    
+    # Ищем минуты
+    minutes_match = re.search(r'(\d+)\s*минут', time_str)
+    minutes = int(minutes_match.group(1)) if minutes_match else 0
+    
+    # Ищем дни
+    days_match = re.search(r'(\d+)\s*дн', time_str)
+    days = int(days_match.group(1)) if days_match else 0
+    
+    # Конвертируем в секунды
+    total_seconds = (days * 24 * 3600) + (hours * 3600) + (minutes * 60)
+    
+    # Минимум 1 минута
+    return max(total_seconds, 60)

smart_bot_factory/integrations/__init__.py

@@ -0,0 +1,83 @@
+"""
+Интеграции с существующими файлами проекта
+"""
+
+# Импортируем существующие классы из корня проекта
+import sys
+from pathlib import Path
+
+# Добавляем корень проекта в путь для импорта существующих файлов
+project_root = Path(__file__).parent.parent.parent.parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+try:
+    from openai_client import OpenAIClient
+    from supabase_client import SupabaseClient
+    from config import Config
+    from conversation_manager import ConversationManager
+    from admin_manager import AdminManager
+    from prompt_loader import PromptLoader
+    from bot_utils import send_message, parse_ai_response, process_events
+    from handlers import router, setup_handlers
+    from admin_logic import setup_admin_handlers
+    from bot_utils import setup_utils_handlers
+except ImportError as e:
+    # Если файлы не найдены, создаем заглушки
+    print(f"⚠️ Предупреждение: не удалось импортировать существующие файлы: {e}")
+    
+    class OpenAIClient:
+        def __init__(self, *args, **kwargs):
+            raise NotImplementedError("OpenAIClient не найден. Убедитесь, что openai_client.py существует в корне проекта")
+    
+    class SupabaseClient:
+        def __init__(self, *args, **kwargs):
+            raise NotImplementedError("SupabaseClient не найден. Убедитесь, что supabase_client.py существует в корне проекта")
+    
+    class Config:
+        def __init__(self, *args, **kwargs):
+            raise NotImplementedError("Config не найден. Убедитесь, что config.py существует в корне проекта")
+    
+    class ConversationManager:
+        def __init__(self, *args, **kwargs):
+            raise NotImplementedError("ConversationManager не найден. Убедитесь, что conversation_manager.py существует в корне проекта")
+    
+    class AdminManager:
+        def __init__(self, *args, **kwargs):
+            raise NotImplementedError("AdminManager не найден. Убедитесь, что admin_manager.py существует в корне проекта")
+    
+    class PromptLoader:
+        def __init__(self, *args, **kwargs):
+            raise NotImplementedError("PromptLoader не найден. Убедитесь, что prompt_loader.py существует в корне проекта")
+    
+    # Заглушки для функций
+    def send_message(*args, **kwargs):
+        raise NotImplementedError("send_message не найден. Убедитесь, что bot_utils.py существует в корне проекта")
+    
+    def parse_ai_response(*args, **kwargs):
+        raise NotImplementedError("parse_ai_response не найден. Убедитесь, что bot_utils.py существует в корне проекта")
+    
+    def process_events(*args, **kwargs):
+        raise NotImplementedError("process_events не найден. Убедитесь, что bot_utils.py существует в корне проекта")
+    
+    # Заглушки для роутера
+    router = None
+    setup_handlers = None
+    setup_admin_handlers = None
+    setup_utils_handlers = None
+
+__all__ = [
+    'OpenAIClient',
+    'SupabaseClient', 
+    'Config',
+    'ConversationManager',
+    'AdminManager',
+    'PromptLoader',
+    'send_message',
+    'parse_ai_response', 
+    'process_events',
+    'router',
+    'setup_handlers',
+    'setup_admin_handlers',
+    'setup_utils_handlers'
+]