smart-bot-factory 0.1.9__py3-none-any.whl → 0.2.1__py3-none-any.whl

smart_bot_factory/core/router.py

@@ -1,5 +1,5 @@
 """
-Роутер для Smart Bot Factory - аналог aiogram Router
+EventRouter для Smart Bot Factory - роутер для событий, задач и глобальных обработчиков
 """
 
 from typing import Dict, Any, Callable, Union
@@ -7,7 +7,7 @@ import logging
 
 logger = logging.getLogger(__name__)
 
-class Router:
+class EventRouter:
     """
     Роутер для организации обработчиков событий, задач и глобальных обработчиков
     """
@@ -19,7 +19,7 @@ class Router:
         Args:
             name: Имя роутера для логирования
         """
-        self.name = name or f"Router_{id(self)}"
+        self.name = name or f"EventRouter_{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]] = {}
@@ -183,12 +183,12 @@ class Router:
         all_handlers.update(self._global_handlers)
         return all_handlers
     
-    def include_router(self, router: 'Router'):
+    def include_router(self, router: 'EventRouter'):
         """
         Включает другой роутер в текущий
         
         Args:
-            router: Роутер для включения
+            router: EventRouter для включения
         """
         # Добавляем обработчики событий
         for event_type, handler_info in router.get_event_handlers().items():
@@ -211,4 +211,4 @@ class Router:
         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)})"
+        return f"EventRouter(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

@@ -4,17 +4,17 @@
 
 from typing import Dict, List, Any, Optional
 import logging
-from .router import Router
+from .router import EventRouter
 
 logger = logging.getLogger(__name__)
 
 class RouterManager:
     """
-    Менеджер для управления роутерами и их обработчиками
+    Менеджер для управления роутерами событий и их обработчиками
     """
     
     def __init__(self):
-        self._routers: List[Router] = []
+        self._routers: List[EventRouter] = []
         self._combined_handlers: Dict[str, Dict[str, Any]] = {
             'event_handlers': {},
             'scheduled_tasks': {},
@@ -23,12 +23,12 @@ class RouterManager:
         
         logger.info("🔄 Создан менеджер роутеров")
     
-    def register_router(self, router: Router):
+    def register_router(self, router: EventRouter):
         """
-        Регистрирует роутер в менеджере
+        Регистрирует роутер событий в менеджере
         
         Args:
-            router: Роутер для регистрации
+            router: EventRouter для регистрации
         """
         if router not in self._routers:
             self._routers.append(router)
@@ -37,12 +37,12 @@ class RouterManager:
         else:
             logger.warning(f"⚠️ Роутер {router.name} уже зарегистрирован")
     
-    def unregister_router(self, router: Router):
+    def unregister_router(self, router: EventRouter):
         """
-        Отменяет регистрацию роутера
+        Отменяет регистрацию роутера событий
         
         Args:
