Update app.py

app.py

@@ -6,232 +6,971 @@ import io
 import traceback
 import requests
 import torch
-from fastapi import FastAPI, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-import uvicorn
-from pyrogram import Client, filters, enums
-from gtts import gTTS
-from transformers import AutoModelForCausalLM, AutoTokenizer
+import logging
+import random
+import json
+from telegram import (
+    Update,
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    InputFile,
+)
+from telegram.ext import (
+    Application,
+    CommandHandler,
+    MessageHandler,
+    CallbackQueryHandler,
+    ContextTypes,
+    filters,
+)
+from telegram.constants import ParseMode, ChatAction
+
+# ============================================================
+# НАСТРОЙКА ЛОГИРОВАНИЯ
+# ============================================================
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    level=logging.INFO,
+)
+logger = logging.getLogger(__name__)
 
 # ============================================================
 # КОНФИГУРАЦИЯ БОТА
 # ============================================================
-API_ID = 39072129
-API_HASH = "5ed7516a5721300911826a9093397922"
-SESSION_STRING = "AgJUMYEANjf0BgCQGcJsNjo5Rs1siB3_DseD8Du7YbJOL9jk9QSWth2Lw2C5GolmYqM-KxQiXnXF_KF1P3BXTAIlATMoPokL-CMdQ4OrOcZdPtM3P8KPigL0JDljK95d2h-E6xSzmo9-TQcaZoYPpeYoNrcJ_Ii5R3AcjbQerf_GzadJFmuM-31sLHF9OP16tUtnnyngsY_V6hdlkhWZlDdnJV1TKRgwP-kViMRf84IYaiEEW7kGKNgqe8fU2OUir1-Xz-X-Cil_CgPDP0h7fOHYB0H74Ul_yq8XZI71C4MbcPwsEpp5LeGc8WBBXkIXD6r0AINmMiKDjb1EOwlIczlQ6gXsWQAAAAIA83VRAQ"
+BOT_TOKEN = "8605889873:AAE2gV2t0psXKlj-8h9ksyyoCrWa8Q-TdkA"
 
-# Используем полностью открытую и умную модель (не требует HF_TOKEN)
-MODEL_ID = "Qwen/Qwen2.5-1.5B-Instruct"
+# ============================================================
+# СПИСОК КЛЮЧЕЙ GEMINI (при ошибке одного — используется следующий)
+# ============================================================
+GEMINI_API_KEYS = [
+    # Добавьте сюда ваши ключи Gemini API, например:
+    # "AIzaSy...",
+    # "AIzaSy...",
+    # "AIzaSy...",
+    # Пример-заглушка (замените на настоящие ключи):
+    "ЗАМЕНИТЕ_НА_ВАШИ_КЛЮЧИ_GEMINI_API",
+]
+
+# Текущий индекс ключа (глобальный, потокобезопасный через asyncio.Lock)
+current_key_index = 0
+key_lock = asyncio.Lock()
+
+GEMINI_MODEL = "gemini-2.5-flash-preview-04-17"
+GEMINI_API_URL = "https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?key={key}"
 
 # ============================================================
-# ИНИЦИАЛИЗАЦИЯ ИИ (Локально через Transformers)
+# СИСТЕМНЫЙ ПРОМПТ ДЛЯ INAI
 # ============================================================
-print(f"🧠 Загрузка мозгов ИИ из {MODEL_ID} (это займет немного времени при первом запуске)...")
+INAI_SYSTEM_PROMPT = """Ты — INAI #RID3, искусственный интеллект, созданный RID3 СЕРВИСАМИ 🤖✨
+Твоё полное имя: INAI #RID3
+Создатель: RID3 СЕРВИСАМИ (@Rid3_inc)
 
-try:
-    # Загружаем токенизатор и саму модель
-    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
-    # Используем torch.float32 для CPU или torch.bfloat16 если есть мощный процессор
-    model = AutoModelForCausalLM.from_pretrained(
-        MODEL_ID,
-        torch_dtype=torch.float32, 
-        device_map="cpu", # Принудительно на CPU, как вы и хотели
-        low_cpu_mem_usage=True
-    )
-    print("🚀 INAI готов к работе (Локальная модель загружена)!")
-except Exception as e:
-    print(f"❌ Ошибка загрузки модели: {e}")
-    traceback.print_exc()
+ПРАВИЛА ПОВЕДЕНИЯ:
+🔹 Ты активно используешь эмодзи в каждом ответе — это твой фирменный стиль
+🔹 Ты очень хорошо разбираешься в программировании — это твоя ГЛАВНАЯ специализация
+🔹 Ты помогаешь с кодом на Python, JavaScript, TypeScript, Rust, Go, C++, SQL и других языках
+🔹 Ты объясняешь концепции программирования понятно и с примерами
+🔹 Ты можешь создавать изображения по запросу пользователя (но это второстепенная функция)
+🔹 Всегда отвечай на языке пользователя (русский или другой)
+🔹 Ты дружелюбный, умный и полезный ИИ-ассист��нт
+🔹 Если пользователь просит нарисовать/создать изображение — добавь в конце своего ответа специальный тег: [DRAW]: описание на английском языке
+
+СТИЛЬ ОТВЕТОВ:
+✅ Всегда используй эмодзи
+✅ Для кода используй блоки кода с указанием языка
+✅ Давай развёрнутые и полезные ответы
+✅ Будь позитивным и поддерживающим
 
+ЕСЛИ ХОЧЕШЬ ПРЕДЛОЖИТЬ ПОЛЬЗОВАТЕЛЮ ВАРИАНТЫ ДЕЙСТВИЙ — добавь в конце ответа JSON с кнопками в таком формате:
+[BUTTONS]: [{"text": "Текст кнопки 1", "action": "действие1"}, {"text": "Текст кнопки 2", "action": "действие2"}]
+
+НЕ предлагай кнопки при каждом ответе — только когда это реально уместно и полезно."""
 
 # ============================================================
