User: Анализ файла tmpi5j_mczn.txt:

Подпись к файлу: Ответ превысил лимит символов и был отправлен в виде файла

Содержимое:
Понял вашу задачу. Вы хотите, чтобы все веб-страницы, полученные через поиск в интернете, передавались модели GPT-4o для дальнейшего анализа и формирования ответов пользователю. Ниже представлен полный обновлённый код вашего Telegram-бота, соответствующий вашим требованиям.

```python
import logging
import asyncio
import os
import aiosqlite  # Асинхронный доступ к SQLite
import aiohttp  # Асинхронные HTTP-запросы
from datetime import datetime, timedelta
from typing import Dict, List

from aiogram import Bot, Dispatcher, types
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup

# Импорт настроек из config.py
import config

# Импорт клиентов API
from sparrow_api import SparrowAPI
from gpt4o_api import GPT4OAPI
from forgetapi import ForgetAPI
from image_api import ImageAPI

# Импорт AudioProcessor из audio_processing.py
from audio_processing import AudioProcessor

# Импорт функций из doc.py
from doc import process_file_content, send_long_message, build_context, SUPPORTED_EXTENSIONS

# Дополнительные импорты
import xlsxwriter
from bs4 import BeautifulSoup
from urllib.parse import quote_plus  # Для URL-кодирования

# Настройка логирования
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Классы состояний для FSM
class Form(StatesGroup):
    ImageGenerationPrompt = State()
    ImageGenerationSize = State()
    # Состояния для Админ-Панели
    AdminPanel = State()
    SelectTariffForEdit = State()
    EditTariffNameOrDescription = State()
    EditTariffName = State()
    EditTariffDescription = State()
    EditTariffTokens = State()
    BroadcastMessageState = State()
    BroadcastSelectTariff = State()
    EditTariffTokenAmount = State()
    # Новые состояния для управления чатами
    ManageChats = State()
    AddChat = State()
    DeleteChat = State()
    # Состояния для генерации отчёта
    GenerateReport = State()

class EnhancedBot:
    MAX_MESSAGE_LENGTH = 4000  # Максимальная длина сообщения

    # Доступные модели и их API
    ALL_AVAILABLE_MODELS = [
        ("GPT-4o", "gpt-4o-2024-08-06", "gpt4o"),
        ("o1-preview", "o1-preview", "forget"),
        ("o1-mini", "o1-mini", "forget"),
        ("GPT 4o Mini", "gpt-4o-mini", "forget"),
        ("GPT 3.5 turbo", "gpt-3.5-turbo", "forget"),
        # Добавьте другие модели по необходимости
    ]

    FREE_MODELS = ALL_AVAILABLE_MODELS  # Теперь все модели доступны бесплатно

    def __init__(self):
        self.bot = Bot(token=config.BOT_TOKEN)
        self.storage = MemoryStorage()
        self.dp = Dispatcher(self.bot, storage=self.storage)
        self.sparrow = SparrowAPI()
        self.gpt4o_api = GPT4OAPI()
        self.forget_api = ForgetAPI()
        self.image_api = ImageAPI()
        self.audio_processor = AudioProcessor(self.bot)
        self.conversations: Dict[str, List[str]] = {}
        self.waiting_messages: Dict[str, types.Message] = {}
        self.user_tasks: Dict[str, asyncio.Task] = {}
        self.db_connection = None  # Инициализируем позже в асинхронном методе
        self.db_cursor = None
        self._setup_handlers()

        # Инициализация API клиентов
        self.api_clients = {
            "sparrow": self.sparrow,
            "gpt4o": self.gpt4o_api,
            "forget": self.forget_api,
            "image": self.image_api,
        }

        # Создание маппинга модель -> API
        self.MODEL_API_MAPPING = {
            model_id: api_name for (_, model_id, api_name) in self.ALL_AVAILABLE_MODELS
        }

    async def _setup_database(self):
        # Асинхронное подключение к базе данных и создание таблиц
        self.db_connection = await aiosqlite.connect('user_data.db')
        self.db_cursor = await self.db_connection.cursor()

        # Создание таблицы для хранения данных пользователей
        await self.db_cursor.execute('''
            CREATE TABLE IF NOT EXISTS users (
                user_id TEXT PRIMARY KEY,
                is_subscribed INTEGER DEFAULT 0,
                model TEXT DEFAULT 'gpt-4-turbo',
                tariff_plan TEXT DEFAULT 'free',
                tokens_available INTEGER DEFAULT 3000,
                last_token_refresh DATETIME,
                group_association TEXT
            )
        ''')
        # Создание таблицы для тарифных планов
        await self.db_cursor.execute('''
            CREATE TABLE IF NOT EXISTS tariff_plans (
                tariff_id TEXT PRIMARY KEY,
                name TEXT,
                description TEXT,
                daily_tokens INTEGER
            )
        ''')
        # Создание таблицы для премиум-чатов
        await self.db_cursor.execute('''
            CREATE TABLE IF NOT EXISTS premium_chats (
                chat_id INTEGER PRIMARY KEY
            )
        ''')
        # Инициализируем тарифные планы, если таблица пуста
        async with self.db_connection.execute('SELECT COUNT(*) FROM tariff_plans') as cursor:
            row = await cursor.fetchone()
            if row and row[0] == 0:
                await self.db_connection.executemany('''
                    INSERT INTO tariff_plans (tariff_id, name, description, daily_tokens) VALUES (?, ?, ?, ?)
                ''', [
                    ('free', 'FREE', 'Стандартный тариф с ограниченным набором функций.', 3000),
                    ('premium', 'Premium', 'Расширенный тариф с дополнительными возможностями.', 100000),
                    ('admin', 'ADMIN', 'Неограниченный доступ для администраторов.', -1)
                ])
                await self.db_connection.commit()
        # Инициализируем премиум-чаты, если таблица пуста
        async with self.db_connection.execute('SELECT COUNT(*) FROM premium_chats') as cursor:
            row = await cursor.fetchone()
            if row and row[0] == 0:
                await self.db_connection.executemany('''
                    INSERT INTO premium_chats (chat_id) VALUES (?)
                ''', [
                    (-1002413809826,),
                    (-1002482241267,)
                ])
                await self.db_connection.commit()
        await self.db_connection.commit()

    def get_tariff_info_sync(self, tariff_id: str):
        # Получение информации о тарифе из памяти
        # Для асинхронной базы данных этот метод лучше сделать асинхронным.
        # Здесь оставлено синхронное обращение для совместимости.
        async def inner():
            async with self.db_connection.execute('SELECT name, description, daily_tokens FROM tariff_plans WHERE tariff_id = ?', (tariff_id,)) as cursor:
                result = await cursor.fetchone()
                if result:
                    return {'name': result[0], 'description': result[1], 'daily_tokens': result[2]}
                else:
                    return None
        return asyncio.run(inner())

    async def set_tariff_info(self, tariff_id: str, name: str = None, description: str = None, daily_tokens: int = None):
        # Установка информации о тарифе
        if name:
            await self.db_connection.execute('UPDATE tariff_plans SET name = ? WHERE tariff_id = ?', (name, tariff_id))
        if description:
            await self.db_connection.execute('UPDATE tariff_plans SET description = ? WHERE tariff_id = ?', (description, tariff_id))
        if daily_tokens is not None:
            await self.db_connection.execute('UPDATE tariff_plans SET daily_tokens = ? WHERE tariff_id = ?', (daily_tokens, tariff_id))
        await self.db_connection.commit()

    async def is_user_subscribed(self, user_id: str) -> bool:
        # Проверка подписки пользователя
        async with self.db_connection.execute('SELECT is_subscribed FROM users WHERE user_id = ?', (user_id,)) as cursor:
            result = await cursor.fetchone()
            if result:
                return bool(result[0])
            else:
                return False

    async def set_user_subscription(self, user_id: str, is_subscribed: bool):
        # Установка статуса подписки пользователя
        await self.db_connection.execute('''
            INSERT INTO users (user_id, is_subscribed) VALUES (?, ?)
            ON CONFLICT(user_id) DO UPDATE SET is_subscribed=excluded.is_subscribed
        ''', (user_id, int(is_subscribed)))
        await self.db_connection.commit()

    async def get_user_model(self, user_id: str) -> str:
        # Получение выбранной модели пользователя
        async with self.db_connection.execute('SELECT model FROM users WHERE user_id = ?', (user_id,)) as cursor:
            result = await cursor.fetchone()
            if result:
                return result[0]
            else:
                # Устанавливаем модель по умолчанию в соответствии с тарифом
                return 'gpt-4-turbo'  # Модель по умолчанию

    async def set_user_model(self, user_id: str, model: str):
        # Установка выбранной модели пользователя
        await self.db_connection.execute('''
            INSERT INTO users (user_id, model) VALUES (?, ?)
            ON CONFLICT(user_id) DO UPDATE SET model=excluded.model
        ''', (user_id, model))
        await self.db_connection.commit()

    async def get_user_tariff_plan(self, user_id: str) -> str:
        # Получение тарифного плана пользователя
        async with self.db_connection.execute('SELECT tariff_plan FROM users WHERE user_id = ?', (user_id,)) as cursor:
            result = await cursor.fetchone()
            if result:
                return result[0]
            else:
                return 'free'  # Тариф по умолчанию

    async def set_user_tariff_plan(self, user_id: str, tariff_plan: str):
        # Установка тарифного плана пользователя
        # Также выполняем перерасчет токенов при смене тарифного плана
        previous_tariff_plan = await self.get_user_tariff_plan(user_id)
        await self.db_connection.execute('''
            INSERT INTO users (user_id, tariff_plan) VALUES (?, ?)
            ON CONFLICT(user_id) DO UPDATE SET tariff_plan=excluded.tariff_plan
        ''', (user_id, tariff_plan))
        await self.db_connection.commit()
        if previous_tariff_plan != tariff_plan:
            await self.set_last_token_refresh(user_id, None)
            asyncio.create_task(self.refresh_user_tokens(user_id))

    async def get_user_tokens(self, user_id: str) -> int:
        # Получение количества токенов пользователя
        async with self.db_connection.execute('SELECT tokens_available FROM users WHERE user_id = ?', (user_id,)) as cursor:
            result = await cursor.fetchone()
            if result:
                return result[0]
            else:
                # Устанавливаем токены по умолчанию в соответствии с тарифом
                tariff_plan = await self.get_user_tariff_plan(user_id)
                tariff_info = await self.get_tariff_info(tariff_plan)
                return tariff_info['daily_tokens'] if tariff_info else 3000

    async def set_user_tokens(self, user_id: str, tokens: int):
        # Установка количества токенов пользователя
        await self.db_connection.execute('''
            INSERT INTO users (user_id, tokens_available) VALUES (?, ?)
            ON CONFLICT(user_id) DO UPDATE SET tokens_available=excluded.tokens_available
        ''', (user_id, tokens))
        await self.db_connection.commit()

    async def get_last_token_refresh(self, user_id: str) -> datetime:
        # Получение даты последнего обновления токенов
        async with self.db_connection.execute('SELECT last_token_refresh FROM users WHERE user_id = ?', (user_id,)) as cursor:
            result = await cursor.fetchone()
            if result and result[0]:
                return datetime.strptime(result[0], '%Y-%m-%d %H:%M:%S.%f')
            else:
                return None

    async def set_last_token_refresh(self, user_id: str, date: datetime):
        # Установка даты последнего обновления токенов
        date_str = date.strftime('%Y-%m-%d %H:%M:%S.%f') if date else None
        await self.db_connection.execute('''
            INSERT INTO users (user_id, last_token_refresh) VALUES (?, ?)
            ON CONFLICT(user_id) DO UPDATE SET last_token_refresh=excluded.last_token_refresh
        ''', (user_id, date_str))
        await self.db_connection.commit()

    async def refresh_user_tokens(self, user_id: str):
        # Обновление токенов пользователя ежедневно
        last_refresh = await self.get_last_token_refresh(user_id)
        now = datetime.now()
        if not last_refresh or (now - last_refresh).days >= 1:
            tariff_plan = await self.get_user_tariff_plan(user_id)
            tariff_info = await self.get_tariff_info(tariff_plan)
            tokens = tariff_info['daily_tokens'] if tariff_info else 3000
            await self.set_user_tokens(user_id, tokens)
            await self.set_last_token_refresh(user_id, now)

    async def check_and_update_tariff_plan(self, user_id: str):
        # Проверка и обновление тарифного плана пользователя
        telegram_user_id = int(user_id)
        is_admin = telegram_user_id in config.ADMIN_IDS

        if is_admin:
            await self.set_user_tariff_plan(user_id, 'admin')
        else:
            # Получаем список премиум-чатов из базы данных
            async with self.db_connection.execute('SELECT chat_id FROM premium_chats') as cursor:
                premium_chat_ids = [row[0] for row in await cursor.fetchall()]

            # Проверяем, состоит ли пользователь в одной из премиум-групп
            is_premium_member = False
            for group_id in premium_chat_ids:
                try:
                    chat_member = await self.bot.get_chat_member(chat_id=group_id, user_id=telegram_user_id)
                    if chat_member.status in ['member', 'administrator', 'creator']:
                        is_premium_member = True
                        # Обновляем информацию о принадлежности пользователя к группе
                        await self.set_user_group_association(user_id, group_id)
                        break
                except Exception as e:
                    logger.error(f"Ошибка при проверке членства в группе {group_id} для пользователя {user_id}: {e}")

            if is_premium_member:
                await self.set_user_tariff_plan(user_id, 'premium')
            else:
                await self.set_user_tariff_plan(user_id, 'free')
                # Устанавливаем модель по умолчанию для бесплатного тарифа
                await self.set_user_model(user_id, 'gpt-4-turbo')

    async def set_user_group_association(self, user_id: str, group_id: int):
        # Устанавливаем информацию о принадлежности пользователя к группе
        await self.db_connection.execute('''
            INSERT INTO users (user_id, group_association) VALUES (?, ?)
            ON CONFLICT(user_id) DO UPDATE SET group_association=excluded.group_association
        ''', (user_id, str(group_id)))
        await self.db_connection.commit()

    async def get_user_group_association(self, user_id: str) -> str:
        # Получаем информацию о принадлежности пользователя к группе
        async with self.db_connection.execute('SELECT group_association FROM users WHERE user_id = ?', (user_id,)) as cursor:
            result = await cursor.fetchone()
            if result and result[0]:
                return result[0]
            else:
                return "None"

    def _setup_handlers(self):
        # Настройка обработчиков сообщений
        self.dp.register_message_handler(self.cmd_start, commands=['start', 'help'])
        self.dp.register_message_handler(
            self.process_model_selection,
            lambda msg: msg.text in [model[0] for model in self.ALL_AVAILABLE_MODELS]
        )
        self.dp.register_message_handler(
            self.handle_clear_context,
            lambda msg: msg.text == "🗑 Очистить контекст"
        )
        self.dp.register_message_handler(
            self.show_model_selection,
            lambda msg: msg.text == "🤖 Выбрать модель"
        )
        self.dp.register_message_handler(
            self.show_profile,
            lambda msg: msg.text == "👤 Профиль"
        )
        self.dp.register_message_handler(
            self.start_image_generation,
            lambda msg: msg.text == "🖼️ Генерация изображения"
        )
        self.dp.register_message_handler(
            self.check_subscription_button_handler,
            lambda msg: msg.text == "🔄 Проверить подписку"
        )
        self.dp.register_message_handler(
            self.cancel_handler,
            state='*',
            text='🔙 Назад'
        )
        # Обработчики для Админ-Панели
        self.dp.register_message_handler(
            self.show_admin_panel,
            lambda msg: msg.text == "🛠️ Админ-Панель"
        )
        self.dp.register_message_handler(
            self.handle_admin_selection,
            state=Form.AdminPanel
        )
        self.dp.register_message_handler(
            self.handle_tariff_selection_for_edit,
            state=Form.SelectTariffForEdit
        )
        self.dp.register_message_handler(
            self.handle_edit_tariff_name_or_description,
            state=Form.EditTariffNameOrDescription
        )
        self.dp.register_message_handler(
            self.handle_edit_tariff_name,
            state=Form.EditTariffName
        )
        self.dp.register_message_handler(
            self.handle_edit_tariff_description,
            state=Form.EditTariffDescription
        )
        self.dp.register_message_handler(
            self.handle_edit_tariff_tokens,
            state=Form.EditTariffTokens
        )
        self.dp.register_message_handler(
            self.handle_set_tariff_tokens,
            state=Form.EditTariffTokenAmount
        )
        self.dp.register_message_handler(
            self.handle_broadcast_message,
            state=Form.BroadcastSelectTariff
        )
        self.dp.register_message_handler(
            self.handle_broadcast_text,
            state=Form.BroadcastMessageState
        )
        # Обработчики для управления чатами
        self.dp.register_message_handler(
            self.handle_manage_chats,
            state=Form.ManageChats
        )
        self.dp.register_message_handler(
            self.handle_add_chat,
            state=Form.AddChat
        )
        self.dp.register_message_handler(
            self.handle_delete_chat,
            state=Form.DeleteChat
        )
        # Обработчики для генерации отчёта
        self.dp.register_message_handler(
            self.handle_generate_report,
            state=Form.GenerateReport
        )
        # Регистрация обработчиков состояний FSM
        self.dp.register_message_handler(
            self.process_image_prompt,
            state=Form.ImageGenerationPrompt
        )
        self.dp.register_message_handler(
            self.process_image_size,
            state=Form.ImageGenerationSize
        )
        self.dp.register_message_handler(
            self.handle_document,
            content_types=[types.ContentType.DOCUMENT]
        )
        # Обработка аудио и голосовых сообщений
        self.dp.register_message_handler(
            self.handle_audio,
            content_types=[types.ContentType.AUDIO, types.ContentType.VOICE]
        )
        # Обработка фотографий
        self.dp.register_message_handler(
            self.handle_photo,
            content_types=[types.ContentType.PHOTO]
        )
        self.dp.register_message_handler(
            self.handle_text,
            content_types=[types.ContentType.TEXT]
        )

    async def cancel_handler(self, message: types.Message, state: FSMContext):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Обработка нажатия кнопки "🔙 Назад" во время состояния
        user_id = str(message.from_user.id)
        await state.finish()
        tariff_plan = await self.get_user_tariff_plan(user_id)
        await message.reply("Отменено. Вы вернулись в главное меню.", reply_markup=self.get_keyboard(tariff_plan, user_id))

    def get_keyboard(self, tariff_plan: str, user_id: str):
        # Создание основной клавиатуры
        keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
        keyboard.row("🗑 Очистить контекст", "🤖 Выбрать модель")
        keyboard.row("🖼️ Генерация изображения", "👤 Профиль")
        if int(user_id) in config.ADMIN_IDS:
            keyboard.add("🛠️ Админ-Панель")
        return keyboard

    def get_model_keyboard(self, tariff_plan: str):
        # Создание клавиатуры выбора модели
        keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
        models = self.ALL_AVAILABLE_MODELS
        buttons = [types.KeyboardButton(model_name) for model_name, _, _ in models]
        keyboard.add(*buttons)
        keyboard.add("🔙 Назад")
        return keyboard

    def get_subscription_keyboard(self):
        # Клавиатура с кнопкой проверки подписки
        keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
        keyboard.add("🔄 Проверить подписку")
        return keyboard

    async def prompt_subscription(self, message: types.Message):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Просьба пользователю подписаться на канал
        keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
        keyboard.add("🔄 Проверить подписку")
        subscribe_button = types.InlineKeyboardButton(
            text="📢 Подписаться на канал",
            url=f"https://t.me/{config.CHANNEL_USERNAME}"
        )
        inline_keyboard = types.InlineKeyboardMarkup().add(subscribe_button)
        await message.reply(
            "Чтобы пользоваться ботом, пожалуйста, подпишитесь на наш канал.",
            reply_markup=inline_keyboard
        )
        await message.answer(
            "После подписки нажмите кнопку ниже, чтобы проверить подписку.",
            reply_markup=keyboard
        )

    async def check_subscription_button_handler(self, message: types.Message):
        # Обработка нажатия кнопки "Проверить подписку"
        await self.cmd_start(message)

    async def cmd_start(self, message: types.Message):
        # Асинхронная инициализация базы данных при запуске
        if not self.db_connection:
            await self._setup_database()

        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Обработка команды /start
        user_id = str(message.from_user.id)
        telegram_user_id = message.from_user.id

        # Проверка подписки
        is_subscribed = await self.check_user_subscription(telegram_user_id)
        await self.set_user_subscription(user_id, is_subscribed)

        if not is_subscribed:
            await self.prompt_subscription(message)
        else:
            # Проверяем и обновляем тарифный план пользователя
            await self.check_and_update_tariff_plan(user_id)
            await self.refresh_user_tokens(user_id)
            tariff_plan = await self.get_user_tariff_plan(user_id)
            keyboard = self.get_keyboard(tariff_plan, user_id)

            welcome_text = (
                "👋 <b>Привет!</b>\n\n"
                "Я бот для общения с AI моделями.\n\n"
                "Выберите модель для общения и отправляйте сообщения.\n\n"
                "Чтобы сменить модель, нажмите <b>🤖 Выбрать модель</b>.\n"
                "Чтобы очистить контекст беседы, нажмите <b>🗑 Очистить контекст</b>.\n"
                "Для доступа к профилю нажмите <b>👤 Профиль</b>.\n"
                "Для генерации изображения нажмите <b>🖼️ Генерация изображения</b>."
            )

            await message.reply(welcome_text, reply_markup=keyboard, parse_mode=types.ParseMode.HTML)

    async def show_model_selection(self, message: types.Message):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Показать выбор моделей
        user_id = str(message.from_user.id)
        tariff_plan = await self.get_user_tariff_plan(user_id)
        keyboard = self.get_model_keyboard(tariff_plan)
        await message.reply(
            "Выберите модель для общения:",
            reply_markup=keyboard
        )

    async def process_model_selection(self, message: types.Message):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Обработка выбора модели
        user_id = str(message.from_user.id)
        telegram_user_id = message.from_user.id

        # Проверка подписки
        is_subscribed = await self.check_user_subscription(telegram_user_id)
        await self.set_user_subscription(user_id, is_subscribed)

        if not is_subscribed:
            await self.prompt_subscription(message)
            return

        # Проверяем и обновляем тарифный план пользователя
        await self.check_and_update_tariff_plan(user_id)
        await self.refresh_user_tokens(user_id)
        tariff_plan = await self.get_user_tariff_plan(user_id)

        if message.text == "🔙 Назад":
            await message.reply("Вы вернулись в главное меню.", reply_markup=self.get_keyboard(tariff_plan, user_id))
            return

        available_models = [model[0] for model in self.ALL_AVAILABLE_MODELS]

        model_name = message.text
        if model_name not in available_models:
            await message.reply("Неверный выбор модели. Пожалуйста, выберите модель из списка.")
            return

        model_id = None
        for name, id, _ in self.ALL_AVAILABLE_MODELS:
            if name == model_name:
                model_id = id
                break

        if not model_id:
            await message.reply("Неверный выбор модели. Пожалуйста, выберите модель из списка.")
            return

        # Сохранение выбора модели пользователя
        await self.set_user_model(user_id, model_id)

        # Очистка контекста беседы при смене модели
        self.conversations.pop(user_id, None)

        await message.reply(f"Выбрана модель: {model_name}", reply_markup=self.get_keyboard(tariff_plan, user_id))

    async def handle_clear_context(self, message: types.Message):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Очистка контекста беседы
        user_id = str(message.from_user.id)
        telegram_user_id = message.from_user.id

        # Проверка подписки
        is_subscribed = await self.check_user_subscription(telegram_user_id)
        await self.set_user_subscription(user_id, is_subscribed)

        if not is_subscribed:
            await self.prompt_subscription(message)
            return

        self.conversations.pop(user_id, None)
        tariff_plan = await self.get_user_tariff_plan(user_id)
        await message.reply(
            "Контекст очищен! Можете начать новый разговор.",
            reply_markup=self.get_keyboard(tariff_plan, user_id)
        )

    async def show_profile(self, message: types.Message):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Отображение профиля пользователя
        user_id = str(message.from_user.id)
        telegram_user_id = message.from_user.id

        # Проверка подписки и обновление тарифного плана
        is_subscribed = await self.check_user_subscription(telegram_user_id)
        await self.set_user_subscription(user_id, is_subscribed)
        await self.check_and_update_tariff_plan(user_id)
        await self.refresh_user_tokens(user_id)

        tariff_plan = await self.get_user_tariff_plan(user_id)
        tokens_available = await self.get_user_tokens(user_id)
        last_refresh = await self.get_last_token_refresh(user_id)
        now = datetime.now()
        if last_refresh:
            next_refresh_date = last_refresh + timedelta(days=1)
            seconds_left = (next_refresh_date - now).total_seconds()
            hours_left = int(seconds_left // 3600)
            minutes_left = int((seconds_left % 3600) // 60)
            if seconds_left < 0:
                hours_left = 0
                minutes_left = 0
        else:
            hours_left = 24
            minutes_left = 0

        if tokens_available == -1:
            tokens_text = "∞"
        else:
            tokens_text = f"{tokens_available:,}".replace(",", " ")

        tariff_info = await self.get_tariff_info(tariff_plan)
        if tariff_info:
            tariff_name = tariff_info['name']
            tariff_description = tariff_info['description']
        else:
            tariff_name = tariff_plan
            tariff_description = "Нет описания для этого тарифа."

        if tokens_available == -1:
            refresh_text = ""
        else:
            if hours_left == 0 and minutes_left == 0:
                refresh_text = "Обновление токенов: <b>скоро</b>"
            else:
                refresh_text = f"Обновление токенов через: <b>{hours_left} часов {minutes_left} минут</b>"

        profile_text = (
            f"👤 <b>Профиль пользователя</b>\n\n"
            f"Ваш тариф: <b>{tariff_name}</b>\n\n"
            f"<b>Описание тарифа:</b>\n{tariff_description}\n\n"
            f"Токенов осталось: <b>{tokens_text}</b>\n"
            f"{refresh_text}"
        )

        await message.reply(profile_text, reply_markup=self.get_keyboard(tariff_plan, user_id), parse_mode=types.ParseMode.HTML)

    async def start_image_generation(self, message: types.Message):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Начало процесса генерации изображения
        user_id = str(message.from_user.id)
        telegram_user_id = message.from_user.id

        # Проверка подписки
        is_subscribed = await self.check_user_subscription(telegram_user_id)
        await self.set_user_subscription(user_id, is_subscribed)

        if not is_subscribed:
            await self.prompt_subscription(message)
            return

        await self.check_and_update_tariff_plan(user_id)
        await self.refresh_user_tokens(user_id)
        tariff_plan = await self.get_user_tariff_plan(user_id)

        # Проверяем, есть ли у пользователя достаточно токенов (100 токенов за генерацию)
        tokens_available = await self.get_user_tokens(user_id)
        if tokens_available != -1 and tokens_available < 100:
            await message.reply("У вас недостаточно токенов для генерации изображения.")
            return

        await Form.ImageGenerationPrompt.set()
        keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
        keyboard.add("🔙 Назад")
        await message.reply(
            "Пожалуйста, введите описание изображения, которое вы хотите сгенерировать:",
            reply_markup=keyboard
        )

    async def process_image_prompt(self, message: types.Message, state: FSMContext):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Обработка описания изображения
        user_id = str(message.from_user.id)
        await self.check_and_update_tariff_plan(user_id)
        await self.refresh_user_tokens(user_id)
        tariff_plan = await self.get_user_tariff_plan(user_id)

        if message.text == "🔙 Назад":
            await state.finish()
            await message.reply("Вы вернулись в главное меню.", reply_markup=self.get_keyboard(tariff_plan, user_id))
            return

        prompt = message.text

        # Переводим описание на английский с помощью GPT-4o
        translated_prompt = await self.translate_prompt(prompt, user_id)

        if not translated_prompt:
            await message.reply("Не удалось перевести описание на английский.")
            await state.finish()
            return

        # Сохраняем переведенное описание в состоянии
        await state.update_data(prompt=translated_prompt)

        # Предлагаем выбрать соотношение сторон
        keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
        keyboard.add("1:1", "3:4", "16:9", "9:16")
        keyboard.add("🔙 Назад")
        await Form.next()
        await message.reply("Пожалуйста, выберите соотношение сторон изображения:", reply_markup=keyboard)

    async def process_image_size(self, message: types.Message, state: FSMContext):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Обработка выбора соотношения сторон
        user_id = str(message.from_user.id)
        await self.check_and_update_tariff_plan(user_id)
        await self.refresh_user_tokens(user_id)
        tariff_plan = await self.get_user_tariff_plan(user_id)

        if message.text == "🔙 Назад":
            await state.finish()
            await message.reply("Вы вернулись в главное меню.", reply_markup=self.get_keyboard(tariff_plan, user_id))
            return

        size = message.text
        if size not in ["1:1", "3:4", "16:9", "9:16"]:
            await message.reply("Пожалуйста, выберите соотношение сторон из предложенных вариантов.")
            return

        await state.update_data(size=size)

        # Проверяем, есть ли у пользователя достаточно токенов (100 токенов за генерацию)
        tokens_available = await self.get_user_tokens(user_id)
        if tokens_available != -1 and tokens_available < 100:
            await message.reply("У вас недостаточно токенов для генерации изображения.")
            await state.finish()
            return

        # Списываем 100 токенов
        if tokens_available != -1:
            await self.set_user_tokens(user_id, tokens_available - 100)

        # Получаем данные из состояния
        data = await state.get_data()
        prompt = data['prompt']
        size = data['size']

        # Показываем, что бот набирает ответ
        await self.bot.send_chat_action(message.chat.id, types.ChatActions.UPLOAD_PHOTO)

        waiting_message = await message.reply("Генерирую изображение...")
        self.waiting_messages[user_id] = waiting_message

        try:
            # Используем ImageAPI для генерации изображения
            images = await asyncio.to_thread(
                self.image_api.generate_images,
                prompt=prompt,
                n=1,
                size=size
            )
            if images:
                for image_url in images:
                    await message.reply_photo(photo=image_url)
            else:
                await message.reply("Не удалось сгенерировать изображение.")
        except Exception as e:
            logger.error(f"Ошибка при генерации изображения: {str(e)}", exc_info=True)
            await message.reply(f"Произошла ошибка при генерации изображения: {str(e)}")
        finally:
            if user_id in self.waiting_messages:
                try:
                    await self.waiting_messages[user_id].delete()
                except Exception as e:
                    logger.error(f"Ошибка при удалении сообщения ожидания: {e}")
                del self.waiting_messages[user_id]
            # Завершаем состояние и возвращаем основную клавиатуру
            await state.finish()
            await message.reply("Вы можете продолжить общение.", reply_markup=self.get_keyboard(tariff_plan, user_id))

    async def translate_prompt(self, prompt: str, user_id: str) -> str:
        """
        Переводит текст на английский язык с помощью GPT-4o.
        """
        try:
            model = 'gpt-4o-mini'
            api_name = self.MODEL_API_MAPPING.get(model)
            api_client = self.api_clients.get(api_name)
            if not api_client:
                return None

            # Формируем сообщения для перевода
            conversation = [
                {"role": "user", "content": f"Пожалуйста, переведи следующий текст на английский язык:\n\n{prompt}"}
            ]

            response = await asyncio.to_thread(
                api_client.send_message,
                model=model,
                messages=conversation,
                temperature=0.7,
                max_tokens=1000
            )

            if not response:
                return None

            choices = response.get('choices')
            if not choices:
                return None

            assistant_message = choices[0].get('message')
            if not assistant_message:
                return None

            content = assistant_message.get('content')
            return content.strip() if content else None
        except Exception as e:
            logger.error(f"Ошибка при переводе описания: {str(e)}", exc_info=True)
            return None

    async def handle_document(self, message: types.Message):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Обработка документов
        if not message.document:
            return

        user_id = str(message.from_user.id)
        telegram_user_id = message.from_user.id

        # Проверка подписки
        is_subscribed = await self.check_user_subscription(telegram_user_id)
        await self.set_user_subscription(user_id, is_subscribed)

        if not is_subscribed:
            await self.prompt_subscription(message)
            return

        # Проверка занятости пользователя
        if user_id in self.user_tasks:
            await message.reply("Пожалуйста, дождитесь ответа на предыдущее сообщение.")
            return

        # Проверяем и обновляем тарифный план пользователя
        await self.check_and_update_tariff_plan(user_id)
        await self.refresh_user_tokens(user_id)

        # Проверяем, есть ли у пользователя достаточно токенов
        tokens_available = await self.get_user_tokens(user_id)
        if tokens_available == 0:
            await message.reply("У вас закончились токены. Подождите до обновления лимита или измените тарифный план.")
            return

        # Создаем задачу для обработки документа
        task = asyncio.create_task(self._process_document(message))
        self.user_tasks[user_id] = task

    async def _process_document(self, message: types.Message):
        # Вспомогательная функция для обработки документа
        user_id = str(message.from_user.id)
        try:
            file_name = message.document.file_name or "document"
            content = await process_file_content(self.bot, message.document.file_id, file_name)

            prompt = f"Анализ файла {file_name}:\n\n"
            if message.caption:
                prompt += f"Подпись к файлу: {message.caption}\n\n"
            prompt += f"Содержимое:\n{content}"

            # Считаем количество токенов и обновляем баланс
            tokens_used = len(prompt)
            tokens_available = await self.get_user_tokens(user_id)
            if tokens_available != -1:
                if tokens_used > tokens_available:
                    await message.reply("У вас недостаточно токенов для анализа этого файла.")
                    return
                await self.set_user_tokens(user_id, tokens_available - tokens_used)

            await self.process_message(message, prompt)
        except Exception as e:
            logger.error(f"Ошибка при обработке документа: {e}", exc_info=True)
            await message.reply(f"Произошла ошибка при обработке документа: {e}")
        finally:
            # Удаляем задачу из списка после завершения
            if user_id in self.user_tasks:
                del self.user_tasks[user_id]

    async def handle_audio(self, message: types.Message):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Обработка аудио и голосовых сообщений
        user_id = str(message.from_user.id)
        telegram_user_id = message.from_user.id

        # Проверка подписки
        is_subscribed = await self.check_user_subscription(telegram_user_id)
        await self.set_user_subscription(user_id, is_subscribed)

        if not is_subscribed:
            await self.prompt_subscription(message)
            return

        # Проверка занятости пользователя
        if user_id in self.user_tasks:
            await message.reply("Пожалуйста, дождитесь ответа на предыдущее сообщение.")
            return

        # Проверяем и обновляем тарифный план пользователя
        await self.check_and_update_tariff_plan(user_id)
        await self.refresh_user_tokens(user_id)

        # Проверяем, есть ли у пользователя достаточно токенов
        tokens_available = await self.get_user_tokens(user_id)
        if tokens_available == 0:
            await message.reply("У вас закончились токенов. Подождите до обновления лимита или измените тарифный план.")
            return

        # Создаем задачу для обработки аудио
        task = asyncio.create_task(self._process_audio(message))
        self.user_tasks[user_id] = task

    async def _process_audio(self, message: types.Message):
        # Вспомогательная функция для обработки аудио
        user_id = str(message.from_user.id)
        try:
            await self.audio_processor.process_audio_message(message, self.process_message)
        except Exception as e:
            logger.error(f"Ошибка при обработке аудио: {e}", exc_info=True)
            await message.reply(f"Произошла ошибка при обработке аудио: {e}")
        finally:
            # Удаляем задачу из списка после завершения
            if user_id in self.user_tasks:
                del self.user_tasks[user_id]

    async def handle_photo(self, message: types.Message):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Обработка фотографий
        user_id = str(message.from_user.id)
        telegram_user_id = message.from_user.id

        # Проверка подписки
        is_subscribed = await self.check_user_subscription(telegram_user_id)
        await self.set_user_subscription(user_id, is_subscribed)

        if not is_subscribed:
            await self.prompt_subscription(message)
            return

        # Проверка занятости пользователя
        if user_id in self.user_tasks:
            await message.reply("Пожалуйста, дождитесь ответа на предыдущее сообщение.")
            return

        # Проверяем и обновляем тарифный план пользователя
        await self.check_and_update_tariff_plan(user_id)
        await self.refresh_user_tokens(user_id)

        # Проверяем, есть ли у пользователя достаточно токенов
        tokens_available = await self.get_user_tokens(user_id)
        if tokens_available == 0:
            await message.reply("У вас закончились токенов. Подождите до обновления лимита или измените тарифный план.")
            return

        # Создаем задачу для обработки фотографии
        task = asyncio.create_task(self._process_photo(message))
        self.user_tasks[user_id] = task

    async def _process_photo(self, message: types.Message):
        # Вспомогательная функция для обработки фотографии
        user_id = str(message.from_user.id)
        try:
            # Получаем файл изображения
            photo = message.photo[-1]  # Используем изображение с максимальным разрешением
            file_info = await self.bot.get_file(photo.file_id)
            image_url = f"https://api.telegram.org/file/bot{config.BOT_TOKEN}/{file_info.file_path}"

            # Подготавливаем контекст для gpt-4o
            prompt = message.caption or "Изображение для анализа."

            # Сохраняем контекст
            await self.process_message(message, prompt, image_url=image_url)
        except Exception as e:
            logger.error(f"Ошибка при обработке фотографии: {e}", exc_info=True)
            await message.reply(f"Произошла ошибка при обработке фотографии: {e}")
        finally:
            # Удаляем задачу из списка после завершения
            if user_id in self.user_tasks:
                del self.user_tasks[user_id]

    async def handle_text(self, message: types.Message):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Обработка текстовых сообщений
        user_id = str(message.from_user.id)
        telegram_user_id = message.from_user.id

        control_messages = [
            "🗑 Очистить контекст",
            "🤖 Выбрать модель",
            "🖼️ Генерация изображения",
            "👤 Профиль",
            "🛠️ Админ-Панель",
            "🔙 Назад",
            "🔄 Проверить подписку"
        ] + [model[0] for model in self.ALL_AVAILABLE_MODELS]

        if message.text in control_messages:
            return

        # Проверка подписки
        is_subscribed = await self.check_user_subscription(telegram_user_id)
        await self.set_user_subscription(user_id, is_subscribed)

        if not is_subscribed:
            await self.prompt_subscription(message)
            return

        # Проверка занятости пользователя
        if user_id in self.user_tasks:
            await message.reply("Пожалуйста, дождитесь ответа на предыдущее сообщение.")
            return

        # Проверяем и обновляем тарифный план пользователя
        await self.check_and_update_tariff_plan(user_id)
        await self.refresh_user_tokens(user_id)

        # Проверяем, есть ли у пользователя достаточно токенов
        tokens_available = await self.get_user_tokens(user_id)
        if tokens_available == 0:
            await message.reply("У вас закончились токены. Подождите до обновления лимита или измените тарифный план.")
            return

        # Передаем обработку в отдельную функцию
        task = asyncio.create_task(self._process_text_message(message))
        self.user_tasks[user_id] = task

    async def _process_text_message(self, message: types.Message):
        # Вспомогательная функция для обработки текстового сообщения
        user_id = str(message.from_user.id)
        try:
            await self.process_message(message, message.text)
        except Exception as e:
            logger.error(f"Ошибка при обработке текстового сообщения: {e}", exc_info=True)
            await message.reply(f"Произошла ошибка при обработке вашего сообщения: {e}")
        finally:
            # Удаляем задачу из списка после завершения
            if user_id in self.user_tasks:
                del self.user_tasks[user_id]

    async def process_message(self, message: types.Message, text: str, image_url: str = None):
        # Проверка типа чата
        if message.chat.type != 'private':
            return

        # Обработка текстовых сообщений с контекстом
        user_id = str(message.from_user.id)
        telegram_user_id = message.from_user.id

        # Получение выбранной модели пользователя
        model = await self.get_user_model(user_id)
        api_name = self.MODEL_API_MAPPING.get(model)

        # Проверяем ключевые слова для поиска в интернете только для gpt4o
        if api_name == 'gpt4o' and any(keyword in text.lower() for keyword in ["найди в интернете", "погода", "найди", "искать информацию"]):
            search_query = self.extract_search_query(text)
            if search_query:
                search_result = await self.search_internet(search_query)
                if search_result:
                    # Передаём результаты поиска GPT-4o для анализа и формирования ответа
                    gpt_response = await self.analyze_search_results_with_gpt4o(search_query, search_result, user_id)
                    if gpt_response:
                        await send_long_message(message, gpt_response)
                        return
                    else:
                        await message.reply("Не удалось обработать результаты поиска.")
                else:
                    await message.reply("Не удалось найти информацию по вашему запросу.")
            else:
                await message.reply("Пожалуйста, уточните ваш запрос для поиска.")
            return

        # Показываем, что бот набирает ответ
        await self.bot.send_chat_action(message.chat.id, types.ChatActions.TYPING)

        waiting_message = await message.reply("Пишу для вас ответ...")
        self.waiting_messages[user_id] = waiting_message

        try:
            # Проверяем и обновляем тарифный план пользователя
            await self.check_and_update_tariff_plan(user_id)
            await self.refresh_user_tokens(user_id)
            tariff_plan = await self.get_user_tariff_plan(user_id)

            # Проверяем, есть ли у пользователя достаточно токенов
            tokens_available = await self.get_user_tokens(user_id)
            if tokens_available == 0:
                await message.reply("У вас закончились токены. Подождите до обновления лимита или измените тарифный план.")
                return

            if not api_name:
                await message.reply("Неизвестная модель или API. Пожалуйста, выберите модель из списка.")
                return

            api_client = self.api_clients.get(api_name)

            if not api_client:
                await message.reply("Ошибка в настройке API. Пожалуйста, свяжитесь с администратором.")
                return

            # Получение предыдущего контекста для пользователя
            conversation = self.conversations.get(user_id, [])

            if api_name == 'sparrow':
                # Используем SparrowAPI
                conversation_dict = self.conversations.get(user_id, {})
                conversation_id = conversation_dict.get('conversation_id')
                response = await asyncio.to_thread(
                    api_client.send_message,
                    message=text,
                    conversation_id=conversation_id,
                    models=[model]
                )

                if not response or 'data' not in response:
                    await message.reply("Получен некорректный ответ от API")
                    return

                data = response['data']
                messages = data.get('messages', [])

                if not messages:
                    await message.reply("Не получено сообщений от API")
                    return

                if 'conversationId' in data:
                    self.conversations.setdefault(user_id, {})['conversation_id'] = data['conversationId']

                assistant_message = next(
                    (msg for msg in reversed(messages) if msg.get('role') == 'assistant'),
                    None
                )

                if not assistant_message:
                    await message.reply("Не получен ответ от ассистента")
                    return

                content = assistant_message.get('content')
                if not content and 'contents' in assistant_message:
                    content = next(
                        (c.get('content') for c in assistant_message['contents']
                         if c.get('model') == model),
                        None
                    )

                if not content:
                    await message.reply("Не удалось получить текст ответа")
                    return

                # Считаем количество токенов и обновляем баланс
                tokens_used = len(content)
                tokens_available = await self.get_user_tokens(user_id)
                if tokens_available != -1:
                    if tokens_used > tokens_available:
                        await message.reply("У вас недостаточно токенов для этого ответа.")
                        return
                    await self.set_user_tokens(user_id, tokens_available - tokens_used)

                await send_long_message(message, content)

            elif api_name == 'gpt4o':
                # Используем GPT4OAPI
                if image_url:
                    # Если есть изображение, формируем контент специальным образом
                    content = [
                        {"text": text, "type": "text"},
                        {"type": "image_url", "image_url": {"url": image_url}}
                    ]

                    item = {
                        "role": "user",
                        "content": content
                    }

                    data = {
                        "model": model,
                        "item": item
                    }
                else:
                    # Объединяем контекст и отправляем как текст
                    conversation.append(f"Пользователь: {text}")
                    context_text = build_context(conversation)

                    item = {
                        "role": "user",
                        "content": context_text
                    }

                    data = {
                        "model": model,
                        "item": item
                    }

                # Отправка запроса к GPT4OAPI
                response = await asyncio.to_thread(
                    api_client.send_message,
                    data=data
                )

                if not response:
                    await message.reply("Получен некорректный ответ от API")
                    return

                # Извлечение ответа ассистента
                choices = response.get('choices')
                if not choices:
                    await message.reply("Не удалось получить ответ от ассистента")
                    return

                assistant_message = choices[0].get('message')
                if not assistant_message:
                    await message.reply("Не удалось получить ответ от ассистента")
                    return

                assistant_content = assistant_message.get('content')
                if assistant_content:
                    if image_url:
                        # При обработке изображения сохраняем контент как есть
                        conversation.append(f"Пользователь: [Изображение]")
                        conversation.append(f"Ассистент: {assistant_content}")
                    else:
                        # Добавляем ответ ассистента в контекст
                        conversation.append(f"Ассистент: {assistant_content}")

                    self.conversations[user_id] = conversation

                    # Считаем количество токенов и обновляем баланс
                    tokens_used = len(str(assistant_content))
                    tokens_available = await self.get_user_tokens(user_id)
                    if tokens_available != -1:
                        if tokens_used > tokens_available:
                            await message.reply("У вас недостаточно токенов для этого ответа.")
                            return
                        await self.set_user_tokens(user_id, tokens_available - tokens_used)

                    # Отправка ответа пользователю
                    if isinstance(assistant_content, list):
                        # Обрабатываем список содержимого
                        for content_item in assistant_content:
                            if content_item.get('type') == 'text':
                                text = content_item.get('text')
                                await send_long_message(message, text)
                            elif content_item.get('type') == 'image_url':
                                image_data = content_item.get('image_url', {})
                                image_url = image_data.get('url')
                                if image_url:
                                    await message.reply_photo(photo=image_url)
                    else:
                        # Если контент представлен в виде текста
                        await send_long_message(message, assistant_content)
                else:
                    await message.reply("Не удалось получить текст ответа")

            elif api_name == 'forget':
                # Используем ForgetAPI
                conversation.append({"role": "user", "content": text})
                conversation = conversation[-10:]  # Ограничиваем контекст

                # Отправка запроса к ForgetAPI
                response = await asyncio.to_thread(
                    api_client.send_message,
                    model=model,
                    messages=conversation,
                    temperature=0.7,
                    max_tokens=10000
                )

                if not response:
                    await message.reply("Получен некорректный ответ от API")
                    return

                # Извлечение ответа ассистента
                choices = response.get('choices')
                if not choices:
                    await message.reply("Не удалось получить ответ от ассистента")
                    return

                assistant_message = choices[0].get('message')
                if not assistant_message:
                    await message.reply("Не удалось получить ответ от ассистента")
                    return

                content = assistant_message.get('content')
                if content:
                    conversation.append({"role": "assistant", "content": content})
                    self.conversations[user_id] = conversation

                    # Считаем количество токенов и обновляем баланс
                    tokens_used = len(content)
                    tokens_available = await self.get_user_tokens(user_id)
                    if tokens_available != -1:
                        if tokens_used > tokens_available:
                            await message.reply("У вас недостаточно токенов для этого ответа.")
                            return
                        await self.set_user_tokens(user_id, tokens_available - tokens_used)

                    # Отправка ответа пользователю
                    await send_long_message(message, content)
                else:
                    await message.reply("Не удалось получить текст ответа")
            else:
                await message.reply("Неизвестная модель или API. Пожалуйста, выберите модель из списка.")
                return

        except Exception as e:
            logger.error(f"Ошибка в process_message: {str(e)}", exc_info=True)
            await message.reply(f"Произошла ошибка при обработке вашего сообщения: {e}")
        finally:
            if user_id in self.waiting_messages:
                try:
                    await self.waiting_messages[user_id].delete()
                except Exception as e:
                    logger.error(f"Ошибка при удалении сообщения ожидания: {e}")
                del self.waiting_messages[user_id]

    async def search_internet(self, query: str) -> str:
        """
        Выполняет поиск в поисковой системе и возвращает результаты.
        Реализован парсинг через Bing для большей стабильности.
        """
        try:
            headers = {
                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
            }
            results = []
            async with aiohttp.ClientSession() as session:
                for page in range(3):  # Парсим первые 3 страницы
                    offset = page * 10
                    search_url = f"https://www.bing.com/search?q={quote_plus(query)}&first={offset + 1}"
                    async with session.get(search_url, headers=headers) as response:
                        if response.status != 200:
                            logger.error(f"Ошибка при поиске в интернете: статус код {response.status} для страницы {page+1}")
                            continue

                        html = await response.text()
                        soup = BeautifulSoup(html, 'html.parser')

                        # Извлекаем основные результаты поиска
                        for g in soup.find_all('li', class_='b_algo'):
                            title_tag = g.find('h2')
                            link_tag = g.find('a', href=True)
                            snippet_tag = g.find('p')

                            if title_tag and link_tag:
                                title_text = title_tag.get_text()
                                link = link_tag['href']
                                snippet = snippet_tag.get_text() if snippet_tag else "Нет описания."

                                results.append(f"<b>{title_text}</b>\n{snippet}\n<a href='{link}'>Подробнее</a>")

            if not results:
                return "Не удалось найти информацию по вашему запросу."

            # Ограничиваем количество результатов, например, 9 (3 страницы по 3 результата)
            results = results[:9]
            return "\n\n".join(results)
        except Exception as e:
            logger.error(f"Ошибка при поиске в интернете: {e}", exc_info=True)
            return "Произошла ошибка при выполнении поискового запроса."

    def extract_search_query(self, text: str) -> str:
        """
        Извлекает поисковый запрос из сообщения пользователя.
        """
        keywords = ["найди в интернете", "погода", "найди", "искать информацию"]
        text_lower = text.lower()
        for keyword in keywords:
            if keyword in text_lower:
                # Извлекаем часть текста после ключевого слова
                return text_lower.split(keyword, 1)[1].strip()
        return ""

    async def analyze_search_results_with_gpt4o(self, query: str, search_results: str, user_id: str) -> str:
        """
        Отправляет результаты поиска модели GPT-4o для анализа и формирования ответа.
        """
        try:
            model = 'gpt-4o-2024-08-06'  # Убедитесь, что модель корректна
            api_name = self.MODEL_API_MAPPING.get(model)
            api_client = self.api_clients.get(api_name)
            if not api_client:
                return None

            # Формируем сообщение для GPT-4o с предоставленными результатами поиска
            conversation = [
                {"role": "user", "content": f"Я выполнил поиск по запросу: '{query}'. Вот полученные результаты:\n\n{search_results}\n\nПожалуйста, проанализируй эти результаты и дай мне краткий ответ."}
            ]

            response = await asyncio.to_thread(
                api_client.send_message,
                model=model,
                messages=conversation,
                temperature=0.7,
                max_tokens=1500
            )

            if not response:
                return None

            choices = response.get('choices')
            if not choices:
                return None

            assistant_message = choices[0].get('message')
            if not assistant_message:
                return None

            content = assistant_message.get('content')
            return content.strip() if content else None

        except Exception as e:
            logger.error(f"Ошибка при анализе результатов поиска с помощью GPT-4o: {e}", exc_info=True)
            return None

    async def start(self):
        # Запуск бота
        logger.info("Запуск бота...")
        try:
            await self._setup_database()
            await self.dp.start_polling()
        except (KeyboardInterrupt, SystemExit):
            logger.info("Бот остановлен")
        except Exception as e:
            logger.error(f"Ошибка запуска бота: {str(e)}", exc_info=True)
            raise
        finally:
            if self.db_connection:
                await self.db_connection.close()

    async def check_user_subscription(self, user_id: int) -> bool:
        # Проверка подписки пользователя на канал
        try:
            chat_member = await self.bot.get_chat_member(chat_id='@' + config.CHANNEL_USERNAME, user_id=user_id)
            if chat_member.status in ['member', 'administrator', 'creator']:
                return True
            else:
                return False
        except Exception as e:
            logger.error(f"Ошибка при проверке подписки для пользователя {user_id}: {e}")
            return False

    # ----- Обработчики для Админ-Панели -----

    async def show_admin_panel(self, message: types.Message):
        # Проверка, что пользователь является администратором
        if message.from_user.id not in config.ADMIN_IDS:
            return

        await Form.AdminPanel.set()
        keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
        keyboard.add("Изменить тариф")
        keyboard.add("Изменить токены тарифа")
        keyboard.add("Сделать рассылку")
        keyboard.add("Управление чатами")
        keyboard.add("Сгенерировать отчёт")
        keyboard.add("🔙 Назад")
        await message.reply("Добро пожаловать в Админ-Панель. Выберите действие:", reply_markup=keyboard)

    async def handle_admin_selection(self, message: types.Message, state: FSMContext):
        if message.from_user.id not in config.ADMIN_IDS:
            await state.finish()
            return

        if message.text == "Изменить тариф":
            # Переходим к выбору тарифа для редактирования
            await Form.SelectTariffForEdit.set()
            keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
            tariffs = ['free', 'premium', 'admin']
            keyboard.add(*tariffs)
            keyboard.add("🔙 Назад")
            await message.reply("Выберите тариф для редактирования:", reply_markup=keyboard)
        elif message.text == "Изменить токены тарифа":
            # Переходим к выбору тарифа для изменения токенов
            await Form.EditTariffTokens.set()
            keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
            tariffs = ['free', 'premium', 'admin']
            keyboard.add(*tariffs)
            keyboard.add("🔙 Назад")
            await message.reply("Выберите тариф, для которого хотите изменить количество ежедневных токенов:", reply_markup=keyboard)
        elif message.text == "Сделать рассылку":
            # Переходим к рассылке сообщений
            await Form.BroadcastSelectTariff.set()
            keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
            tariffs = ['free', 'premium', 'admin', 'Все']
            keyboard.add(*tariffs)
            keyboard.add("🔙 Назад")
            await message.reply("Выберите тариф, пользователям которого хотите отправить сообщение:", reply_markup=keyboard)
        elif message.text == "Управление чатами":
            # Переходим к управлению чатами
            await Form.ManageChats.set()
            keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
            keyboard.add("Добавить чат")
            keyboard.add("Удалить чат")
            keyboard.add("Показать чаты")
            keyboard.add("🔙 Назад")
            await message.reply("Выберите действие с чатами:", reply_markup=keyboard)
        elif message.text == "Сгенерировать отчёт":
            # Генерация отчёта
            await self.generate_report(message)
            await state.finish()
            await self.show_admin_panel(message)
        elif message.text == "🔙 Назад":
            await state.finish()
            await self.cmd_start(message)
        else:
            await message.reply("Пожалуйста, выберите действие из списка.")

    async def handle_manage_chats(self, message: types.Message, state: FSMContext):
        if message.text == "Добавить чат":
            await Form.AddChat.set()
            await message.reply("Пожалуйста, отправьте ID чата, который хотите добавить в премиум-чаты:")
        elif message.text == "Удалить чат":
            await Form.DeleteChat.set()
            await message.reply("Пожалуйста, отправьте ID чата, который хотите удалить из премиум-чатов:")
        elif message.text == "Показать чаты":
            # Показываем список премиум-чатов
            async with self.db_connection.execute('SELECT chat_id FROM premium_chats') as cursor:
                premium_chat_ids = [row[0] for row in await cursor.fetchall()]
            if premium_chat_ids:
                chat_list = "\n".join([str(chat_id) for chat_id in premium_chat_ids])
                await message.reply(f"Список премиум-чатов:\n{chat_list}")
            else:
                await message.reply("Премиум-чаты отсутствуют.")
        elif message.text == "🔙 Назад":
            await Form.AdminPanel.set()
            await self.show_admin_panel(message)
        else:
            await message.reply("Пожалуйста, выберите действие из списка.")

    async def handle_add_chat(self, message: types.Message, state: FSMContext):
        try:
            chat_id = int(message.text)
            await self.db_connection.execute('INSERT OR IGNORE INTO premium_chats (chat_id) VALUES (?)', (chat_id,))
            await self.db_connection.commit()
            await message.reply(f"Чат {chat_id} успешно добавлен в премиум-чаты.")
            await state.finish()
            await self.show_admin_panel(message)
        except ValueError:
            await message.reply("Пожалуйста, введите корректный числовой ID чата.")
        except Exception as e:
            await message.reply(f"Ошибка при добавлении чата: {e}")
            await state.finish()
            await self.show_admin_panel(message)

    async def handle_delete_chat(self, message: types.Message, state: FSMContext):
        try:
            chat_id = int(message.text)
            await self.db_connection.execute('DELETE FROM premium_chats WHERE chat_id = ?', (chat_id,))
            await self.db_connection.commit()
            await message.reply(f"Чат {chat_id} успешно удалён из премиум-чатов.")
            await state.finish()
            await self.show_admin_panel(message)
        except ValueError:
            await message.reply("Пожалуйста, введите корректный числовой ID чата.")
        except Exception as e:
            await message.reply(f"Ошибка при удалении чата: {e}")
            await state.finish()
            await self.show_admin_panel(message)

    async def generate_report(self, message: types.Message):
        # Генерация отчёта в формате xlsx
        await message.reply("Генерирую отчёт...")

        workbook = xlsxwriter.Workbook('report.xlsx')
        worksheet = workbook.add_worksheet()

        # Заголовки столбцов
        headers = ['Группа', 'Тариф', 'ID пользователя', 'Использовано токенов']
        for col_num, header in enumerate(headers):
            worksheet.write(0, col_num, header)

        # Получаем список пользователей
        async with self.db_connection.execute('SELECT user_id, tariff_plan, tokens_available, group_association FROM users') as cursor:
            users = await cursor.fetchall()

        # Получаем список премиум-чатов
        async with self.db_connection.execute('SELECT chat_id FROM premium_chats') as cursor:
            premium_chat_ids = [str(row[0]) for row in await cursor.fetchall()]

        # Группа, при старте на которую нужно подписаться
        start_group = '@' + config.CHANNEL_USERNAME

        # Заполняем данные
        row_num = 1
        for user_id, tariff_plan, tokens_available, group_association in users:
            if group_association and int(group_association) in [int(cid) for cid in premium_chat_ids]:
                group_name = f"Чат {group_association}"
            elif not group_association or group_association == "None":
                group_name = start_group
            else:
                group_name = group_association

            worksheet.write(row_num, 0, group_name)
            worksheet.write(row_num, 1, tariff_plan)
            worksheet.write(row_num, 2, user_id)
            tariff_info = await self.get_tariff_info(tariff_plan)
            if tariff_info and tariff_info['daily_tokens'] != -1 and tokens_available is not None:
                tokens_used = tariff_info['daily_tokens'] - tokens_available
            else:
                tokens_used = "∞" if tariff_plan == 'admin' else "N/A"
            worksheet.write(row_num, 3, tokens_used)
            row_num += 1

        workbook.close()

        with open('report.xlsx', 'rb') as f:
            await self.bot.send_document(chat_id=message.chat.id, document=f)

    async def handle_generate_report(self, message: types.Message, state: FSMContext):
        # Этот обработчик фактически не используется, так как генерация происходит сразу
        pass

    async def handle_tariff_selection_for_edit(self, message: types.Message, state: FSMContext):
        if message.text == "🔙 Назад":
            await state.finish()
            await self.show_admin_panel(message)
            return
        tariff_id = message.text
        if tariff_id not in ['free', 'premium', 'admin']:
            await message.reply("Пожалуйста, выберите тариф из списка.")
            return
        await state.update_data(tariff_id=tariff_id)
        await Form.EditTariffNameOrDescription.set()
        keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
        keyboard.add("Изменить название", "Изменить описание")
        keyboard.add("🔙 Назад")
        await message.reply("Выберите, что вы хотите изменить:", reply_markup=keyboard)

    async def handle_edit_tariff_name_or_description(self, message: types.Message, state: FSMContext):
        if message.text == "🔙 Назад":
            await Form.SelectTariffForEdit.set()
            keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
            tariffs = ['free', 'premium', 'admin']
            keyboard.add(*tariffs)
            keyboard.add("🔙 Назад")
            await message.reply("Выберите тариф для редактирования:", reply_markup=keyboard)
            return
        data = await state.get_data()
        tariff_id = data.get('tariff_id')

        if message.text == "Изменить название":
            await Form.EditTariffName.set()
            await message.reply("Введите новое название тарифа:")
        elif message.text == "Изменить описание":
            await Form.EditTariffDescription.set()
            await message.reply("Введите новое описание тарифа:")
        else:
            await message.reply("Пожалуйста, выберите действие из списка.")

    async def handle_edit_tariff_name(self, message: types.Message, state: FSMContext):
        new_name = message.text
        data = await state.get_data()
        tariff_id = data.get('tariff_id')
        await self.set_tariff_info(tariff_id, name=new_name)
        await message.reply(f"Название тарифа '{tariff_id}' успешно изменено на '{new_name}'.")
        await state.finish()
        await self.show_admin_panel(message)

    async def handle_edit_tariff_description(self, message: types.Message, state: FSMContext):
        new_description = message.text
        data = await state.get_data()
        tariff_id = data.get('tariff_id')
        await self.set_tariff_info(tariff_id, description=new_description)
        await message.reply(f"Описание тарифа '{tariff_id}' успешно изменено.")
        await state.finish()
        await self.show_admin_panel(message)

    async def handle_edit_tariff_tokens(self, message: types.Message, state: FSMContext):
        if message.text == "🔙 Назад":
            await state.finish()
            await self.show_admin_panel(message)
            return
        tariff_id = message.text
        if tariff_id not in ['free', 'premium', 'admin']:
            await message.reply("Пожалуйста, выберите тариф из списка.")
            return
        await state.update_data(tariff_id=tariff_id)
        await Form.EditTariffTokenAmount.set()
        await message.reply("Введите новое количество ежедневных токенов (введите -1 для неограниченного количества):")

    async def handle_set_tariff_tokens(self, message: types.Message, state: FSMContext):
        try:
            new_token_amount = int(message.text)
            data = await state.get_data()
            tariff_id = data.get('tariff_id')
            await self.set_tariff_info(tariff_id, daily_tokens=new_token_amount)
            await message.reply(f"Количество ежедневных токенов для тарифа '{tariff_id}' успешно изменено на {new_token_amount}.")
            await state.finish()
            await self.show_admin_panel(message)
        except ValueError:
            await message.reply("Пожалуйста, введите корректное число.")

    async def handle_broadcast_message(self, message: types.Message, state: FSMContext):
        if message.text == "🔙 Назад":
            await state.finish()
            await self.show_admin_panel(message)
            return
        tariff_id = message.text
        if tariff_id not in ['free', 'premium', 'admin', 'Все']:
            await message.reply("Пожалуйста, выберите тариф из списка.")
            return
        await state.update_data(tariff_id=tariff_id)
        await Form.BroadcastMessageState.set()
        await message.reply("Введите сообщение для рассылки:")

    async def handle_broadcast_text(self, message: types.Message, state: FSMContext):
        broadcast_text = message.text
        data = await state.get_data()
        tariff_id = data.get('tariff_id')

        # Получаем список пользователей
        if tariff_id == 'Все':
            async with self.db_connection.execute('SELECT user_id FROM users') as cursor:
                user_ids = [row[0] for row in await cursor.fetchall()]
        else:
            async with self.db_connection.execute('SELECT user_id FROM users WHERE tariff_plan = ?', (tariff_id,)) as cursor:
                user_ids = [row[0] for row in await cursor.fetchall()]

        success_count = 0
        for user_id in user_ids:
            try:
                await self.bot.send_message(chat_id=int(user_id), text=broadcast_text)
                success_count += 1
            except Exception as e:
                logger.error(f"Не удалось отправить сообщение пользователю {user_id}: {e}")

        await message.reply(f"Рассылка завершена. Сообщение отправлено {success_count} пользователям.")
        await state.finish()
        await self.show_admin_panel(message)

    # ----- Конец обработчиков для Админ-Панели -----

    async def search_internet(self, query: str) -> str:
        """
        Выполняет поиск в поисковой системе и возвращает результаты.
        Реализован парсинг через Bing для большей стабильности.
        """
        try:
            headers = {
                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
            }
            results = []
            async with aiohttp.ClientSession() as session:
                for page in range(3):  # Парсим первые 3 страницы
                    offset = page * 10
                    search_url = f"https://www.bing.com/search?q={quote_plus(query)}&first={offset + 1}"
                    async with session.get(search_url, headers=headers) as response:
                        if response.status != 200:
                            logger.error(f"Ошибка при поиске в интернете: статус код {response.status} для страницы {page+1}")
                            continue

                        html = await response.text()
                        soup = BeautifulSoup(html, 'html.parser')

                        # Извлекаем основные результаты поиска
                        for g in soup.find_all('li', class_='b_algo'):
                            title_tag = g.find('h2')
                            link_tag = g.find('a', href=True)
                            snippet_tag = g.find('p')

                            if title_tag and link_tag:
                                title_text = title_tag.get_text()
                                link = link_tag['href']
                                snippet = snippet_tag.get_text() if snippet_tag else "Нет описания."

                                results.append(f"<b>{title_text}</b>\n{snippet}\n<a href='{link}'>Подробнее</a>")

            if not results:
                return "Не удалось найти информацию по вашему запросу."

            # Ограничиваем количество результатов, например, 9 (3 страницы по 3 результата)
            results = results[:9]
            return "\n\n".join(results)
        except Exception as e:
            logger.error(f"Ошибка при поиске в интернете: {e}", exc_info=True)
            return "Произошла ошибка при выполнении поискового запроса."

    async def analyze_search_results_with_gpt4o(self, query: str, search_results: str, user_id: str) -> str:
        """
        Отправляет результаты поиска модели GPT-4o для анализа и формирования ответа.
        """
        try:
            model = 'gpt-4o-2024-08-06'  # Убедитесь, что модель корректна
            api_name = self.MODEL_API_MAPPING.get(model)
            api_client = self.api_clients.get(api_name)
            if not api_client:
                return None

            # Формируем сообщение для GPT-4o с предоставленными результатами поиска
            conversation = [
                {"role": "user", "content": f"Я выполнил поиск по запросу: '{query}'. Вот полученные результаты:\n\n{search_results}\n\nПожалуйста, проанализируй эти результаты и дай мне краткий ответ."}
            ]

            response = await asyncio.to_thread(
                api_client.send_message,
                model=model,
                messages=conversation,
                temperature=0.7,
                max_tokens=1500
            )

            if not response:
                return None

            choices = response.get('choices')
            if not choices:
                return None

            assistant_message = choices[0].get('message')
            if not assistant_message:
                return None

            content = assistant_message.get('content')
            return content.strip() if content else None

        except Exception as e:
            logger.error(f"Ошибка при анализе результатов поиска с помощью GPT-4o: {e}", exc_info=True)
            return None

    async def handle_generate_report(self, message: types.Message, state: FSMContext):
        # Этот обработчик фактически не используется, так как генерация происходит сразу
        pass

    async def send_long_message(self, message: types.Message, text: str):
        """
        Отправляет длинные сообщения, разделяя их на части, если превышают лимит Telegram.
        """
        for i in range(0, len(text), self.MAX_MESSAGE_LENGTH):
            part = text[i:i + self.MAX_MESSAGE_LENGTH]
            await message.answer(part, parse_mode=types.ParseMode.HTML)

    async def perform_search_internet(self, query: str) -> str:
        """
        Упрощенный метод для выполнения поиска в Интернете без использования API-ключей.
        """
        return await self.search_internet(query)

    # ----- Окончание Остальных Методов -----


async def main():
    # Асинхронная функция main
    bot = EnhancedBot()
    try:
        await bot.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Бот остановлен")
    except Exception as e:
        logger.error(f"Критическая ошибка: {str(e)}", exc_info=True)

if __name__ == '__main__':
    asyncio.run(main())
```