-            router: Роутер для отмены регистрации
+            router: EventRouter для отмены регистрации
         """
         if router in self._routers:
             self._routers.remove(router)
@@ -150,8 +150,8 @@ class RouterManager:
         
         return "\n".join(prompt_parts)
     
-    def get_router_by_name(self, name: str) -> Optional[Router]:
-        """Получает роутер по имени"""
+    def get_router_by_name(self, name: str) -> Optional[EventRouter]:
+        """Получает роутер событий по имени"""
         for router in self._routers:
             if router.name == name:
                 return router

smart_bot_factory/core/telegram_router.py

@@ -0,0 +1,58 @@
+"""
+TelegramRouter - обертка над aiogram Router для обработки Telegram сообщений
+"""
+
+from typing import Any
+import logging
+from aiogram import Router as AiogramRouter
+
+logger = logging.getLogger(__name__)
+
+
+class TelegramRouter:
+    """
+    Обертка над aiogram Router для единообразного API библиотеки
+    Позволяет регистрировать обработчики команд, сообщений и callback'ов
+    """
+    
+    def __init__(self, name: str = None):
+        """
+        Инициализация Telegram роутера
+        
+        Args:
+            name: Имя роутера для логирования
+        """
+        self.name = name or f"TelegramRouter_{id(self)}"
+        self._router = AiogramRouter(name=self.name)
+        
+        logger.info(f"📱 Создан TelegramRouter: {self.name}")
+    
+    @property
+    def router(self) -> AiogramRouter:
+        """
+        Возвращает внутренний aiogram Router
+        
+        Используйте этот роутер для прямой работы с aiogram API:
+        
+        Example:
+            telegram_router = TelegramRouter("my_router")
+            
+            # Регистрация команды
+            @telegram_router.router.message(Command("start"))
+            async def start_handler(message: Message):
+                await message.answer("Hello!")
+            
+            # Регистрация callback
+            @telegram_router.router.callback_query(F.data.startswith("buy_"))
+            async def buy_handler(callback: CallbackQuery):
+                await callback.answer("Покупка...")
+        """
+        return self._router
+    
+    def get_aiogram_router(self) -> AiogramRouter:
+        """Получает внутренний aiogram Router (алиас для .router)"""
+        return self._router
+    
+    def __repr__(self):
+        return f"TelegramRouter(name='{self.name}')"
+

smart_bot_factory/creation/bot_builder.py

@@ -5,7 +5,7 @@
 import os
 import logging
 from pathlib import Path
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
 
 from ..config import Config
 from ..integrations.openai_client import OpenAIClient
@@ -45,6 +45,8 @@ class BotBuilder:
         self.analytics_manager: Optional[AnalyticsManager] = None
         self.prompt_loader: Optional[PromptLoader] = None
         self.router_manager: Optional[RouterManager] = None
+        self._telegram_routers: List = []  # Список Telegram роутеров
+        self._start_handlers: List = []  # Список обработчиков on_start
         
         # Флаги инициализации
         self._initialized = False
@@ -258,10 +260,10 @@ class BotBuilder:
     
     def register_router(self, router):
         """
-        Регистрирует роутер в менеджере роутеров
+        Регистрирует роутер событий в менеджере роутеров
         
         Args:
-            router: Роутер для регистрации
+            router: EventRouter для регистрации
         """
         # Если RouterManager еще не инициализирован, создаем его
         if not self.router_manager:
@@ -270,10 +272,94 @@ class BotBuilder:
             logger.info(f"✅ Router Manager создан для регистрации роутера '{router.name}'")
         
         self.router_manager.register_router(router)
-        logger.info(f"✅ Роутер '{router.name}' зарегистрирован в боте {self.bot_id}")
+        logger.info(f"✅ Роутер событий '{router.name}' зарегистрирован в боте {self.bot_id}")
+    
+    def register_routers(self, *event_routers):
+        """
+        Регистрирует несколько роутеров событий одновременно
+        
+        Args:
+            *event_routers: Произвольное количество EventRouter
+            
+        Example:
+            bot_builder.register_routers(event_router1, event_router2, event_router3)
+        """
+        if not event_routers:
+            logger.warning("⚠️ register_routers вызван без аргументов")
+            return
+        
+        for router in event_routers:
+            self.register_router(router)
+        
+        logger.info(f"✅ Зарегистрировано {len(event_routers)} роутеров событий")
+    
+    def register_telegram_router(self, telegram_router):
+        """
+        Регистрирует Telegram роутер для обработки команд и сообщений
+        
+        Args:
+            telegram_router: TelegramRouter для регистрации
+        """
+        from ..core.telegram_router import TelegramRouter
+        
+        if not isinstance(telegram_router, TelegramRouter):
+            raise TypeError(f"Ожидается TelegramRouter, получен {type(telegram_router)}")
+        
+        self._telegram_routers.append(telegram_router)
+        logger.info(f"✅ Telegram роутер '{telegram_router.name}' зарегистрирован в боте {self.bot_id}")
+    
+    def register_telegram_routers(self, *telegram_routers):
+        """
+        Регистрирует несколько Telegram роутеров одновременно
+        
+        Args:
+            *telegram_routers: Произвольное количество TelegramRouter
+            
+        Example:
+            bot_builder.register_telegram_routers(telegram_router1, telegram_router2)
+        """
+        if not telegram_routers:
+            logger.warning("⚠️ register_telegram_routers вызван без аргументов")
+            return
+        
+        for router in telegram_routers:
+            self.register_telegram_router(router)
+        
+        logger.info(f"✅ Зарегистрировано {len(telegram_routers)} Telegram роутеров")
+    
+    def on_start(self, handler):
+        """
+        Регистрирует обработчик, который вызывается после стандартной логики /start
+        
+        Обработчик получает доступ к:
+        - user_id: int - ID пользователя Telegram
+        - session_id: str - ID созданной сессии
+        - message: Message - Объект сообщения от aiogram
+        - state: FSMContext - Контекст состояния
+        
+        Args:
+            handler: Async функция с сигнатурой:
+                     async def handler(user_id: int, session_id: str, message: Message, state: FSMContext)
+        
+        Example:
+            @bot_builder.on_start
+            async def my_start_handler(user_id, session_id, message, state):
+                keyboard = InlineKeyboardMarkup(...)
+                await message.answer("Выберите действие:", reply_markup=keyboard)
+        """
+        if not callable(handler):
+            raise TypeError(f"Обработчик должен быть callable, получен {type(handler)}")
+        
+        self._start_handlers.append(handler)
+        logger.info(f"✅ Зарегистрирован обработчик on_start: {handler.__name__}")
+        return handler  # Возвращаем handler для использования как декоратор
+    
+    def get_start_handlers(self) -> List:
+        """Получает список обработчиков on_start"""
+        return self._start_handlers.copy()
     
     def get_router_manager(self) -> RouterManager:
-        """Получает менеджер роутеров"""
+        """Получает менеджер роутеров событий"""
         return self.router_manager
     
     async def start(self):
@@ -320,6 +406,7 @@ class BotBuilder:
                 handlers_module.admin_manager = self.admin_manager
                 handlers_module.analytics_manager = self.analytics_manager
                 handlers_module.conversation_manager = self.conversation_manager
+                handlers_module.start_handlers = self._start_handlers  # Передаем обработчики on_start
                 logger.info("✅ Глобальные переменные установлены в handlers")
             except Exception as e:
                 logger.warning(f"⚠️ Не удалось установить глобальные переменные в handlers: {e}")
@@ -375,7 +462,14 @@ class BotBuilder:
             from ..admin.admin_logic import setup_admin_handlers
             from ..core.bot_utils import setup_utils_handlers
             
-            # Настраиваем обработчики запросов
+            # Подключаем пользовательские Telegram роутеры ПЕРВЫМИ (высший приоритет)
+            if self._telegram_routers:
+                logger.info(f"🔗 Подключаем {len(self._telegram_routers)} пользовательских Telegram роутеров")
+                for telegram_router in self._telegram_routers:
+                    dp.include_router(telegram_router.get_aiogram_router())
+                    logger.info(f"✅ Подключен Telegram роутер: {telegram_router.name}")
+            
+            # Настраиваем стандартные обработчики (меньший приоритет)
             setup_utils_handlers(dp)    # Утилитарные команды (/status, /help)
             setup_admin_handlers(dp)    # Админские команды (/админ, /стат, /чат)
             setup_handlers(dp)          # Основные пользовательские обработчики

smart_bot_factory/handlers/handlers.py

@@ -277,6 +277,23 @@ async def user_start_handler(message: Message, state: FSMContext):
         
         logging.info(f"✅ Приветственное сообщение успешно сохранено в БД для сессии {session_id}")
         
+        # ВЫЗЫВАЕМ ПОЛЬЗОВАТЕЛЬСКИЕ ОБРАБОТЧИКИ on_start
+        start_handlers = get_global_var('start_handlers')
+        if start_handlers:
+            logger.info(f"🔔 Вызов {len(start_handlers)} пользовательских обработчиков on_start")
+            for handler in start_handlers:
+                try:
+                    await handler(
+                        user_id=message.from_user.id,
+                        session_id=session_id,
+                        message=message,
+                        state=state
+                    )
+                    logger.info(f"✅ Обработчик on_start '{handler.__name__}' выполнен успешно")
+                except Exception as handler_error:
+                    logger.error(f"❌ Ошибка в обработчике on_start '{handler.__name__}': {handler_error}")
+                    # Продолжаем выполнение остальных обработчиков
+        
     except Exception as e:
         logger.error(f"Ошибка при обработке user /start: {e}")
         await send_message(message, "Произошла ошибка при инициализации. Попробуйте позже.")

smart_bot_factory/router/__init__.py

@@ -2,8 +2,10 @@
 Router модули smart_bot_factory
 """
 