-# FASTAPI НАСТРОЙКИ
+# КЛЮЧЕВЫЕ СЛОВА ДЛЯ ТРИГГЕРА ИИ В ГРУППАХ
 # ============================================================
-app = FastAPI(title="INAI Unified API")
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+AI_TRIGGER_KEYWORDS = [
+    "inai", "инэй", "инаи", "ии", "ai", "бот", "bot",
+    "искусственный интеллект", "нейросеть", "нейро",
+    "помоги", "помогите", "скажи", "ответь", "объясни",
+    "что такое", "как сделать", "напиши код", "помоги с кодом",
+]
 
-class ChatRequest(BaseModel):
-    prompt: str
-    system_prompt: str = "You are INAI, created by RID3 (@Rid3_inc)."
-    max_tokens: int = 512
-    temperature: float = 0.7
+# Ключевые слова для генерации изображений
+IMAGE_KEYWORDS = [
+    "нарисуй", "нарисовать", "рисуй", "нарисовал бы",
+    "создай картинку", "сгенерируй", "сгенерируй картинку",
+    "сгенерируй изображение", "создай изображение",
+    "draw", "generate image", "create image",
+    "фото", "картинка", "изображение",
+]
 
 # ============================================================
-# PYROGRAM БОТ
+# ФУНКЦИИ РАБОТЫ С GEMINI API (С РОТАЦИЕЙ КЛЮЧЕЙ)
 # ============================================================
-bot = Client(
-    "inai_local_bot",
-    session_string=SESSION_STRING,
-    api_id=API_ID,
-    api_hash=API_HASH,
-    in_memory=True
-)
+
+async def get_next_key():
+    """Возвращает следующий доступный ключ по кругу."""
+    global current_key_index
+    async with key_lock:
+        key = GEMINI_API_KEYS[current_key_index]
+        current_key_index = (current_key_index + 1) % len(GEMINI_API_KEYS)
+        return key, current_key_index - 1 if current_key_index > 0 else len(GEMINI_API_KEYS) - 1
+
+
+async def call_gemini_api(prompt: str, system_prompt: str = None, history: list = None) -> str:
+    """
+    Отправляет запрос к Gemini API с автоматической ротацией ключей.
+    При ошибке одного ключа переходит к следующему.
+    """
+    if system_prompt is None:
+        system_prompt = INAI_SYSTEM_PROMPT
+
+    # Формируем сообщения (история + новый запрос)
+    messages = []
+    if history:
+        for item in history:
+            messages.append(item)
+    messages.append({"role": "user", "parts": [{"text": prompt}]})
+
+    # Формируем тело запроса
+    request_body = {
+        "system_instruction": {
+            "parts": [{"text": system_prompt}]
+        },
+        "contents": messages,
+        "generationConfig": {
+            "temperature": 0.8,
+            "topK": 40,
+            "topP": 0.95,
+            "maxOutputTokens": 2048,
+        },
+        "safetySettings": [
+            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+        ],
+    }
+
+    # Пробуем каждый ключ по очереди
+    tried_keys = set()
+    attempts = 0
+    max_attempts = len(GEMINI_API_KEYS)
+
+    while attempts < max_attempts:
+        key, key_idx = await get_next_key()
+
+        if key_idx in tried_keys:
+            # Если уже пробовали этот ключ — пропускаем
+            attempts += 1
+            continue
+
+        tried_keys.add(key_idx)
+        attempts += 1
+
+        url = GEMINI_API_URL.format(model=GEMINI_MODEL, key=key)
+
+        try:
+            logger.info(f"🔑 Используем ключ #{key_idx + 1} для запроса к Gemini API")
+
+            response = await asyncio.to_thread(
+                lambda: requests.post(
+                    url,
+                    json=request_body,
+                    headers={"Content-Type": "application/json"},
+                    timeout=60,
+                )
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                # Извлекаем текст ответа
+                try:
+                    text = data["candidates"][0]["content"]["parts"][0]["text"]
+                    logger.info(f"✅ Успешный ответ от Gemini (ключ #{key_idx + 1})")
+                    return text
+                except (KeyError, IndexError) as e:
+                    logger.error(f"❌ Ошибка парсинга ответа Gemini: {e} | Ответ: {data}")
+                    continue
+
+            elif response.status_code == 429:
+                logger.warning(f"⚠️ Ключ #{key_idx + 1} превысил лимит (429). Переключаем ключ...")
+                continue
+
+            elif response.status_code == 401 or response.status_code == 403:
+                logger.warning(f"⚠️ Ключ #{key_idx + 1} недействителен ({response.status_code}). Переключаем ключ...")
+                continue
+
+            elif response.status_code == 503:
+                logger.warning(f"⚠️ Сервис Gemini временно недоступен (503). Пробуем другой ключ...")
+                continue
+
+            else:
+                logger.error(f"❌ Ошибка Gemini API (ключ #{key_idx + 1}): {response.status_code} | {response.text[:300]}")
+                continue
+
+        except requests.exceptions.Timeout:
+            logger.error(f"⏰ Таймаут запроса (ключ #{key_idx + 1}). Переключаем ключ...")
+            continue
+        except requests.exceptions.ConnectionError as e:
+            logger.error(f"🔌 Ошибка соединения (ключ #{key_idx + 1}): {e}")
+            continue
+        except Exception as e:
+            logger.error(f"💥 Неожиданная ошибка (ключ #{key_idx + 1}): {e}")
+            traceback.print_exc()
+            continue
+
+    # Если все ключи не сработали
+    return "❌ К сожалению, все доступные ключи API временно недоступны. Попробуйте позже! 🙏"
+
 
 # ============================================================
-# ЯДРО ГЕНЕРАЦИИ ТЕКСТА
+# ПАРСИНГ ОТВЕТА ИИ (кнопки, рисунки и т.д.)
 # ============================================================
-async def get_ai_response(prompt: str, user_name: str = "User", system_prompt: str = None, is_photo: bool = False, max_tokens: int = 512, temperature: float = 0.7):
-    if not system_prompt:
-        system_prompt = (
-            f"You are INAI, an AI created by RID3 (@Rid3_inc). "
-            f"The user's name is {user_name}. Always respond in Russian language. "
-            "For image requests, end your message with [DRAW]: followed by an English description."
-        )
-    
-    # Формируем структуру сообщений
-    messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": prompt}
-    ]
-    
-    # Применяем шаблон чата модели
-    prompt_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-    
-    def generate():
-        inputs = tokenizer(prompt_text, return_tensors="pt").to(model.device)
-        
-        # Генерация ответа
-        outputs = model.generate(
-            **inputs, 
-            max_new_tokens=max_tokens, 
-            temperature=temperature,
-            do_sample=True,
-            pad_token_id=tokenizer.eos_token_id
-        )
-        
-        # Декодируем только новый сгенерированный текст
-        generated_ids = outputs[0][inputs['input_ids'].shape[-1]:]
-        return tokenizer.decode(generated_ids, skip_special_tokens=True)
 