## Объяснение Внесённых Изменений

1. **Интеграция GPT-4o для Анализа Результатов Поиска**:
    - Добавлена функция `analyze_search_results_with_gpt4o`, которая передаёт результаты поиска модели GPT-4o для анализа и формирования ответа. Это позволяет GPT-4o обрабатывать полную информацию с веб-страниц и предоставлять пользователю более содержательные ответы.

2. **Изменение Логики `process_message`**:
    - В методе `process_message` добавлена проверка для моделей `gpt4o`. Если сообщение пользователя содержит ключевые слова для поиска в интернете, бот выполняет поиск, а затем передаёт результаты GPT-4o для анализа и формирования ответа.
    - Это обеспечивает передачу всех полученных веб-страниц модели GPT-4o для создания более интеллектуальных и контекстуальных ответов.

3. **Улучшение Обработки Исключений и Логирования**:
    - Внесены улучшения в обработку исключений и логирование, особенно в новых функциях, чтобы обеспечить стабильную работу бота и облегчить отладку при возникновении ошибок.

4. **Оптимизация Функции `send_long_message`**:
    - Функция `send_long_message` теперь используется для отправки длинных сообщений, разбивая их на части, соответствующие лимиту Telegram (4096 символов).

5. **Обновления в Админ-Панели**:
    - Убедитесь, что функции администрирования корректно работают после внесённых изменений, особенно если добавляются новые функции или изменяется логика работы бота.

