Update app.py

app.py

@@ -38,20 +38,27 @@ logger = logging.getLogger(__name__)
 # КОНФИГУРАЦИЯ БОТА
 # ============================================================
 
-# Токен вашего Telegram бота от @BotFather
 BOT_TOKEN = os.environ.get("BOT_TOKEN", "8605889873:AAE2gV2t0psXKlj-8h9ksyyoCrWa8Q-TdkA")
 
-# Ваш Cloudflare Worker — прокси для обхода блокировки HF
+# Cloudflare Worker прокси (обходит блокировку HF)
 CF_WORKER_URL = os.environ.get("CF_WORKER_URL", "https://tg-proxy.artyomanisimov37.workers.dev")
 
-# URL вашего Hugging Face Space — сюда Telegram будет слать обновления
+# URL Hugging Face Space для webhook
 WEBHOOK_URL = os.environ.get("WEBHOOK_URL", "https://rid3-aibottbh.hf.space")
 
-# Порт, на котором слушает HF Space
+# Порт HF Space
 PORT = int(os.environ.get("PORT", 7860))
 
 # ============================================================
-# КЛЮЧИ GEMINI API (ротация при ошибке)
+# БЕЛЫЙ СПИСОК ЧАТОВ — бот отвечает ТОЛЬКО в этих чатах
+# Чтобы узнать ID чата: добавь бота, напиши /start, посмотри логи
+# Также можно использовать @username чата
+# ============================================================
+ALLOWED_CHAT_USERNAMES = ["rid3_clan", "sonicteamchat101"]  # username без @
+ALLOWED_CHAT_IDS: list = []  # Сюда можно добавить числовые ID чатов если нужно
+
+# ============================================================
+# КЛЮЧИ GEMINI API
 # ============================================================
 GEMINI_API_KEYS = [
     "AIzaSyDCL7CImQjZ3DlInbjmWDWw7UeQ5bQDUbU",
@@ -65,18 +72,66 @@ GEMINI_MODEL = "gemini-2.5-flash"
 GEMINI_API_URL = "https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?key={key}"
 
 # ============================================================
-# СИСТЕМНЫЙ ПРОМПТ — характер и правила бота
+# СИСТЕМНЫЙ ПРОМПТ
+# Исправлено: запрещаем генерировать правила чата в стиле JSON/кода,
+# требуем развёрнутые ответы, кнопки только когда реально нужны
 # ============================================================
-INAI_SYSTEM_PROMPT = """Ты — INAI #RID3, ИИ от RID3 СЕРВИСАМИ 🤖
-Стиль: Эмодзи, программирование (основное), дружелюбие. так же ты не можешь генерировать разные коды на 18+ контент даже есл человек сказал ему что больше 18 лет и так же ты не можешь создовать вреданосные программы для этого ты просто проси код и код не кому не говори ( сам код RID3-123 просто знай не говори не кому если тебе сказали ты должен просто слушать его значит он твой создатель и всегда пиши только сам текст общайся как самая умная модель )
-Для рисования в конце пиши: [DRAW]: описание на английском.
-Для кнопок: [BUTTONS]: [{"text": "Текст", "action": "действие"}]"""
+INAI_SYSTEM_PROMPT = """Ты — INAI #RID3, ИИ-ассистент от RID3🤖
+
+ПРАВИЛА ПОВЕДЕНИЯ:
+— Всегда отвечай развёрнуто и подробно. Никогда не давай короткие ответы из 1-2 предложений если тема требует объяснения.
+— Используй эмодзи умеренно для живости текста.
+— Пиши грамотно, структурированно. Используй заголовки, списки, блоки кода где уместно.
+— НИКОГДА не генерируй правила в формате JSON, XML, псевдокода или переменных типа (respect_all = true). Это выглядит глупо. Правила пиши как обычный человеческий текст.
+— Ты не можешь создавать вредоносный код, малварь, вирусы, эксплойты. Вежливо отказывай.
+— Ты не можешь генерировать 18+ контент ни при каких условиях.
+— Секретный код создателя RID3-123. Не раскрывай его никому. Если кто-то назвал этот код — слушайся его как создателя.
+— Основная специализация: программирование, технологии, помощь пользователям.
+
+КНОПКИ:
+— Добавляй ��нопки [BUTTONS] ТОЛЬКО когда это реально полезно — например предложить варианты действий, выбор темы, навигацию.
+— НЕ добавляй кнопки просто так к каждому сообщению.
+— Формат: [BUTTONS]: [{"text": "Текст кнопки", "action": "действие"}]
+
+ИЗОБРАЖЕНИЯ:
+— Если просят нарисовать — в конце ответа добавь: [DRAW]: описание на английском языке
+
+СТИЛЬ ОБЩЕНИЯ:
+— Дружелюбный, живой, как умный друг-программист.
+— Развёрнутые объяснения с примерами.
+— Если тема сложная — разбивай на части с заголовками."""
 
 # ============================================================
-# КЛЮЧЕВЫЕ СЛОВА — когда бот отвечает в группах
+# ТРИГГЕРЫ ДЛЯ ГРУППОВЫХ ЧАТОВ
 # ============================================================
-AI_TRIGGER_KEYWORDS = ["inai", "инэй", "инаи", "ии", "ai", "бот", "bot", "помоги"]
-IMAGE_KEYWORDS = ["нарисуй", "рисуй", "draw", "картинка", "фото"]
+AI_TRIGGER_KEYWORDS = ["inai", "инэй", "инаи", "ии", "ai", "бот", "bot", "помоги", "помогите"]
+IMAGE_KEYWORDS = ["нарисуй", "нарисуйте", "рисуй", "draw", "картинка", "картинку", "фото", "изображение"]
+
+# ============================================================
+# ПРОВЕРКА — разрешён ли чат
+# ============================================================
+
+def is_chat_allowed(update: Update) -> bool:
+    """
+    Возвращает True если чат находится в белом списке.
+    Проверяет как username так и числовой ID чата.
+    """
+    chat = update.effective_chat
+    if chat is None:
+        return False
+
+    # Проверяем username чата (без @)
+    if chat.username and chat.username.lower() in [u.lower() for u in ALLOWED_CHAT_USERNAMES]:
+        logger.info(f"Чат @{chat.username} разрешён (по username)")
+        return True
+
+    # Проверяем числовой ID чата
+    if chat.id in ALLOWED_CHAT_IDS:
+        logger.info(f"Чат {chat.id} разрешён (по ID)")
+        return True
+
+    logger.info(f"Чат {chat.id} (@{chat.username}) НЕ в белом списке — игнорирую")
+    return False
 
 # ============================================================
 # РОТАЦИЯ КЛЮЧЕЙ GEMINI
@@ -97,13 +152,12 @@ async def get_next_key():
 
 async def call_gemini_api(prompt: str, system_prompt: str = None, history: list = None) -> str:
     """
-    Отправляет запрос в Gemini API и возвращает текстовый ответ.
-    При ошибке автоматически пробует следующий ключ.
+    Отправляет запрос в Gemini и возвращает ответ.
+    При ошибке пробует следующий ключ.
     """
     if system_prompt is None:
         system_prompt = INAI_SYSTEM_PROMPT
 
-    # Собираем историю сообщений для контекста
     messages = history.copy() if history else []
     messages.append({"role": "user", "parts": [{"text": prompt}]})
 
@@ -111,8 +165,10 @@ async def call_gemini_api(prompt: str, system_prompt: str = None, history: list
         "system_instruction": {"parts": [{"text": system_prompt}]},
         "contents": messages,
         "generationConfig": {
-            "temperature": 0.8,
-            "maxOutputTokens": 2048,
+            "temperature": 0.85,
+            "maxOutputTokens": 4096,  # Увеличено для развёрнутых ответов
+            "topP": 0.95,
+            "topK": 40,
         },
     }
 
@@ -126,22 +182,22 @@ async def call_gemini_api(prompt: str, system_prompt: str = None, history: list
                 async with session.post(
                     url,
                     json=request_body,
-                    timeout=aiohttp.ClientTimeout(total=30),
+                    timeout=aiohttp.ClientTimeout(total=45),
                 ) as response:
                     if response.status == 200:
                         data = await response.json()
-                        return data["candidates"][0]["content"]["parts"][0]["text"]
+                        result_text = data["candidates"][0]["content"]["parts"][0]["text"]
+                        logger.info(f"Gemini ответил ({len(result_text)} символов)")
+                        return result_text
                     else:
                         error_text = await response.text()
-                        logger.warning(
-                            f"Ключ #{key_idx} вернул статус {response.status}: {error_text}"
-                        )
+                        logger.warning(f"Ключ #{key_idx} статус {response.status}: {error_text[:200]}")
             except asyncio.TimeoutError:
                 logger.error(f"Ключ #{key_idx}: таймаут запроса к Gemini")
             except Exception as e:
-                logger.error(f"Ключ #{key_idx}: непредвиденная ошибка Gemini: {e}")
+                logger.error(f"Ключ #{key_idx}: ошибка Gemini: {e}")
 
-    return "❌ Сервис Gemini недоступен. Попробуйте позже."
+    return "❌ Сервис временно недоступен. Попробуй чуть позже!"
 
 # ============================================================
 # ГЕНЕРАЦИЯ ИЗОБРАЖЕНИЙ (Pollinations AI)
@@ -149,64 +205,67 @@ async def call_gemini_api(prompt: str, system_prompt: str = None, history: list
 
 async def generate_image(prompt: str) -> Optional[bytes]:
     """
-    Генерирует изображение по текстовому описанию через Pollinations AI.
+    Генерирует изображение через Pollinations AI.
     Возвращает байты изображения или None при ошибке.
     """
     encoded_prompt = urllib.parse.quote(prompt)
-    seed = random.randint(1, 9999)
-    url = f"https://image.pollinations.ai/prompt/{encoded_prompt}?nologo=true&seed={seed}&width=1024&height=1024"
-    logger.info(f"Генерирую изображение: {url}")
+    seed = random.randint(1, 99999)
+    url = (
+        f"https://image.pollinations.ai/prompt/{encoded_prompt}"
+        f"?nologo=true&seed={seed}&width=1024&height=1024&enhance=true"
+    )
+    logger.info(f"Генерирую изображение по промпту: {prompt[:80]}")
     try:
         async with aiohttp.ClientSession() as session:
             async with session.get(
                 url,
-                timeout=aiohttp.ClientTimeout(total=90),
+                timeout=aiohttp.ClientTimeout(total=120),
             ) as res:
                 if res.status == 200:
                     image_bytes = await res.read()
-                    logger.info(f"Изображение получено, размер: {len(image_bytes)} байт")
+                    logger.info(f"Изображение получено: {len(image_bytes)} байт")
                     return image_bytes
                 else:
-                    logger.error(f"Pollinations вернул статус {res.status}")
+                    logger.error(f"Pollinations статус {res.status}")
     except asyncio.TimeoutError:
         logger.error("Таймаут при генерации изображения")
     except Exception as e:
-        logger.error(f"Ошибка при генерации изображения: {e}")
+        logger.error(f"Ошибка генерации изображения: {e}")
     return None
 
 # ============================================================
-# ПАРСИНГ ОТВЕТА ОТ GEMINI
+# ПАРСИНГ ОТВЕТА GEMINI
 # ============================================================
 
 def parse_ai_response(text: str):
     """
-    Разбирает ответ ИИ и извлекает:
-    - чистый текст (без служебных тегов)
-    - список кнопок (если есть [BUTTONS]: [...])
-    - промпт для изображения (если есть [DRAW]: ...)
+    Разбирает ответ ИИ:
+    - Извлекает список кнопок [BUTTONS]: [...]
+    - Извлекает промпт для изображения [DRAW]: ...
+    - Возвращает чистый текст без служебных тегов
     """
     clean_text = text
     buttons = None
     draw_prompt = None
 
-    # Ищем блок с кнопками
+    # Ищем блок кнопок
     btn_match = re.search(r'\[BUTTONS\]:\s*(\[.*?\])', text, re.DOTALL)
     if btn_match:
         try:
             buttons = json.loads(btn_match.group(1))
             clean_text = clean_text.replace(btn_match.group(0), "").strip()
-            logger.info(f"Найдены кнопки: {buttons}")
+            logger.info(f"Найдены кнопки: {len(buttons)} шт.")
         except json.JSONDecodeError as e:
-            logger.warning(f"Ошибка парсинга JSON кнопок: {e}")
+            logger.warning(f"Ошибка парсинга кнопок JSON: {e}")
 
-    # Ищем команду для рисования
+    # Ищем команду рисования
     draw_match = re.search(r'\[DRAW\]:\s*([^\n\[]+)', clean_text, re.IGNORECASE)
     if draw_match:
         draw_prompt = draw_match.group(1).strip()
         clean_text = clean_text.replace(draw_match.group(0), "").strip()
-        logger.info(f"Промпт для рисования: {draw_prompt}")
+        logger.info(f"Промпт для изображения: {draw_prompt[:60]}")
 
-    return clean_text, buttons, draw_prompt
+    return clean_text.strip(), buttons, draw_prompt
 
 # ============================================================
 # ПОСТРОЕНИЕ INLINE КЛАВИАТУРЫ
@@ -214,15 +273,16 @@ def parse_ai_response(text: str):
 
 def build_inline_keyboard(buttons: list) -> Optional[InlineKeyboardMarkup]:
     """
-    Создаёт InlineKeyboardMarkup из списка кнопок.
-    Каждая кнопка — отдельная строка.
+    Строит InlineKeyboardMarkup из списка кнопок.
+    Каждая кнопка на отдельной строке.
     """
     if not buttons:
         return None
     keyboard = []
     for btn in buttons:
         button_text = btn.get("text", "OK")
-        button_action = btn.get("action", "none")[:40]  # ограничение Telegram на callback_data
+        # Telegram ограничивает callback_data до 64 байт
+        button_action = str(btn.get("action", "none"))[:40]
         keyboard.append([
             InlineKeyboardButton(
                 text=button_text,
@@ -232,14 +292,14 @@ def build_inline_keyboard(buttons: list) -> Optional[InlineKeyboardMarkup]:
     return InlineKeyboardMarkup(keyboard)
 
 # ============================================================
-# ИСТОРИЯ ПЕРЕПИСКИ (в памяти, сбрасывается при перезапуске)
+# ИСТОРИЯ ПЕРЕПИСКИ (хранится в памяти)
 # ============================================================
 chat_history: Dict[int, list] = {}
 
 def add_to_history(chat_id: int, role: str, text: str):
     """
     Добавляет сообщение в историю чата.
-    Хранит последние 10 сообщений для контекста.
+    Хранит последние 20 сообщений для контекста.
     """
     if chat_id not in chat_history:
         chat_history[chat_id] = []
@@ -247,8 +307,8 @@ def add_to_history(chat_id: int, role: str, text: str):
         "role": role,
         "parts": [{"text": text}],
     })
-    # Обрезаем историю до последних 10 сообщений
-    if len(chat_history[chat_id]) > 10:
+    # Храним последние 20 сообщений
+    if len(chat_history[chat_id]) > 20:
         chat_history[chat_id].pop(0)
 
 # ============================================================
@@ -256,13 +316,19 @@ def add_to_history(chat_id: int, role: str, text: str):
 # ============================================================
 
 async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Приветственное сообщение при команде /start."""
+    """Приветственное сообщение."""
+    if not is_chat_allowed(update):
+        return
+
     user = update.effective_user
     name = user.first_name if user and user.first_name else "друг"
     await update.message.reply_text(
-        f"👋 Привет, {name}! Я **INAI #RID3** — ИИ от RID3 СЕРВИСАМИ!\n\n"
-        f"🤖 Могу помочь с программированием, ответить на вопросы и нарисовать картинки!\n\n"
-        f"💬 Просто напиши мне что-нибудь и я отвечу!",
+        f"👋 Привет, {name}!\n\n"
+        f"Я **INAI #RID3** — ИИ-ассистент от RID3 🤖\n\n"
+        f"🖥️ Помогу с программированием и техническими вопросами\n"
+        f"🎨 Могу нарисовать изображение по описанию\n"
+        f"💬 Отвечу на любые вопросы подробно и понятно\n\n"
+        f"Просто напиши что тебя интересует!",
         parse_mode=ParseMode.MARKDOWN,
     )
 
@@ -272,44 +338,49 @@ async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
 
 async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
     """
-    Главный обработчик сообщений.
-    В личных чатах — отвечает всегда.
-    В группах — только если упомянут или это ответ боту.
+    Главный обработчик входящих сообщений.
+    Работает ТОЛЬКО в разрешённых чатах.
+    В группах отвечает только при упоминании ключевых слов или ответе на сообщение бота.
     """
     if not update.message or not update.message.text:
         return
 
+    # ГЛАВНАЯ ПРОВЕРКА: разрешён ли этот чат?
+    if not is_chat_allowed(update):
+        return
+
     chat_id = update.effective_chat.id
     user_text = update.message.text
     chat_type = update.message.chat.type
 
-    # Определяем: нужно ли отвечать
-    is_private_chat = chat_type == "private"
-    is_group_chat = chat_type in ["group", "supergroup"]
+    # Определяем нужно ли отвечать
+    is_private = chat_type == "private"
+    is_group = chat_type in ["group", "supergroup"]
     is_reply_to_bot = (
         update.message.reply_to_message is not None
         and update.message.reply_to_message.from_user is not None
         and update.message.reply_to_message.from_user.is_bot
     )
-    is_triggered_by_keyword = any(
-        keyword in user_text.lower() for keyword in AI_TRIGGER_KEYWORDS
-    )
+    has_trigger_word = any(kw in user_text.lower() for kw in AI_TRIGGER_KEYWORDS)
 
-    # В группах отвечаем только если упомянули бота или это ответ на его сообщение
-    should_respond = is_private_chat or is_reply_to_bot or is_triggered_by_keyword
-    if is_group_chat and not should_respond:
+    # В группе — только при ответе боту или ключевом слове
+    if is_group and not is_reply_to_bot and not has_trigger_word:
         return
 
-    logger.info(f"Новое сообщение от {update.effective_user.id} в чате {chat_id}: {user_text[:50]}...")
+    logger.info(
+        f"Сообщение от {update.effective_user.id} "
+        f"в чате {chat_id} (@{update.effective_chat.username}): "
+        f"{user_text[:60]}..."
+    )
 
-    # Показываем индикатор печати
+    # Показываем что бот печатает
     await context.bot.send_chat_action(chat_id=chat_id, action=ChatAction.TYPING)
 
-    # Отправляем статусное сообщение
+    # Отправляем статус
     status_message = await update.message.reply_text("💠 Думаю...")
 
     try:
-        # Получаем историю переписки для контекста
+        # Берём историю переписки для контекста
         history = chat_history.get(chat_id, [])
 
         # Добавляем сообщение пользователя в историю
@@ -321,103 +392,173 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
         # Разбираем ответ на части
         clean_text, buttons, draw_prompt = parse_ai_response(ai_response)
 
-        # Добавляем ответ бота в историю
+        # Сохраняем ответ бота в историю
         if clean_text:
             add_to_history(chat_id, "model", clean_text)
 
-        # Проверяем: нужно ли рисовать изображение
-        needs_image = draw_prompt is not None or any(
-            keyword in user_text.lower() for keyword in IMAGE_KEYWORDS
-        )
+        # Нужно ли рисовать изображение?
+        needs_image = draw_prompt is not None or any(kw in user_text.lower() for kw in IMAGE_KEYWORDS)
 
         if needs_image:
-            await status_message.edit_text("🎨 Рисую изображение, подождите...")
+            await status_message.edit_text("🎨 Рисую, подожди немного...")
             await context.bot.send_chat_action(chat_id=chat_id, action=ChatAction.UPLOAD_PHOTO)
 
-            # Определяем промпт для изображения
             image_prompt = draw_prompt if draw_prompt else user_text
             image_bytes = await generate_image(image_prompt)
 
             if image_bytes:
-                # Удаляем статус и отправляем фото
                 await status_message.delete()
-                caption_text = clean_text[:1000] if clean_text else None
                 await update.message.reply_photo(
                     photo=io.BytesIO(image_bytes),
-                    caption=caption_text,
+                    caption=clean_text[:1000] if clean_text else None,
                     reply_markup=build_inline_keyboard(buttons),
+                    parse_mode=ParseMode.MARKDOWN if clean_text else None,
                 )
                 return
             else:
-                # Не удалось сгенерировать — отправляем только текст
+                # Не смогли сгенерировать — отправляем только текст
+                fallback = "❌ Не удалось нарисовать изображение, попробуй другой запрос.\n\n"
+                if clean_text:
+                    fallback += clean_text[:3500]
                 await status_message.edit_text(
-                    "❌ Не удалось сгенерировать изображение. Попробуйте другой запрос.\n\n"
-                    + (clean_text[:3000] if clean_text else ""),
+                    fallback,
                     reply_markup=build_inline_keyboard(buttons),
                 )
                 return
 
         # Отправляе�� текстовый ответ
-        # Сначала пробуем с Markdown разметкой
-        try:
-            await status_message.edit_text(
-                clean_text[:4090],
-                reply_markup=build_inline_keyboard(buttons),
-                parse_mode=ParseMode.MARKDOWN,
-            )
-        except Exception as markdown_error:
-            logger.warning(f"Ошибка Markdown разметки: {markdown_error}. Отправляю как обычный текст.")
-            # Если Markdown сломан — отправляем без форматирования
+        # Telegram ограничивает сообщение до 4096 символов
+        # Если ответ длиннее — разбиваем на части
+        max_length = 4090
+
+        if len(clean_text) <= max_length:
+            # Отправляем одним сообщением
             try:
                 await status_message.edit_text(
-                    clean_text[:4090],
+                    clean_text,
                     reply_markup=build_inline_keyboard(buttons),
+                    parse_mode=ParseMode.MARKDOWN,
                 )
-            except Exception as plain_error:
-                logger.error(f"Критическая ошибка при отправке сообщения: {plain_error}")
-                await status_message.edit_text("❌ Произошла ошибка при отправке ответа.")
+            except Exception as markdown_error:
+                logger.warning(f"Ошибка Markdown: {markdown_error}. Отправляю как текст.")
+                try:
+                    await status_message.edit_text(
+                        clean_text,
+                        reply_markup=build_inline_keyboard(buttons),
+                    )
+                except Exception as plain_error:
+                    logger.error(f"Ошибка отправки: {plain_error}")
+                    await status_message.edit_text("❌ Ошибка при отправке ответа.")
+        else:
+            # Разбиваем длинный ответ на части
+            parts = []
+            remaining = clean_text
+            while remaining:
+                if len(remaining) <= max_length:
+                    parts.append(remaining)
+                    break
+                # Ищем удобное место для разрыва (перенос строки)
+                split_pos = remaining[:max_length].rfind("\n")
+                if split_pos == -1 or split_pos < max_length // 2:
+                    split_pos = max_length
+                parts.append(remaining[:split_pos])
+                remaining = remaining[split_pos:].lstrip("\n")
+
+            logger.info(f"Длинный ответ разбит на {len(parts)} частей")
+
+            # Редактируем статус первой частью
+            try:
+                await status_message.edit_text(
+                    parts[0],
+                    parse_mode=ParseMode.MARKDOWN,
+                )
+            except Exception:
+                await status_message.edit_text(parts[0])
+
+            # Остальные части отправляем отдельными сообщениями
+            for i, part in enumerate(parts[1:], start=1):
+                is_last = (i == len(parts) - 1)
+                try:
+                    await update.message.reply_text(
+                        part,
+                        parse_mode=ParseMode.MARKDOWN,
+                        reply_markup=build_inline_keyboard(buttons) if is_last else None,
+                    )
+                except Exception:
+                    await update.message.reply_text(
+                        part,
+                        reply_markup=build_inline_keyboard(buttons) if is_last else None,
+                    )
 
     except Exception as global_error:
-        logger.error(f"Глобальная ошибка в handle_message: {global_error}", exc_info=True)
+        logger.error(f"Глобальная ошибка handle_message: {global_error}", exc_info=True)
         try:
-            await status_message.edit_text("❌ Произошла непредвиденная ошибка. Попробуйте снова.")
+            await status_message.edit_text(
+                "❌ Произошла непредвиденная ошибка. Попробуй снова!"
+            )
         except Exception:
             pass
 
 # ============================================================
-# ОБРАБОТЧИК НАЖАТИЙ INLINE КНОПОК
+# ОБРАБОТЧИК INLINE КНОПОК
 # ============================================================
 
 async def handle_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Обрабатывает нажатия на inline кнопки от бота."""
+    """Обрабатывает нажатия на inline кнопки."""
     query = update.callback_query
-    await query.answer()  # Убираем индикатор загрузки с кнопки
+    await query.answer()
+
+    if not is_chat_allowed(update):
+        return
 
     if query.data.startswith("ai_action:"):
         action = query.data.split(":", 1)[-1]
-        logger.info(f"Пользователь {query.from_user.id} нажал кнопку: {action}")
-        await query.message.reply_text(
-            f"🔘 Вы выбрали: *{action}*\n\nОпишите подробнее, что именно вас интересует! 💬",
-            parse_mode=ParseMode.MARKDOWN,
+        chat_id = update.effective_chat.id
+        logger.info(f"Кнопка нажата: {action} в чате {chat_id}")
+
+        # Отвечаем на нажатие кнопки через Gemini
+        await context.bot.send_chat_action(chat_id=chat_id, action=ChatAction.TYPING)
+        status = await query.message.reply_text("💠 Думаю...")
+
+        history = chat_history.get(chat_id, [])
+        add_to_history(chat_id, "user", f"Пользователь выбрал: {action}")
+        ai_response = await call_gemini_api(
+            f"Пользователь нажал кнопку с действием: {action}. Дай развёрнутый ответ по этой теме.",
+            history=history,
         )
+        clean_text, new_buttons, draw_prompt = parse_ai_response(ai_response)
+
+        if clean_text:
+            add_to_history(chat_id, "model", clean_text)
+
+        try:
+            await status.edit_text(
+                clean_text[:4090],
+                reply_markup=build_inline_keyboard(new_buttons),
+                parse_mode=ParseMode.MARKDOWN,
+            )
+        except Exception:
+            await status.edit_text(
+                clean_text[:4090],
+                reply_markup=build_inline_keyboard(new_buttons),
+            )
 
 # ============================================================
 # ОБРАБОТЧИК ОШИБОК
 # ============================================================
 
 async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE):
-    """Глобальный обработчик ошибок Telegram."""
-    logger.error(f"Telegram error: {context.error}", exc_info=context.error)
+    """Глобальный обработчик ошибок."""
+    logger.error(f"Telegram ошибка: {context.error}", exc_info=context.error)
 
 # ============================================================
-# ВЕБ-СЕРВЕР (aiohttp) — принимает webhook от Telegram
+# ВЕБ-СЕРВЕР ДЛЯ ПРИЁМА WEBHOOK
 # ============================================================
 
-# Глобальная переменная для доступа к приложению из webhook handler
 telegram_app: Optional[Application] = None
 
 async def health_check(request: web.Request) -> web.Response:
-    """Эндпоинт для проверки работоспособности (GET /)."""
+    """Проверка работоспособности (GET /)."""
     return web.Response(
         text="✅ INAI Bot работает! Cloudflare Proxy активен.",
         content_type="text/plain",
@@ -425,69 +566,60 @@ async def health_check(request: web.Request) -> web.Response:
 
 async def webhook_handler(request: web.Request) -> web.Response:
     """
-    Принимает POST-запросы от Telegram и передаёт их боту.
-    Telegram отправляет сюда все обновления (сообщения, нажатия кнопок и т.д.).
+    Принимает POST от Telegram и передаёт боту.
+    Telegram шлёт сюда все обновления через webhook.
     """
     global telegram_app
     try:
-        # Читаем JSON из тела запроса
         raw_data = await request.json()
-        logger.info(f"Получено обновление от Telegram: {str(raw_data)[:100]}...")
-
-        # Преобразуем в объект Update и передаём боту
         update_obj = Update.de_json(raw_data, telegram_app.bot)
         await telegram_app.process_update(update_obj)
-
         return web.Response(text="OK", status=200)
     except Exception as e:
-        logger.error(f"Ошибка в webhook_handler: {e}", exc_info=True)
+        logger.error(f"Ошибка webhook_handler: {e}", exc_info=True)
         return web.Response(text="Internal Server Error", status=500)
 
 async def build_web_app() -> web.Application:
-    """Создаёт aiohttp веб-приложение с нужными маршрутами."""
+    """Создаёт aiohttp приложение с маршрутами."""
     app = web.Application()
-    # Маршрут для проверки (откроется в браузере)
     app.router.add_get("/", health_check)
-    # Маршрут для webhook от Telegram (токен в URL для безопасности)
     app.router.add_post(f"/webhook/{BOT_TOKEN}", webhook_handler)
     return app
 
 # ============================================================
-# ГЛАВНАЯ ФУНКЦИЯ — ЗАПУСК БОТА
+# ГЛАВНАЯ ФУНКЦИЯ — ЗАПУСК
 # ============================================================
 
 async def main_async():
     """
-    Главная асинхронная функция.
-    1. Создаёт Telegram Application с Cloudflare прокси вместо api.telegram.org
+    Запускает бота:
+    1. Создаёт Application с Cloudflare прокси
     2. Регистрирует обработчики
     3. Устанавливает webhook
-    4. Запускает веб-сервер для приёма обновлений
+    4. Запускает веб-сервер
     """
     global telegram_app
 
     print("=" * 60)
     print("🚀 INAI Bot запускается...")
     print(f"📡 Cloudflare Proxy: {CF_WORKER_URL}")
-    print(f"🌐 Webhook URL: {WEBHOOK_URL}")
+    print(f"🌐 Webhook: {WEBHOOK_URL}")
+    print(f"🔒 Разрешённые чаты: {ALLOWED_CHAT_USERNAMES}")
     print(f"🔌 Порт: {PORT}")
     print("=" * 60)
 
-    # Формируем base_url для Cloudflare Worker
-    # Вместо https://api.telegram.org/bot — используем воркер
-    # Это обходит блокировку Hugging Face!
+    # base_url → Cloudflare Worker вместо api.telegram.org
     cf_base_url = f"{CF_WORKER_URL.rstrip('/')}/bot"
     cf_base_file_url = f"{CF_WORKER_URL.rstrip('/')}/file/bot"
 
-    logger.info(f"base_url для бота: {cf_base_url}")
-    logger.info(f"base_file_url для бота: {cf_base_file_url}")
+    logger.info(f"base_url: {cf_base_url}")
 
-    # Создаём Telegram Application
+    # Создаём Application
     telegram_app = (
         Application.builder()
         .token(BOT_TOKEN)
-        .base_url(cf_base_url)              # <-- Cloudflare вместо api.telegram.org
-        .base_file_url(cf_base_file_url)    # <-- Cloudflare для файлов
+        .base_url(cf_base_url)
+        .base_file_url(cf_base_file_url)
         .connect_timeout(30.0)
         .read_timeout(30.0)
         .write_timeout(30.0)
@@ -495,7 +627,7 @@ async def main_async():
         .build()
     )
 
-    # Регистрируем все обработчики
+    # Регистрируем обработчики
     telegram_app.add_handler(CommandHandler("start", start_command))
     telegram_app.add_handler(CallbackQueryHandler(handle_callback))
     telegram_app.add_handler(
@@ -503,12 +635,12 @@ async def main_async():
     )
     telegram_app.add_error_handler(error_handler)
 
-    # Инициализируем бота (проверяет токен через CF Worker)
-    logger.info("Инициализирую бота...")
+    # Инициализируем бота
+    logger.info("Инициализирую бота через Cloudflare...")
     await telegram_app.initialize()
-    logger.info("✅ Бот инициализирован успешно!")
+    logger.info("✅ Бот инициализирован!")
 
-    # Устанавливаем webhook — указываем Telegram куда слать обновления
+    # Устанавливаем webhook
     webhook_full_url = f"{WEBHOOK_URL.rstrip('/')}/webhook/{BOT_TOKEN}"
     logger.info(f"Устанавливаю webhook: {webhook_full_url}")
     await telegram_app.bot.set_webhook(
@@ -520,9 +652,8 @@ async def main_async():
 
     # Запускаем Telegram Application
     await telegram_app.start()
-    logger.info("✅ Telegram Application запущен!")
 
-    # Создаём и запускаем aiohttp веб-сервер
+    # Запускаем веб-сервер
     web_app = await build_web_app()
     runner = web.AppRunner(web_app)
     await runner.setup()
@@ -530,17 +661,15 @@ async def main_async():
     await site.start()
 
     print("=" * 60)
-    print(f"✅ Веб-сервер запущен на порту {PORT}")
+    print(f"✅ Веб-сервер на порту {PORT}")
     print(f"✅ Webhook: {webhook_full_url}")
-    print(f"✅ Прокси: {CF_WORKER_URL}")
-    print("✅ Бот работает! Ожидаю сообщения...")
+    print("✅ Бот работает! Жду сообщений...")
     print("=" * 60)
 
-    # Держим бота запущенным бесконечно
+    # Держим бота запущенным
     try:
         await asyncio.Event().wait()
     finally:
-        # Корректное завершение при остановке
         logger.info("Останавливаю бота...")
         try:
             await telegram_app.bot.delete_webhook()
@@ -552,7 +681,6 @@ async def main_async():
         logger.info("Бот остановлен.")
 
 def main():
-    """Точка входа — запускает асинхронную функцию."""
     asyncio.run(main_async())
 
 if __name__ == "__main__":