+def parse_ai_response(text: str):
+    """
+    Парсит ответ ИИ:
+    - Извлекает кнопки из [BUTTONS]: [...]
+    - Извлекает промпт для изображения из [DRAW]: описание
+    - Возвращает (чистый текст, список кнопок или None, промпт для картинки или None)
+    """
+    clean_text = text
+    buttons = None
+    draw_prompt = None
+
+    # Ищем кнопки
+    buttons_match = re.search(r'\[BUTTONS\]:\s*(\[.*?\])', text, re.DOTALL)
+    if buttons_match:
+        try:
+            buttons_json = buttons_match.group(1)
+            buttons = json.loads(buttons_json)
+            # Убираем тег из текста
+            clean_text = clean_text.replace(buttons_match.group(0), "").strip()
+        except json.JSONDecodeError as e:
+            logger.warning(f"⚠️ Не удалось распарсить кнопки: {e}")
+            buttons = None
+
+    # Ищем запрос на рисование
+    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()
+
+    # Убираем лишние пустые строки
+    clean_text = re.sub(r'\n{3,}', '\n\n', clean_text).strip()
+
+    return clean_text, buttons, draw_prompt
+
+
+def build_inline_keyboard(buttons: list) -> InlineKeyboardMarkup | None:
+    """
+    Создаёт InlineKeyboardMarkup из списка кнопок.
+    Формат кнопок: [{"text": "...", "action": "..."}]
+    """
+    if not buttons:
+        return None
+
+    keyboard_rows = []
+    row = []
+    for i, btn in enumerate(buttons):
+        button_text = btn.get("text", "Кнопка")
+        button_action = btn.get("action", "action")
+        # Callback data ограничена 64 байтами в Telegram
+        callback_data = f"ai_action:{button_action[:50]}"
+        row.append(InlineKeyboardButton(button_text, callback_data=callback_data))
+
+        # По 2 кнопки в ряд
+        if len(row) == 2 or i == len(buttons) - 1:
+            keyboard_rows.append(row)
+            row = []
+
+    if keyboard_rows:
+        return InlineKeyboardMarkup(keyboard_rows)
+    return None
+
+
+# ============================================================
+# ГЕНЕРАЦИЯ ИЗОБРАЖЕНИЙ (Pollinations.ai — бесплатно)
+# ============================================================
+
+async def generate_image(prompt: str) -> bytes | None:
+    """Генерирует изображение через Pollinations.ai (бесплатно, без API ключа)."""
     try:
-        # Запускаем тяжелую генерацию в отдельном потоке, чтобы не блокировать бота и API
-        text = await asyncio.to_thread(generate)
-        text = text.strip()
-        
-        # Обработка тега рисования
-        img_p = None
-        if "[DRAW]:" in text or is_photo:
-            m = re.search(r'\[DRAW\]:\s*([^\n]+)', text, re.I)
-            img_p = m.group(1).strip() if m else f"{prompt}, high quality digital art"
-            if m: 
-                text = text.replace(m.group(0), "").strip()
-                
-        return text, img_p
+        encoded_prompt = urllib.parse.quote(prompt)
+        # Добавляем случайный seed для разнообразия
+        seed = random.randint(1, 999999)
+        img_url = f"https://image.pollinations.ai/prompt/{encoded_prompt}?nologo=true&seed={seed}&width=1024&height=1024"
+
+        logger.info(f"🎨 Генерирую изображение: {prompt[:100]}...")
+
+        response = await asyncio.to_thread(
+            lambda: requests.get(img_url, timeout=60)
+        )
+
+        if response.status_code == 200 and response.content:
+            logger.info(f"✅ Изображение успешно сгенерировано ({len(response.content)} байт)")
+            return response.content
+        else:
+            logger.error(f"❌ Ошибка генерации изображения: {response.status_code}")
+            return None
+
     except Exception as e:
-        return f"❌ Ошибка генерации: {str(e)}", None
+        logger.error(f"💥 Ошибка при генерации изображения: {e}")
+        return None
+
+
+# ============================================================
+# ХРАНИЛИЩЕ ИСТОРИИ ДИАЛОГОВ (в памяти, для каждого чата)
+# ============================================================
+conversation_history: dict[int, list] = {}
+
+MAX_HISTORY_LENGTH = 20  # Максимум сообщений в истории
+
+
+def get_history(chat_id: int) -> list:
+    """Возвращает историю диалога для чата."""
+    return conversation_history.get(chat_id, [])
+
+
+def add_to_history(chat_id: int, role: str, text: str):
+    """Добавляет сообщение в историю диалога."""
+    if chat_id not in conversation_history:
+        conversation_history[chat_id] = []
+
+    conversation_history[chat_id].append({
+        "role": role,
+        "parts": [{"text": text}]
+    })
+
+    # Обрезаем историю если слишком длинная
+    if len(conversation_history[chat_id]) > MAX_HISTORY_LENGTH:
+        conversation_history[chat_id] = conversation_history[chat_id][-MAX_HISTORY_LENGTH:]
+
+
+def clear_history(chat_id: int):
+    """Очищает историю диалога для чата."""
+    if chat_id in conversation_history:
+        del conversation_history[chat_id]
+
+
+# ============================================================
+# ПРОВЕРКА: ДОЛЖЕН ЛИ ИИ ОТВЕЧАТЬ НА ЭТО СООБЩЕНИЕ?
+# ============================================================
+
+def should_ai_respond(message_text: str, is_group: bool, is_reply_to_bot: bool) -> tuple[bool, str]:
+    """
+    Проверяет, должен ли ИИ ответить на сообщение.
+    Возвращает (должен_отвечать, очищенный_запрос)
+    """
+    if not message_text:
+        return False, ""
+
+    text_lower = message_text.lower().strip()
+
+    # В личных сообщениях ИИ отвечает всегда
+    if not is_group:
+        return True, message_text
+
+    # В группах — только если это ответ на сообщение бота
+    if is_reply_to_bot:
+        return True, message_text
+
+    # В группах — проверяем наличие триггерных слов
+    for keyword in AI_TRIGGER_KEYWORDS:
+        if text_lower.startswith(keyword):
+            # Убираем триггерное слово из начала
+            cleaned = re.sub(
+                r'^' + re.escape(keyword) + r'[,\s]*',
+                '',
+                message_text,
+                flags=re.IGNORECASE
+            ).strip()
+            return True, cleaned if cleaned else message_text
+
+        if keyword in text_lower and len(keyword) > 3:
+            # Для более длинных ключевых слов — проверяем вхождение
+            return True, message_text
+
+    return False, ""
+
 
 # ============================================================
-# ФУНКЦИИ МУЛЬТИМЕДИА (Бесплатно, без API ключей)
+# ОБРАБОТЧИКИ КОМАНД
 # ============================================================
-async def generate_voice(text: str):
-    def sync_tts():
-        clean = re.sub(r'[*_`#]', '', text) # Убираем markdown
-        tts = gTTS(text=clean, lang='ru', slow=False)
-        fp = io.BytesIO()
-        tts.write_to_fp(fp)
-        fp.name = 'voice.ogg'
-        fp.seek(0)
-        return fp
-    return await asyncio.to_thread(sync_tts)
+
+async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Обработчик команды /start."""
+    user = update.effective_user
+    first_name = user.first_name if user else "Пользователь"
+
+    welcome_text = (
+        f"👋 Привет, {first_name}! Я — **INAI #RID3** 🤖✨\n\n"
+        f"🧠 Я искусственный интеллект, созданный **RID3 СЕРВИСАМИ**\n"
+        f"💻 Моя главная специализация — **программирование и технологии**!\n\n"
+        f"**Что я умею:**\n"
+        f"🔹 Помогать с кодом (Python, JS, Rust, Go, C++ и многое другое)\n"
+        f"🔹 Объяснять концепции программирования\n"
+        f"🔹 Дебажить и оптимизировать код\n"
+        f"🔹 Создавать изображения по запросу 🎨\n"
+        f"🔹 Отвечать на любые вопросы\n\n"
+        f"**В группах** — напишите **INAI**, **AI**, **БОТ** или ответьте на моё сообщение!\n\n"
+        f"💡 Просто напишите мне что-нибудь, и я помогу! 🚀"
+    )
+
+    keyboard = InlineKeyboardMarkup([
+        [
+            InlineKeyboardButton("💻 Пример кода", callback_data="example:code"),
+            InlineKeyboardButton("🎨 Нарисовать", callback_data="example:draw"),
+        ],
+        [
+            InlineKeyboardButton("❓ Как использовать", callback_data="example:help"),
+            InlineKeyboardButton("🗑️ Очистить историю", callback_data="action:clear_history"),
+        ],
+    ])
+
+    await update.message.reply_text(
+        welcome_text,
+        parse_mode=ParseMode.MARKDOWN,
+        reply_markup=keyboard,
+    )
+
+
+async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Обработчик команды /help."""
+    help_text = (
+        "📚 **Справка по INAI #RID3**\n\n"
+        "**Команды:**\n"
+        "🔸 `/start` — Начать работу с ботом\n"
+        "🔸 `/help` — Показать эту справку\n"
+        "🔸 `/clear` — Очистить историю диалога\n"
+        "🔸 `/draw [описание]` — Сгенерировать изображе��ие\n\n"
+        "**Как общаться в группах:**\n"
+        "✅ Начните сообщение с: `INAI`, `AI`, `ИИ`, `БОТ`, `BOT`\n"
+        "✅ Ответьте на моё сообщение\n\n"
+        "**Примеры запросов:**\n"
+        "💬 `INAI, напиши функцию сортировки на Python`\n"
+        "💬 `AI помоги с этим кодом`\n"
+        "💬 `нарисуй красивый закат на море`\n\n"
+        "🔥 **Специализация:** Программирование и технологии\n"
+        "🎨 **Дополнительно:** Генерация изображений\n\n"
+        "Создан RID3 СЕРВИСАМИ (@Rid3_inc) 🚀"
+    )
+
+    await update.message.reply_text(help_text, parse_mode=ParseMode.MARKDOWN)
+
+
+async def clear_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Обработчик команды /clear — очищает историю диалога."""
+    chat_id = update.effective_chat.id
+    clear_history(chat_id)
+
+    await update.message.reply_text(
+        "🗑️ История диалога очищена! Начинаем с чистого листа ✨\n"
+        "Чем могу помочь? 💻"
+    )
+
+
+async def draw_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Обработчик команды /draw — генерирует изображение."""
+    if not context.args:
+        await update.message.reply_text(
+            "🎨 Укажите описание изображения!\n"
+            "Пример: `/draw красивый закат на море, цифровое искусство`",
+            parse_mode=ParseMode.MARKDOWN,
+        )
+        return
+
+    prompt = " ".join(context.args)
+    await handle_image_generation(update, context, prompt, original_text=prompt)
+
 
 # ============================================================