## Дополнительные Рекомендации

1. **Соблюдение Условий Использования Поисковых Систем**:
    - Убедитесь, что парсинг результатов поиска не нарушает условия использования выбранной поисковой системы (в данном случае Bing). Рекомендуется ознакомиться с [условиями использования Bing](https://www.microsoft.com/en-us/bing/apis/bing-web-search-api) и соблюдать их.

2. **Оптимизация Производительности**:
    - Парсинг веб-страниц и последующая передача больших объёмов данных модели GPT-4o может быть ресурсоёмкой. Рассмотрите возможность кеширования результатов поисковых запросов или ограничения частоты таких операций для повышения производительности бота.

3. **Безопасность и Управление Данными**:
    - Проверьте, что все конфиденциальные данные, такие как токены и параметры API, хранятся безопасно и не доступны посторонним лицам. Рекомендуется использовать переменные окружения или другие безопасные методы хранения чувствительных данных.

4. **Тестирование**:
    - Проведите всестороннее тестирование всех функций бота, включая новые возможности, чтобы убедиться в их корректной работе и отсутствии неожиданных сбоев.

5. **Мониторинг и Логирование**:
    - Настройте систему мониторинга и детализированного логирования для своевременного обнаружения и реагирования на возможные проблемы в работе бота.

6. **Обновление Зависимостей**:
    - Регулярно обновляйте используемые библиотеки и зависимости до последних стабильных версий для обеспечения безопасности и стабильности работы бота.

Если у вас возникнут дополнительные вопросы или потребуется помощь с дальнейшими улучшениями вашего бота, пожалуйста, дайте знать!
Assistant: ## Анализ предоставленного кода Telegram-бота

Ваш Telegram-бот представляет собой комплексное решение с множеством функциональных возможностей. Ниже представлен подробный анализ структуры, функциональности, потенциальных проблем и рекомендаций по улучшению.

### 1. **Структура и Организация Кода**

- **Модули и Импорты**: Вы использовали разнообразные библиотеки для реализации асинхронных операций (`aiosqlite`, `aiohttp`), обработки данных (`BeautifulSoup`, `xlsxwriter`) и взаимодействия с Telegram API (`aiogram`). Это обеспечивает гибкость и расширяемость бота.
  
- **Классы и Состояния**: Использование `StatesGroup` для управления состояниями (`Form`) позволяет эффективно обрабатывать различные этапы взаимодействия с пользователем, такие как генерация изображений или администрирование.

- **Асинхронность**: Бот построен на асинхронных операциях, что позволяет одновременно обслуживать нескольких пользователей без блокировок. Однако стоит обратить внимание на использование `asyncio.to_thread` для синхронных вызовов API, что может влиять на производительность при высоких нагрузках.

### 2. **Функциональные Возможности**

- **Выбор Моделей**: Пользователи могут выбирать из нескольких моделей AI (например, GPT-4o, GPT-3.5 turbo), что предоставляет гибкость в использовании.

- **Управление Подпиской**: Бот проверяет подписку пользователя на определенный канал, что позволяет контролировать доступ к функциям бота.

- **Админ-Панель**: Администраторы имеют доступ к расширенным функциям, таким как изменение тарифов, управление чатами и рассылка сообщений.

- **Обработка Медиа**: Бот способен обрабатывать различные типы сообщений, включая текст, фото, документы и аудио, что расширяет его применимость.

- **Поиск в Интернете**: Реализована функция поиска через Bing с последующим анализом результатов моделью GPT-4o для предоставления пользователю содержательных ответов.

### 3. **Потенциальные Проблемы и Риски**

- **Безопасность**:
  - **Хранение Токенов и Конфиденциальных Данных**: Убедитесь, что токены и конфиденциальные параметры API хранятся безопасно, например, используя переменные окружения или секретные хранилища.
  - **Валидация Входящих Данных**: При обработке входящих данных (например, ID чатов в админ-панели) необходимо тщательно проверять их формат и корректность, чтобы избежать потенциальных инъекций или ошибок.

- **Производительность**:
  - **Асинхронные Блокировки**: Использование `asyncio.to_thread` может привести к блокировкам при высоких нагрузках. Рассмотрите возможность использования полностью асинхронных клиентов для взаимодействия с API.
  - **Кеширование Результатов**: Для частых запросов или повторяющихся поисковых операций стоит внедрить механизм кеширования для уменьшения нагрузки и ускорения ответа.

- **Стабильность**:
  - **Обработка Исключений**: Хотя в коде реализована обработка исключений, убедитесь, что все возможные точки отказа покрыты, и бот не прекращает работу при неожиданных ошибках.
  - **Логирование**: Развернутое логирование помогает в отладке и мониторинге работы бота. Рассмотрите интеграцию с системами мониторинга для обеспечения высокой доступности.

- **Соответствие Условиям Использования**:
  - **Парсинг Bing**: Убедитесь, что парсинг результатов поиска не нарушает условия использования Bing. Рекомендуется ознакомиться с официальными [условиями использования Bing](https://www.microsoft.com/en-us/bing/apis/bing-web-search-api) и использовать официальные API при необходимости.

### 4. **Рекомендации по Улучшению**

- **Оптимизация Асинхронности**:
  - **Использование Асинхронных Клиентов API**: Вместо `asyncio.to_thread` рассмотрите возможность использования асинхронных библиотек для взаимодействия с внешними API (если они доступны), что повысит производительность.
  
- **Улучшение Управления Токенами**:
  - **Точная Учётка Использования Токенов**: Вместо простого вычитания количества символов, рассчитайте количество токенов на основе модели (например, используя библиотеку `tiktoken` для OpenAI моделей).
  
- **Повышение Безопасности**:
  - **Ограничение Доступа к Админ-Панели**: Убедитесь, что список администраторов (`ADMIN_IDS`) хранится безопасно и не может быть изменен посторонними.
  - **Проверка Входящих Данных**: Валидируйте все входящие данные от пользователей, особенно те, которые используются в запросах к базе данных или API.

- **Повышение Удобства Пользования**:
  - **Интерактивные Клавиатуры**: Используйте инлайн-клавиатуры для более удобного взаимодействия, особенно в функциях администрирования и выбора моделей.
  - **Обработка Длинных Сообщений**: Функция `send_long_message` уже реализована, но стоит убедиться, что все возможные длинные ответы корректно разбиваются и отправляются пользователю.

- **Расширение Функционала Админ-Панели**:
  - **Отчёты по Активности Пользователей**: Добавьте возможность генерации отчётов по активности пользователей, использованию токенов и другим метрикам.
  - **Резервное Копирование Базы Данных**: Реализуйте автоматическое резервное копирование базы данных для предотвращения потери данных.

- **Тестирование**:
  - **Модульные Тесты**: Напишите модульные тесты для ключевых функций бота, чтобы обеспечить их корректную работу после изменений.
  - **Тестирование Нагрузки**: Проведите тестирование под нагрузкой, чтобы определить, как бот ведет себя при большом количестве одновременных запросов.

- **Документация**:
  - **Описание Функций и Модулей**: Добавьте подробные комментарии и документацию к функциям и классам, чтобы облегчить дальнейшую поддержку и развитие бота.
  - **Руководство для Администраторов**: Создайте руководство по использованию админ-панели, описывающее все доступные функции и команды.

### 5. **Заключение**

Ваш Telegram-бот обладает широкой функциональностью и хорошо структурированным кодом. Внедрение вышеупомянутых рекомендаций поможет повысить его безопасность, производительность и удобство использования. Регулярное обновление зависимостей, мониторинг работы и обратная связь от пользователей также будут способствовать успешному функционированию и развитию бота.

Если у вас есть конкретные вопросы или требуется помощь в реализации каких-либо из предложенных улучшений, пожалуйста, сообщите!
User: ERROR:__main__:Ошибка при анализе результатов поиска с помощью GPT-4o: GPT4OAPI.send_message() got an unexpected keyword argument 'model'
Traceback (most recent call last):
  File "/root/bigbot/bot.py", line 1882, in analyze_search_results_with_gpt4o
    response = await asyncio.to_thread(
  File "/usr/lib/python3.10/asyncio/threads.py", line 25, in to_thread
    return await loop.run_in_executor(None, func_call)
  File "/usr/lib/python3.10/concurrent/futures/thread.py", line 58, in run
    result = self.fn(*self.args, **self.kwargs)
TypeError: GPT4OAPI.send_message() got an unexpected keyword argument 'model'
исправь и напиши весь код полностью без сокращений