-from ..core.router import Router
+from ..core.router import EventRouter
+from ..core.telegram_router import TelegramRouter
 
 __all__ = [
-    'Router'
+    'EventRouter',  # Роутер для событий
+    'TelegramRouter',  # Роутер для Telegram
 ]

{smart_bot_factory-0.1.9.dist-info → smart_bot_factory-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-bot-factory
-Version: 0.1.9
+Version: 0.2.1
 Summary: Библиотека для создания умных чат-ботов
 Author-email: Kopatych <kopatych@example.com>
 License: MIT
@@ -163,18 +163,24 @@ sbf run my-bot
 
 ### Router System
 
-Smart Bot Factory использует систему роутеров для организации обработчиков:
+Smart Bot Factory использует **два типа роутеров** для организации обработчиков:
+
+1. **EventRouter** - для бизнес-логики (события, задачи, глобальные обработчики)
+2. **TelegramRouter** - для Telegram команд, сообщений и callback'ов
 
 ```python
-from smart_bot_factory.router import Router
+from smart_bot_factory.router import EventRouter, TelegramRouter
 from smart_bot_factory.message import send_message_by_human
 from smart_bot_factory.creation import BotBuilder
+from aiogram import F
+from aiogram.filters import Command
+from aiogram.types import Message
+from aiogram.fsm.context import FSMContext
 
-# Создаем роутер
-router = Router("my_bot_handlers")
+# EventRouter - для бизнес-логики
+event_router = EventRouter("my_bot_events")
 
-# Регистрируем обработчики
-@router.event_handler("appointment_booking", notify=True)
+@event_router.event_handler("appointment_booking", notify=True)
 async def handle_booking(user_id: int, event_data: str):
     """Обработчик записи на прием"""
     await send_message_by_human(
@@ -183,15 +189,114 @@ async def handle_booking(user_id: int, event_data: str):
     )
     return {"status": "success"}
 
+# TelegramRouter - для Telegram команд и сообщений
+telegram_router = TelegramRouter("my_bot_telegram")
+
+@telegram_router.router.message(Command("price", "цена"))
+async def handle_price(message: Message, state: FSMContext):
+    """Обработчик команды /price"""
+    await message.answer("💰 Наши цены...")
+
+@telegram_router.router.message(F.text.contains("помощь"))
+async def handle_help(message: Message, state: FSMContext):
+    """Обработчик запросов помощи"""
+    await message.answer("📖 Чем могу помочь?")
+
 # Запуск бота
 async def main():
     bot = BotBuilder("my-bot")
-    bot.register_router(router)
+    
+    # Регистрируем роутеры (можно по одному или несколько сразу)
+    bot.register_routers(event_router)  # EventRouter
+    bot.register_telegram_routers(telegram_router)  # TelegramRouter
+    
     await bot.build()
     await bot.start()
 ```
 
-### Типы обработчиков
+### TelegramRouter - Обработчики Telegram
+
+**TelegramRouter** позволяет добавлять пользовательские команды и обработчики сообщений в Telegram бота, используя стандартный aiogram API:
+
+#### Команды
+
+```python
+from smart_bot_factory.router import TelegramRouter
+from aiogram.filters import Command
+from aiogram.types import Message
+from aiogram.fsm.context import FSMContext
+
+telegram_router = TelegramRouter("my_commands")
+
+@telegram_router.router.message(Command("start", "старт"))
+async def cmd_start(message: Message, state: FSMContext):
+    """Обработчик команды /start"""
+    await message.answer("👋 Привет!")
+
+@telegram_router.router.message(Command("price"))
+async def cmd_price(message: Message, state: FSMContext):
+    """Обработчик команды /price"""
+    await message.answer("💰 Цены:\n1. Базовый - 1000₽\n2. Премиум - 5000₽")
+```
+
+#### Фильтры по тексту
+
+```python
+from aiogram import F
+
+@telegram_router.router.message(F.text.lower().contains("цена"))
+async def handle_price_question(message: Message, state: FSMContext):
+    """Когда пользователь спрашивает о цене"""
+    await message.answer("💡 Используйте /price для просмотра цен")
+
+@telegram_router.router.message(F.text.startswith("!"))
+async def handle_commands(message: Message, state: FSMContext):
+    """Обработка кастомных команд с !"""
+    command = message.text[1:]
+    await message.answer(f"Выполняю команду: {command}")
+```
+
+#### Callback Query
+
+```python
+from aiogram.types import CallbackQuery, InlineKeyboardMarkup, InlineKeyboardButton
+
+@telegram_router.router.callback_query(F.data.startswith("buy_"))
+async def handle_buy(callback: CallbackQuery, state: FSMContext):
+    """Обработка покупки"""
+    product_id = callback.data.split("_")[1]
+    await callback.answer("Оформляем...")
+    await callback.message.answer(f"✅ Товар {product_id} добавлен в корзину")
+
+@telegram_router.router.message(Command("catalog"))
+async def show_catalog(message: Message, state: FSMContext):
+    """Показывает каталог с кнопками"""
+    keyboard = InlineKeyboardMarkup(inline_keyboard=[
+        [InlineKeyboardButton(text="Купить товар 1", callback_data="buy_1")],
+        [InlineKeyboardButton(text="Купить товар 2", callback_data="buy_2")]
+    ])
+    await message.answer("🛍️ Каталог товаров:", reply_markup=keyboard)
+```
+
+#### Регистрация нескольких роутеров
+
+```python
+# Создаем несколько TelegramRouter для разных модулей
+commands_router = TelegramRouter("commands")
+admin_router = TelegramRouter("admin_commands")
+callbacks_router = TelegramRouter("callbacks")
+
+# Регистрируем все сразу
+bot_builder.register_telegram_routers(
+    commands_router,
+    admin_router,
+    callbacks_router
+)
+```
+
+**Важно:** TelegramRouter - это обертка над aiogram Router, предоставляющая доступ к полному функционалу aiogram через свойство `.router`.
+
+### EventRouter - Типы обработчиков событий
 
 #### 1. Event Handlers - Обработчики событий
 
@@ -423,24 +528,81 @@ ADMIN_SESSION_TIMEOUT_MINUTES=30
 
 ### Множественные роутеры
 
+#### Регистрация нескольких EventRouter
+
 ```python
 # handlers/main.py
-main_router = Router("main")
+main_router = EventRouter("main")
 
 # handlers/admin.py
-admin_router = Router("admin")
+admin_router = EventRouter("admin")
+
+# handlers/payments.py
+payments_router = EventRouter("payments")
 
 # app.py
 bot = BotBuilder("my-bot")
+
+# Можно по одному
 bot.register_router(main_router)
 bot.register_router(admin_router)
+
+# Или все сразу
+bot.register_routers(main_router, admin_router, payments_router)
 ```
 
-### Вложенные роутеры
+#### Регистрация нескольких TelegramRouter
 
 ```python
-main_router = Router("main")
-payments_router = Router("payments")
+# telegram/commands.py
+commands_router = TelegramRouter("commands")
+
+@commands_router.router.message(Command("start"))
+async def start(message: Message, state: FSMContext):
+    await message.answer("Привет!")
+
+# telegram/callbacks.py
+callbacks_router = TelegramRouter("callbacks")
+
+@callbacks_router.router.callback_query(F.data.startswith("action_"))
+async def handle_action(callback: CallbackQuery, state: FSMContext):
+    await callback.answer("Выполнено!")
+
+# app.py
+bot = BotBuilder("my-bot")
+
+# Регистрируем несколько Telegram роутеров сразу
+bot.register_telegram_routers(commands_router, callbacks_router)
+```
+
+#### Комбинирование EventRouter и TelegramRouter
+
+```python
+# Создаем роутеры для разных целей
+event_router = EventRouter("events")
+telegram_router = TelegramRouter("telegram_handlers")
+
+# EventRouter - бизнес-логика
+@event_router.event_handler("payment_success")
+async def handle_payment(user_id: int, event_data: str):
+    await send_message_by_human(user_id, "✅ Оплата получена!")
+    return {"status": "success"}
+
+# TelegramRouter - пользовательские команды
+@telegram_router.router.message(Command("balance"))
+async def check_balance(message: Message, state: FSMContext):
+    await message.answer("💰 Ваш баланс: 1000₽")
+
+# Регистрируем оба типа роутеров
+bot_builder.register_routers(event_router)
+bot_builder.register_telegram_routers(telegram_router)
+```
+
+### Вложенные роутеры (EventRouter)
+
+```python
+main_router = EventRouter("main")
+payments_router = EventRouter("payments")
 
 # Включаем роутер платежей в основной
 main_router.include_router(payments_router)
@@ -486,17 +648,38 @@ my-project/
 ```python
 import asyncio
 
-from smart_bot_factory.router import Router
+from smart_bot_factory.router import EventRouter, TelegramRouter
 from smart_bot_factory.message import send_message_by_human, send_message_to_users_by_stage
 from smart_bot_factory.supabase import SupabaseClient
 from smart_bot_factory.creation import BotBuilder
+from aiogram import F
+from aiogram.filters import Command
+from aiogram.types import Message
+from aiogram.fsm.context import FSMContext
 
 # Инициализация
-router = Router("medical_bot")
+event_router = EventRouter("medical_bot_events")
+telegram_router = TelegramRouter("medical_bot_telegram")
 supabase_client = SupabaseClient("medical-bot")
 
-# Обработчик записи на прием
-@router.event_handler("appointment_booking", notify=True)
+# Пользовательские команды (TelegramRouter)
+@telegram_router.router.message(Command("appointment", "запись"))
+async def cmd_appointment(message: Message, state: FSMContext):
+    """Команда для записи на прием"""
+    await message.answer(
+        "📅 Для записи на прием укажите:\n"
+        "- Ваше имя\n"
+        "- Телефон\n"
+        "- Желаемая дата и время"
+    )
+
+@telegram_router.router.message(F.text.lower().contains("цена"))
+async def handle_price_question(message: Message, state: FSMContext):
+    """Вопросы о ценах"""
+    await message.answer("💰 Используйте /appointment для записи и уточнения стоимости")
+
+# Обработчик записи на прием (EventRouter)
+@event_router.event_handler("appointment_booking", notify=True)
 async def handle_appointment(user_id: int, event_data: str):
     """Обрабатывает запись на прием к врачу"""
     # event_data: "имя: Иван, телефон: +79991234567, дата: 2025-10-15, время: 14:00"
@@ -508,8 +691,8 @@ async def handle_appointment(user_id: int, event_data: str):
     
     return {"status": "success", "data": event_data}
 
-# Напоминание за 2 часа до приема
-@router.schedule_task(
+# Напоминание за 2 часа до приема (EventRouter)
+@event_router.schedule_task(
     "appointment_reminder",
     delay="2h",
     event_type="appointment_booking"
@@ -522,8 +705,8 @@ async def remind_before_appointment(user_id: int, reminder_text: str):
     )
     return {"status": "sent"}
 
-# Ночной дайджест для всех
-@router.global_handler("daily_digest", delay="24h")
+# Ночной дайджест для всех (EventRouter)
+@event_router.global_handler("daily_digest", delay="24h")
 async def send_daily_digest(digest_text: str):
     """Отправляет ежедневный дайджест всем активным пользователям"""
     await send_message_to_users_by_stage(
@@ -535,7 +718,11 @@ async def send_daily_digest(digest_text: str):
 # Запуск
 async def main():
     bot = BotBuilder("medical-bot")
-    bot.register_router(router)
+    
+    # Регистрируем роутеры
+    bot.register_routers(event_router)  # EventRouter
+    bot.register_telegram_routers(telegram_router)  # TelegramRouter
+    
     await bot.build()
     await bot.start()
 

{smart_bot_factory-0.1.9.dist-info → smart_bot_factory-0.2.1.dist-info}/RECORD

@@ -28,27 +28,28 @@ smart_bot_factory/core/bot_utils.py,sha256=XmwQ31LOpE_Wudx4OO4tlnVwse3YagakwpgN2
 smart_bot_factory/core/conversation_manager.py,sha256=eoHL7MCEz68DRvTVwRwZgf2PWwGv4T6J9D-I-thETi8,28289
 smart_bot_factory/core/decorators.py,sha256=xQCtr5SOLqqmEzaxrDf_sfxWQouIG7riI6Sa_jqGlcg,68647
 smart_bot_factory/core/message_sender.py,sha256=7uZlMw7bdLb_2eokANUxyP4HomVQV7T2mrl4SBTfqNM,19134
-smart_bot_factory/core/router.py,sha256=Ly2Kj6T9stu2UmE__3CvMvN8Rl1Ipo-SrsbTsiPSssA,11469
-smart_bot_factory/core/router_manager.py,sha256=qncd57qhqXBV42FBEQ8Wl7aar8S7WZnfSC4EQ1BIr0w,9617
+smart_bot_factory/core/router.py,sha256=o-AzLarBgYbXq7OeeXQEfa6XFqcAtLKqf5-3Do79Boo,11555
+smart_bot_factory/core/router_manager.py,sha256=dUwesog-oHk1U2EDdS8p0e4MTSkwtx5_qXn6nrJ9l9I,9700
 smart_bot_factory/core/states.py,sha256=AOc19_yAsDW_8md-2oiowjBhuW3bwcsmMxszCXWZZTQ,355
+smart_bot_factory/core/telegram_router.py,sha256=LcPLOd87Y4Y4YN6TBXVAtmpSp8gAK2otgMI4YS5f5tk,2091
 smart_bot_factory/creation/__init__.py,sha256=IgDk8GDS3pg7Pw_Et41J33ZmeZIU5dRwQdTmYKXfJfE,128
-smart_bot_factory/creation/bot_builder.py,sha256=c3maqY9qJBsRJO3kI4iko2oKf0JrjECUV_XRrImlgQQ,22169
+smart_bot_factory/creation/bot_builder.py,sha256=RhnnZZhNvJC-nKTly5VvoxpXBucKFoXUl4e5gfBk7TI,27057
 smart_bot_factory/creation/bot_testing.py,sha256=JDWXyJfZmbgo-DLdAPk8Sd9FiehtHHa4sLD17lBrTOc,55669
 smart_bot_factory/database/database_structure.sql,sha256=26gFtMC2jdQGQF7Zb_F4Br56rMd4hUDTk9FkNZYneLo,2789
 smart_bot_factory/database/schema.sql,sha256=-6kOmA9QnSkUtmGI2iQRbTvbdiqOhEOQcuz1lJn79mU,28059
 smart_bot_factory/event/__init__.py,sha256=hPL449RULIOB-OXv1ZbGNiHctAYaOMUqhSWGPrDHYBM,212
-smart_bot_factory/handlers/handlers.py,sha256=YH8xG0tDcb7uxZXI4socXURzc-y57_FEQ6GqTgYcM5Q,37603
+smart_bot_factory/handlers/handlers.py,sha256=1_0CAbedbmdSBeWPF9KR97RM6zNWPv56wR9EdrfPtdo,38630
 smart_bot_factory/integrations/openai_client.py,sha256=aMcDrKO0GEx3ZSVEOGDeDtFCDWSXs6biUfgrbRK8yTU,23180
 smart_bot_factory/integrations/supabase_client.py,sha256=AfALLZdDYeMWHLJw6POTGiBd-sH3i03oT6tT7m9C28I,44644
 smart_bot_factory/message/__init__.py,sha256=6QvjdfF99venyDB9udZv9WDNjIHJLNuaVhYdTK3a44A,282
-smart_bot_factory/router/__init__.py,sha256=fLXSXfa-MaI9ickXoqha3PqpjxunsNLyVNlHIoIbr1c,115
+smart_bot_factory/router/__init__.py,sha256=QrfO5u8H2uVzWGMtBvNKunsJAv7UrKtvt2f_D5xSFWE,270
 smart_bot_factory/supabase/__init__.py,sha256=XmZP6yM9ffERM5ddAWyJnrNzEhCYtMu3AcjVCi1rOf8,179
 smart_bot_factory/supabase/client.py,sha256=8_-I3kxZQlKQElI4cTUjNGYcqlyIyEkSrUZaP0nfNNU,26044
 smart_bot_factory/utils/__init__.py,sha256=5zNjw491bj5VkOhoEAwh2hjmv8nldyDOTrG7pbGpz6A,285
 smart_bot_factory/utils/debug_routing.py,sha256=BOoDhKBg7UXe5uHQxRk3TSfPfLPOFqt0N7lAo6kjCOo,4719
 smart_bot_factory/utils/prompt_loader.py,sha256=JSn7CsWnToSbHYtURdeuZn7ectyDqQGrPGHN2ixIGkw,19930
-smart_bot_factory-0.1.9.dist-info/METADATA,sha256=ViqO05vBPd-Qz6kQ2imVmUqePKRGUaOeyBCGpxG4VUk,20494
-smart_bot_factory-0.1.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-smart_bot_factory-0.1.9.dist-info/entry_points.txt,sha256=ybKEAI0WSb7WoRiey7QE-HHfn88UGV7nxLDxXq7b7SU,50
-smart_bot_factory-0.1.9.dist-info/licenses/LICENSE,sha256=OrK3cwdUTzNzIhJvSPtJaVMoYIyC_sSx5EFE_FDMvGs,1092
-smart_bot_factory-0.1.9.dist-info/RECORD,,
+smart_bot_factory-0.2.1.dist-info/METADATA,sha256=wj1v5p2joJlA_u9LcfBFPFjPqBfxvFu1BxUE389uwDA,28224
+smart_bot_factory-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+smart_bot_factory-0.2.1.dist-info/entry_points.txt,sha256=ybKEAI0WSb7WoRiey7QE-HHfn88UGV7nxLDxXq7b7SU,50
+smart_bot_factory-0.2.1.dist-info/licenses/LICENSE,sha256=OrK3cwdUTzNzIhJvSPtJaVMoYIyC_sSx5EFE_FDMvGs,1092
+smart_bot_factory-0.2.1.dist-info/RECORD,,