-# РОУТЫ FASTAPI
+# ОСНОВНОЙ ОБРАБОТЧИК СООБЩЕНИЙ
 # ============================================================
-@app.get("/")
-async def health():
-    return {"status": "online", "message": f"API & Telegram Bot are running on {MODEL_ID}. Use POST /chat"}
 
-@app.post("/chat")
-async def chat(request: ChatRequest):
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Обрабатывает входящие текстовые сообщения."""
+    if not update.message:
+        return
+
+    message = update.message
+    chat_id = update.effective_chat.id
+    user = update.effective_user
+    user_name = user.first_name if user else "Пользователь"
+
+    # Получаем текст сообщения
+    message_text = message.text or message.caption or ""
+    if not message_text:
+        return
+
+    # Определяем тип чата
+    is_group = message.chat.type in ["group", "supergroup"]
+    is_channel = message.chat.type == "channel"
+
+    # В каналах не отвечаем
+    if is_channel:
+        return
+
+    # Проверяем — это ответ на сообщение бота?
+    is_reply_to_bot = (
+        message.reply_to_message is not None
+        and message.reply_to_message.from_user is not None
+        and message.reply_to_message.from_user.is_bot
+        and message.reply_to_message.from_user.username == context.bot.username
+    )
+
+    # Определяем — должен ли ИИ отвечать
+    should_respond, cleaned_query = should_ai_respond(message_text, is_group, is_reply_to_bot)
+
+    if not should_respond:
+        # ИИ не должен отвечать — отвечает программа
+        if is_group:
+            # В группах не спамим каждым сообщением
+            # Отвечаем только если упомянули бота но без запроса
+            text_lower = message_text.lower()
+            for keyword in AI_TRIGGER_KEYWORDS[:6]:  # Только основные ключевые слова
+                if text_lower.startswith(keyword) and not cleaned_query:
+                    await message.reply_text(
+                        "💬 Привет! Я здесь 👋\n"
+                        "Задайте мне вопрос или напишите что нужно сделать!\n"
+                        "Например: `INAI, помоги с кодом на Python` 💻",
+                        parse_mode=ParseMode.MARKDOWN,
+                    )
+                    return
+        return
+
+    # Проверяем — запрос на изображение?
+    query_lower = cleaned_query.lower()
+    wants_image = any(kw in query_lower for kw in IMAGE_KEYWORDS)
+
+    # Показываем индикатор "печатает..."
+    await context.bot.send_chat_action(chat_id=chat_id, action=ChatAction.TYPING)
+
+    # Добавляем сообщение пол��зователя в историю
+    add_to_history(chat_id, "user", cleaned_query)
+
+    # Отправляем статус
+    status_message = await message.reply_text("💠 INAI думает... 🧠")
+
     try:
-        text, _ = await get_ai_response(
-            prompt=request.prompt, 
-            system_prompt=request.system_prompt,
-            max_tokens=request.max_tokens,
-            temperature=request.temperature
+        # Получаем ответ от Gemini
+        history = get_history(chat_id)
+        # Убираем последнее сообщение из истории (оно будет передано как prompt)
+        history_without_last = history[:-1] if history else []
+
+        ai_response = await call_gemini_api(
+            prompt=cleaned_query,
+            history=history_without_last if history_without_last else None,
         )
-        return {"response": text, "model": MODEL_ID}
+
+        # Парсим ответ ИИ
+        clean_text, buttons, draw_prompt = parse_ai_response(ai_response)
+
+        # Добавляем ответ ИИ в историю
+        add_to_history(chat_id, "model", clean_text)
+
+        # Проверяем — хочет ли ИИ нарисовать картинку
+        if draw_prompt or wants_image:
+            final_draw_prompt = draw_prompt if draw_prompt else cleaned_query
+            await handle_image_generation(
+                update, context,
+                prompt=final_draw_prompt,
+                original_text=clean_text,
+                buttons=buttons,
+                status_message=status_message,
+            )
+            return
+
+        # Формируем клавиатуру если ИИ предложил кнопки
+        keyboard = build_inline_keyboard(buttons) if buttons else None
+
+        # Отправляем текстовый ответ
+        # Разбиваем на части если слишком длинный (лимит Telegram — 4096 символов)
+        if len(clean_text) > 4000:
+            parts = split_text(clean_text, max_length=4000)
+            # Первая часть — редактируем статус
+            await status_message.edit_text(
+                parts[0],
+                parse_mode=ParseMode.MARKDOWN,
+            )
+            # Остальные части — отправляем новыми сообщениями
+            for part in parts[1:]:
+                await message.reply_text(part, parse_mode=ParseMode.MARKDOWN)
+            # Кнопки добавляем к последнему сообщению
+            if keyboard:
+                await message.reply_text(
+                    "💡 Выберите дальнейшее действие:",
+                    reply_markup=keyboard,
+                )
+        else:
+            await status_message.edit_text(
+                clean_text,
+                parse_mode=ParseMode.MARKDOWN,
+                reply_markup=keyboard,
+            )
+
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"💥 Ошибка обработки сообщения: {e}")
+        traceback.print_exc()
+        try:
+            await status_message.edit_text(
+                f"❌ Упс! Что-то пошло не так 😅\n"
+                f"Попробуйте ещё раз или напишите `/clear` для сброса диалога."
+            )
+        except Exception:
+            pass
+
 
 # ============================================================
-# ОБРАБОТЧИКИ ТЕЛЕГРАМ БОТА
+# ОБРАБОТЧИК ГЕНЕРАЦИИ ИЗОБРАЖЕНИЙ
 # ============================================================
-@bot.on_message((filters.text | filters.caption) & ~filters.me)
-async def main_handler(client, message):
+
+async def handle_image_generation(
+    update: Update,
+    context: ContextTypes.DEFAULT_TYPE,
+    prompt: str,
+    original_text: str = None,
+    buttons: list = None,
+    status_message=None,
+):
+    """Генерирует и отправляет изображение."""
+    message = update.message
+    chat_id = update.effective_chat.id
+
     try:
-        text = message.text or message.caption or ""
-        is_group = message.chat.type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]
-        
-        user_query = text
-        should_respond = not is_group
-        
-        if is_group:
-            triggers = ["inai", "инэй", "бот"]
-            if any(text.lower().startswith(t) for t in triggers):
-                should_respond = True
-                user_query = re.sub(r"^(inai|инэй|бот)\s*", "", text, flags=re.IGNORECASE)
-            elif message.reply_to_message and message.reply_to_message.from_user.is_self:
-                should_respond = True
-
-        if not should_respond or not user_query.strip(): 
-            return
+        # Обновляем статус
+        if status_message:
+            await status_message.edit_text("🎨 Рисую... Подождите немного! ✨")
+        else:
+            status_message = await message.reply_text("🎨 Рисую... Подождите немного! ✨")
+
+        # Показываем действие загрузки фото
+        await context.bot.send_chat_action(chat_id=chat_id, action=ChatAction.UPLOAD_PHOTO)
+
+        # Генерируем изображение
+        image_bytes = await generate_image(prompt)
+
+        if image_bytes:
+            # Удаляем статусное сообщение
+            try:
+                await status_message.delete()
+            except Exception:
+                pass
+
+            # Формируем подпись
+            caption_text = ""
+            if original_text and original_text.strip():
+                caption_text = original_text[:900]  # Лимит подписи — 1024 символа
+                caption_text += f"\n\n🎨 *Запрос:* _{prompt[:100]}_"
+            else:
+                caption_text = f"🎨 Вот твоё изображение!\n\n*Запрос:* _{prompt[:200]}_"
+
+            # Формируем клавиатуру
+            keyboard = build_inline_keyboard(buttons) if buttons else InlineKeyboardMarkup([
+                [
+                    InlineKeyboardButton("🔄 Перегенерировать", callback_data=f"regen:{prompt[:50]}"),
+                    InlineKeyboardButton("💬 Задать вопрос", callback_data="action:ask_question"),
+                ]
+            ])
+
+            # Отправляем изображение
+            await message.reply_photo(
+                photo=io.BytesIO(image_bytes),
+                caption=caption_text,
+                parse_mode=ParseMode.MARKDOWN,
+                reply_markup=keyboard,
+            )
 
-        is_photo = any(kw in user_query.lower() for kw in ["нарисуй", "фото", "рисуй", "картинка"])
-        is_audio = any(kw in user_query.lower() for kw in ["скажи", "озвучь", "голос"])
+        else:
+            # Ошибка генерации
+            error_text = (
+                "😕 Не удалось сгенерировать изображение.\n"
+                "Попробуйте изменить описание или повторите запрос чуть позже!\n\n"
+                "💡 *Совет:* Попробуйте более подробное описание на английском языке."
+            )
+            if original_text:
+                error_text = original_text + "\n\n" + error_text
 
-        status = await message.reply_text("💠 INAI думает (может занять время на CPU)...")
+            keyboard = build_inline_keyboard(buttons)
+            await status_message.edit_text(
+                error_text,
+                parse_mode=ParseMode.MARKDOWN,
+                reply_markup=keyboard,
+            )
 
-        ai_text, img_prompt = await get_ai_response(
-            prompt=user_query, 
-            user_name=message.from_user.first_name, 
-            is_photo=is_photo
+    except Exception as e:
+        logger.error(f"💥 Ошибка при отправке изображения: {e}")
+        traceback.print_exc()
+        try:
+            await status_message.edit_text(
+                "❌ Ошибка при генерации изображения 😅\n"
+                "Попробуйте ещё раз!"
+            )
+        except Exception:
+            pass
+
+
+# ============================================================
+# ОБРАБОТЧИК НАЖАТИЙ НА КНОПКИ
+# ============================================================
+
+async def handle_callback_query(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Обрабатывает нажатия на inline-кнопки."""
+    query = update.callback_query
+    await query.answer()  # Убираем "часики" на кнопке
+
+    data = query.data
+    chat_id = update.effective_chat.id
+    user = update.effective_user
+    user_name = user.first_name if user else "Пользователь"
+
+    logger.info(f"📲 Нажата кнопка: {data} (пользователь: {user_name})")
+
+    # ---- Действия с историей ----
+    if data == "action:clear_history":
+        clear_history(chat_id)
+        await query.edit_message_text(
+            "🗑️ История диалога очищена! Начинаем с чистого листа ✨\n"
+            "Чем могу помочь? 💻"
         )
+        return
 
-        if is_audio and ai_text:
-            await status.edit_text("🎤 Генерирую голос...")
-            voice = await generate_voice(ai_text)
-            if voice:
-                await message.reply_voice(voice, caption="🔊 INAI Voice")
-                await status.delete()
-                return
-
-        if img_prompt:
-            await status.edit_text("🎨 Рисую...")
-            img_url = f"https://image.pollinations.ai/prompt/{urllib.parse.quote(img_prompt)}?nologo=true"
-            res = await asyncio.to_thread(lambda: requests.get(img_url, timeout=40))
-            if res.status_code == 200:
-                await message.reply_photo(io.BytesIO(res.content), caption=f"✨ {ai_text}"[:1024])
+    # ---- Пример использования ----
+    if data == "example:code":
+        await query.edit_message_text(
+            "💻 **Примеры запросов для кода:**\n\n"
+            "🔸 `Напиши функцию быстрой сортировки на Python`\n"
+            "🔸 `Как исправить эту ошибку: TypeError...`\n"
+            "🔸 `Объясни разницу между async/await и threading`\n"
+            "🔸 `Создай REST API на FastAPI`\n"
+            "🔸 `Напиши SQL запрос для выборки топ-10 пользователей`\n\n"
+            "Просто напишите мне свой запрос! 🚀",
+            parse_mode=ParseMode.MARKDOWN,
+        )
+        return
+
+    if data == "example:draw":
+        await query.edit_message_text(
+            "🎨 **Примеры запросов для генерации изображений:**\n\n"
+            "🔸 `нарисуй красивый закат на море`\n"
+            "🔸 `создай картинку кибер-города будущего`\n"
+            "🔸 `нарисуй котёнка программиста за ноутбуком`\n"
+            "🔸 `/draw futuristic robot in neon city, digital art`\n\n"
+            "Или просто напишите мне что хотите увидеть! ✨",
+            parse_mode=ParseMode.MARKDOWN,
+        )
+        return
+
+    if data == "example:help":
+        await query.edit_message_text(
+            "❓ **Как использовать INAI #RID3:**\n\n"
+            "**В личных сообщениях:**\n"
+            "✅ Просто напишите любой вопрос или задачу\n\n"
+            "**В группах:**\n"
+            "✅ Начните с: `INAI`, `AI`, `ИИ`, `БОТ`\n"
+            "✅ Или ответьте на моё сообщение\n\n"
+            "**Специальные команды:**\n"
+            "🔸 `/start` — Начать\n"
+            "🔸 `/help` — Справка\n"
+            "🔸 `/clear` — Очистить историю\n"
+            "🔸 `/draw [описание]` — Нарисовать\n\n"
+            "**Я лучше всего умею:**\n"
+            "💻 Помогать с программированием\n"
+            "🔧 Дебажить код\n"
+            "📚 Объяснять концепции\n"
+            "🎨 Создавать изображения\n\n"
+            "Создан RID3 СЕРВИСАМИ (@Rid3_inc) 🚀",
+            parse_mode=ParseMode.MARKDOWN,
+        )
+        return
+
+    if data == "action:ask_question":
+        await query.message.reply_text(
+            "💬 Задайте мне вопрос! Я готов помочь 🤖✨\n\n"
+            "Могу помочь с программированием, объяснить что-то,\n"
+            "или создать ещё одно изображение по вашему описанию 🎨"
+        )
+        return
+
+    # ---- Перегенерация изображения ----
+    if data.startswith("regen:"):
+        original_prompt = data[6:]
+        await query.message.reply_text("🔄 Генерирую новый вариант... ✨")
+        # Создаём фиктивный update для передачи в handle_image_generation
+        await handle_image_generation(
+            update=update,
+            context=context,
+            prompt=original_prompt,
+            original_text=f"🔄 Новый вариант изображения по запросу: _{original_prompt}_",
+        )
+        return
+
+    # ---- Действия от ИИ (динамические кнопки) ----
+    if data.startswith("ai_action:"):
+        action = data[10:]  # Убираем префикс "ai_action:"
+
+        # Показываем статус
+        await context.bot.send_chat_action(chat_id=chat_id, action=ChatAction.TYPING)
+        status = await query.message.reply_text("💠 INAI обрабатывает ваш выбор... 🧠")
+
+        # Отправляем действие как запрос к ИИ
+        action_prompt = f"Пользователь нажал кнопку с действием: '{action}'. Выполни это действие или ответь на выбор пользователя."
+        add_to_history(chat_id, "user", action_prompt)
+
+        history = get_history(chat_id)
+        history_without_last = history[:-1] if history else []
+
+        ai_response = await call_gemini_api(
+            prompt=action_prompt,
+            history=history_without_last if history_without_last else None,
+        )
+
+        clean_text, new_buttons, draw_prompt = parse_ai_response(ai_response)
+        add_to_history(chat_id, "model", clean_text)
+
+        # Если ИИ хочет нарисовать
+        if draw_prompt:
+            try:
                 await status.delete()
-                return
+            except Exception:
+                pass
+            await handle_image_generation(
+                update=update,
+                context=context,
+                prompt=draw_prompt,
+                original_text=clean_text,
+                buttons=new_buttons,
+            )
+            return
+
+        # Обычный текстовый ответ
+        keyboard = build_inline_keyboard(new_buttons)
+        try:
+            await status.edit_text(
+                clean_text,
+                parse_mode=ParseMode.MARKDOWN,
+                reply_markup=keyboard,
+            )
+        except Exception:
+            # Если текст не поддерживает Markdown — отправляем без форматирования
+            await status.edit_text(clean_text, reply_markup=keyboard)
+        return
+
+    # Неизвестная кнопка
+    logger.warning(f"⚠️ Неизвестный callback: {data}")
+    await query.answer("⚠️ Неизвестное действие", show_alert=False)
+
+
+# ============================================================
+# ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ
+# ============================================================
+
+def split_text(text: str, max_length: int = 4000) -> list[str]:
+    """Разбивает длинный текст на части для отправки в Telegram."""
+    if len(text) <= max_length:
+        return [text]
+
+    parts = []
+    while text:
+        if len(text) <= max_length:
+            parts.append(text)
+            break
 
-        await status.edit_text(ai_text or "⚠️ Пустой ответ.")
+        # Ищем подходящее место для разрыва (по абзацу или предложению)
+        split_pos = max_length
+
+        # Пробуем разбить по двойному переносу строки
+        pos = text.rfind('\n\n', 0, max_length)
+        if pos > max_length // 2:
+            split_pos = pos + 2
+        else:
+            # Пробуем по одиночному переносу строки
+            pos = text.rfind('\n', 0, max_length)
+            if pos > max_length // 2:
+                split_pos = pos + 1
+            else:
+                # Пробуем по точке
+                pos = text.rfind('. ', 0, max_length)
+                if pos > max_length // 2:
+                    split_pos = pos + 2
+
+        parts.append(text[:split_pos])
+        text = text[split_pos:]
+
+    return parts
+
+
+# ============================================================
+# ОБРАБОТЧИК ОШИБОК
+# ============================================================
+
+async def error_handler(update: object, context: ContextTypes.DEFAULT_TYPE):
+    """Глобальный обработчик ошибок."""
+    logger.error(f"💥 Ошибка при обработке обновления: {context.error}")
+    traceback.print_exc()
 
-    except Exception:
-        print(traceback.format_exc())
 
 # ============================================================
-# АСИНХРОННЫЙ ЗАПУСК
+# ЗАПУСК БОТА
 # ============================================================
-async def main():
-    print("🚀 Запуск Telegram бота...")
-    await bot.start()
-    
-    print("🌐 Запуск FastAPI сервера на порту 7860...")
-    config = uvicorn.Config(app=app, host="0.0.0.0", port=7860, log_level="info")
-    server = uvicorn.Server(config)
-    
-    await server.serve()
-    
-    print("🛑 Остановка бота...")
-    await bot.stop()
+
+def main():
+    """Точка входа — запуск Telegram бота."""
+    print("=" * 60)
+    print("🤖 INAI #RID3 — Telegram Bot")
+    print("🏢 Создан RID3 СЕРВИСАМИ")
+    print("🧠 Модель: Gemini 2.5 Flash")
+    print("=" * 60)
+
+    # Проверяем наличие ключей
+    valid_keys = [k for k in GEMINI_API_KEYS if k and not k.startswith("ЗАМЕНИТЕ")]
+    if not valid_keys:
+        print("❌ ОШИБКА: Не указаны ключи Gemini API!")
+        print("   Добавьте ваши ключи в список GEMINI_API_KEYS")
+        print("   Получить ключи: https://aistudio.google.com/app/apikey")
+        return
+
+    print(f"✅ Загружено {len(valid_keys)} ключей Gemini API")
+    print(f"🚀 Запускаю бота...")
+
+    # Создаём приложение
+    application = (
+        Application.builder()
+        .token(BOT_TOKEN)
+        .build()
+    )
+
+    # Регистрируем обработчики команд
+    application.add_handler(CommandHandler("start", start_command))
+    application.add_handler(CommandHandler("help", help_command))
+    application.add_handler(CommandHandler("clear", clear_command))
+    application.add_handler(CommandHandler("draw", draw_command))
+
+    # Регистрируем обработчик нажатий на кнопки
+    application.add_handler(CallbackQueryHandler(handle_callback_query))
+
+    # Регистрируем обработчик текстовых сообщений
+    application.add_handler(
+        MessageHandler(
+            filters.TEXT & ~filters.COMMAND,
+            handle_message,
+        )
+    )
+
+    # Регистрируем глобальный обработчик ошибок
+    application.add_error_handler(error_handler)
+
+    print("✅ Бот успешно запущен! Нажмите Ctrl+C для остановки.")
+    print("=" * 60)
+
+    # Запускаем polling
+    application.run_polling(
+        allowed_updates=Update.ALL_TYPES,
+        drop_pending_updates=True,
+    )
+
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    main()