_

chatbot/__init__.py

@@ -1,72 +0,0 @@
-import asyncio
-import logging
-import time
-import pyrogram
-import string
-import random
-import requests
-from inspect import getfullargspec
-from os import path
-from random import choice
-import aiohttp
-import re
-import os
-from datetime import datetime as dt
-from pyrogram import Client
-from pyrogram.types import *
-from pyrogram import filters
-from pyrogram.errors import *
-from pyrogram.raw.all import layer
-from pyrogram.handlers import MessageHandler
-from config import API_HASH, API_ID, BOT_TOKEN
-from database import db
-from logger import LOGS
-from platform import python_version
-from pyrogram import __version__ as pyrogram_version
-
-StartTime = time.time()
-START_TIME = dt.now()
-
-def send_log(text_log: str):
-    url = "https://private-akeno.randydev.my.id/api/v2/send_message_logs"
-    params = {
-        "text_log": text_log
-    }
-    response = requests.post(url, params=params)
-    if response.status_code != 200:
-        return None
-    return response.json()["message"]
-
-class Randydev(Client):
-    def __init__(self, loop=None):
-        self.loop = loop or asyncio.get_event_loop()
-
-        super().__init__(
-            "chatbotai",
-            app_version=f"akeno ai latest",
-            api_id=API_ID,
-            api_hash=API_HASH,
-            bot_token=BOT_TOKEN,
-            workers=300,
-            plugins=dict(root="chatbot.plugins"),
-            sleep_threshold=180,
-        )
-    async def start(self):
-        try:
-            await super().start()
-        except FloodWait as e:
-            LOGS.info(e)
-            await asyncio.sleep(e.value)
-        self.start_time = time.time()
-        LOGS.info(
-            "akn running with Pyrogram v%s (Layer %s) started on @%s. Hi!",
-            pyrogram.__version__,
-            layer,
-            self.me.username,
-        )
-    async def stop(self):
-        try:
-            await super().stop()
-            LOGS.warning("akn stopped, Bye!")
-        except ConnectionError:
-            LOGS.warning("akn is already terminated")

chatbot/__main__.py

@@ -1,151 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright 2020-2023 (c) Randy W @xtdevs, @xtsea
-#
-# from : https://github.com/TeamKillerX
-# Channel : @RendyProjects
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU Affero General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU Affero General Public License for more details.
-#
-# You should have received a copy of the GNU Affero General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-import asyncio
-import logging
-import sys
-import traceback
-from contextlib import closing, suppress
-from datetime import datetime as dt, timedelta
-
-from pyrogram import idle
-from uvloop import install
-
-from chatbot import Randydev
-from database import db
-from logger import LOGS
-
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logging.getLogger("pyrogram.syncer").setLevel(logging.WARNING)
-logging.getLogger("pyrogram.client").setLevel(logging.WARNING)
-loop = asyncio.get_event_loop()
-
-async def startup_tasks(bot_client):
-    task1 = asyncio.create_task(
-        premium_expiry_monitor(bot_client),
-        name="premium_expiry_monitor"
-    )
-    task2 = asyncio.create_task(
-        process_unfreezes(bot_client),
-        name="process_unfreezes"
-    )
-    return [task1, task2]
-
-async def premium_expiry_monitor(client):
-    while True:
-        try:
-            now = dt.now()
-            expired = db.user_premium.find({
-                "is_premium": True,
-                "premium_expiry": {"$lt": now}
-            })
-            
-            async for user in expired:
-                await db.user_premium.update_one(
-                    {"user_id": user["user_id"]},
-                    {"$set": {"is_premium": False}}
-                )
-                with suppress(Exception):
-                    await client.send_message(
-                        user["user_id"],
-                        "⚠️ Your premium subscription has expired\n"
-                        "You've been downgraded to free tier (5 images/day)\n\n"
-                    )
-            
-            await asyncio.sleep(3600)
-        except asyncio.CancelledError:
-            LOGS.info("Premium monitor stopped gracefully")
-        except Exception as e:
-            LOGS.error(f"Premium monitor error: {e}")
-            await asyncio.sleep(600)
-
-async def process_unfreezes(client):
-    while True:
-        try:
-            now = dt.now()
-            expired_users = db.user_blacklists.find({
-                "is_frozen": True,
-                "unfreeze_at": {"$lte": now}
-            })
-            
-            async for user in expired_users:
-                await db.user_blacklists.update_one(
-                    {"_id": user["_id"]},
-                    {"$set": {"is_frozen": False}}
-                )
-                LOGS.info(f"Auto-unfrozen user {user['user_id']}")
-
-                with suppress(Exception):
-                    await client.send_message(
-                        user["user_id"],
-                        "✅ Your restrictions have been automatically lifted"
-                    )
-            
-            await asyncio.sleep(300)
-
-        except asyncio.CancelledError:
-            LOGS.info("Unfreeze monitor stopped gracefully")
-        except Exception as e:
-            LOGS.error(f"Unfreeze task error: {str(e)}")
-            await asyncio.sleep(60)
-
-async def shutdown(loop):
-    tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
-    for task in tasks:
-        task.cancel()
-    
-    with suppress(asyncio.CancelledError):
-        await asyncio.gather(*tasks, return_exceptions=True)
-    
-    LOGS.info("Application shutdown complete")
-
-async def main():
-    bg_tasks = None
-    try:
-        await db.connect()
-        randydev = Randydev(loop=loop)
-        
-        await randydev.start()
-        bg_tasks = await startup_tasks(randydev)
-        LOGS.info("Application startup complete")
-
-        await idle()
-
-    except Exception as e:
-        LOGS.critical(f"Fatal error: {str(e)}")
-        traceback.print_exc()
-    finally:
-        for task in bg_tasks:
-            task.cancel()
-        await asyncio.gather(*bg_tasks, return_exceptions=True)
-        await shutdown(asyncio.get_event_loop())
-
-if __name__ == "__main__":
-    install()
-
-    with closing(loop):
-        with suppress(asyncio.CancelledError, KeyboardInterrupt):
-            loop.run_until_complete(main())
-
-        loop.run_until_complete(asyncio.sleep(3))
-        if not loop.is_closed():
-            loop.close()

chatbot/plugins/chat.py

@@ -1,1850 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright 2019-2025 (c) Randy W @xtdevs, @xtsea
-#
-# from : https://github.com/TeamKillerX
-# Channel : @RendyProjects
-# This project is proprietary software. Unauthorized redistribution is prohibited.
-
-import asyncio
-import base64
-import json
-import os
-import random
-import re
-import uuid
-from datetime import datetime as dt, timedelta
-from io import BytesIO
-from typing import List
-
-import cohere
-import requests
-from akenoai import *
-from akenoai.types import DifferentAPIDefault
-from google import genai
-from google.genai import types as ty
-from gpytranslate import SyncTranslator
-from PIL import Image
-from pyrogram import *
-from pyrogram import Client, enums, filters
-from pyrogram.errors import *
-from pyrogram.types import (InlineKeyboardButton, InlineKeyboardMarkup,
-                            InlineQuery, InlineQueryResultArticle,
-                            InlineQueryResultPhoto, InputMediaPhoto,
-                            InputTextMessageContent, Message)
-
-from config import *
-from database import db, users_collection
-from logger import LOGS
-
-from Ryzenth import ApiKeyFrom, SmallConvertDot
-from Ryzenth.types import RequestHumanizer
-
-ryz = ApiKeyFrom(..., True)
-
-trans = SyncTranslator()
-js = AkenoXJs(DifferentAPIDefault()).connect()
-
-message_memory_state = {}
-DISABLED_COMMANDS =  [
-    "/",
-    "/help",
-    "about:",
-    "enabled:",
-    "disabled:",
-    "pro:editimage",
-    "--stream-images",
-    "--edit-images",
-    "--reason",
-    "--deletemydata --reason"
-]
-
-def aigen_check(user_id: int, text: str):
-    result = {}
-    try:
-        response = requests.get(
-            f"https://randydev-ryu-js.hf.space/api/v1/ai/akenox/aigen-v2?query={text}",
-            headers={"x-api-key": "akeno_UKQEQMt991kh2Ehh7JqJYKapx8CCyeC"}
-        ).json()
-
-        ok = json.loads(response.get("results", "{}"))
-
-        result[user_id] = {
-            "is_image": ok.get("is_image", False),
-            "prompt": ok.get("prompt", ""),
-            "is_anti_porno": ok.get("is_anti_porno", False),
-            "reason": ok.get("reason", "")
-        }
-        return result
-    except (json.decoder.JSONDecodeError, KeyError, TypeError, requests.RequestException) as e:
-        return {user_id: {
-            "is_image": False,
-            "prompt": "",
-            "is_anti_porno": False,
-            "reason": f"Error: {str(e)}"
-        }}
-
-def is_command_disabled(text):
-  text_lower = text.lower()
-  if text_lower.startswith("/") and not (
-      text_lower.startswith("/setmodel")
-      or text_lower.startswith("/start")
-      or text_lower.startswith("/mypremium")
-  ):
-    return True
-  else:
-    return False
-
-def obfuscate(word):
-    return word.lower()\
-        .replace("a", "[a@4]")\
-        .replace("b", "[b8]")\
-        .replace("e", "[e3]")\
-        .replace("g", "[g69]")\
-        .replace("i", "[i1!|]")\
-        .replace("o", "[o0]")\
-        .replace("s", "[s5$]")\
-        .replace("t", "[t7+]")\
-        .replace("l", "[l1|]")
-
-def regex_all_blacklist(text):
-    with open("blacklist.txt", "r", encoding="utf-8") as f:
-        words = [obfuscate(w.strip()) for w in f if w.strip()]
-    pattern = r"\b(" + "|".join(words) + r")\b"
-    if re.search(pattern, text, re.IGNORECASE):
-        return True
-    else:
-        return False
-
-async def geni_files_delete(name: str):
-    url = f"https://generativelanguage.googleapis.com/v1beta/{name}"
-    params = {"key": GOOGLE_API_KEY}
-    response = requests.delete(url, params=params)
-    if response.status_code != 200:
-        return None
-    return response.text
-
-async def remove_bg_myapi(return_image):
-    with open(return_image, "rb") as image_file:
-        encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
-    payload = {
-        "image_base64": encoded_string
-    }
-    output_bg = "output.png"
-    response = requests.post("https://randydev-meta-ai.hf.space/remove-bg-base64", json=payload)
-    if response.status_code == 200:
-        result_base64 = response.json().get("output_image_base64")
-        with open(output_bg, "wb") as out_file:
-            out_file.write(base64.b64decode(result_base64))
-        return output_bg
-    else:
-        return None
-
-CREDITS_DEVELOPER = """
-🗓️ 2 May 2025
-
-🤖 @GeminiAIDev_Bot — Crafted with passion by @xtdevs
-
-🧠 Language: Python  
-🔒 Source Code: Not publicly available
-
-✨ About:  
-You’ve entered a realm where your imagination meets intelligence.  
-From ✍️ text, 🖼️ images etc, to full 🗣️ conversations — Gemini is your AI companion.
-
-🧾 Credits: Google Devs, OpenAI Engineers
-"""
-
-GEMINI_START_TEXT = """
-Welcome to Gemini AI [Dev]
-
-Users: `{user}`
-
-You’ve entered the realm of limitless possibilities.
-From text, photos, to full conversations — Gemini is your digital partner.
-
-Speak. Create. Explore. Let your thoughts ignite the machine.
-
-Type anything to begin.
-"""
-
-gen = genai.Client(api_key=GOOGLE_API_KEY)
-
-async def search_auto_by_cohere(user_id, prompt):
-    COHERE_API_KEY = os.environ.get("COHERE_API_KEY")
-    co = cohere.Client(api_key=COHERE_API_KEY)
-    chat_history = await db._get_cohere_chat_from_db(user_id)
-    chat_history.append({"role": "User", "message": prompt})
-    stream = co.chat_stream( 
-        model='command-r-08-2024',
-        message=prompt,
-        temperature=0.3,
-        chat_history=chat_history,
-        prompt_truncation='AUTO',
-        connectors=[{"id":"web-search"}]
-    )
-    data = []
-    output = ""
-    for event in stream:
-        if event.event_type == "search-results":
-            if event.documents:
-                data.extend(event.documents)
-        elif event.event_type == "text-generation":
-            output += event.text
-
-    if not data:
-        data = [{"title": "", "url": ""}]
-
-    reference_dict = {}
-    for item in data:
-        title = item.get("title", "").strip()
-        url = item.get("url", "").strip()
-        if not title or not url:
-            continue
-        if title not in reference_dict:
-            reference_dict[title] = url
-    references = ""
-    for i, (title, url) in enumerate(reference_dict.items()):
-        references += f"{i}. [{title}]({url})\n"
-
-    if not references.strip():
-        references = ""
-
-    if not output:
-        output = "I couldn't generate a response."
-
-    all_answer = f"{output}\n\n{references}"
-    chat_history.append({"role": "Chatbot", "message": all_answer})
-    await db._update_cohere_chat_in_db(user_id, chat_history)
-    return all_answer
-
-
-# Original: @GeminiAIDev_Bot
-# Code by @xtdevs
-def replace_with_markdown_list(text, pattern=r"^\s*\*\s*(.*)$"):
-    def replace(match):
-        text = match.group(1)
-        text = re.sub(r"\b(\w+)\b", r"**\1**", text)
-        return "- " + text
-    return re.sub(pattern, replace, text, flags=re.MULTILINE)
-
-like_counts = {}
-unlike_counts = {}
-TELEGRAM_MAX_LENGTH = 4096
-
-def split_message(text: str) -> List[str]:
-    if len(text) <= TELEGRAM_MAX_LENGTH:
-        return [text]
-
-    parts = []
-    while len(text) > 0:
-        if len(text) > TELEGRAM_MAX_LENGTH:
-            part = text[:TELEGRAM_MAX_LENGTH]
-            parts.append(part)
-            text = text[TELEGRAM_MAX_LENGTH:]
-        else:
-            parts.append(text)
-            text = ""
-    return parts
-
-@Client.on_callback_query(filters.regex("^closedd$"))
-async def closeed(client, callback):
-    await callback.message.delete()
-
-@Client.on_callback_query(filters.regex("^comode:([a-f0-9]{8})"))
-async def coheresearch(client, callback):
-    user_id = callback.from_user.id
-    uuidstr = callback.matches[0].group(1)
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback.answer("Sorry your account is frozen", True)
-        return
-    keyboard = []
-    keyboard.append([
-        InlineKeyboardButton("Deep Search ON", callback_data=f"deeps_on_{uuidstr}"),
-        InlineKeyboardButton("Deep Search OFF", callback_data=f"deeps_off_{uuidstr}")
-    ])
-    keyboard.append([
-        InlineKeyboardButton("Back To Menu", callback_data=f"menu_back:{uuidstr}")
-    ])
-    await callback.edit_message_reply_markup(reply_markup=InlineKeyboardMarkup(keyboard))
-
-@Client.on_callback_query(filters.regex("^human:([a-f0-9]{8})"))
-async def _humancb(client, callback):
-    user_id = callback.from_user.id
-    uuidstr = callback.matches[0].group(1)
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback.answer("Sorry your account is frozen", True)
-        return
-    keyboard = []
-    keyboard.append([
-        InlineKeyboardButton("Humanizer ON", callback_data=f"humanizer_on_{uuidstr}"),
-        InlineKeyboardButton("Humanizer OFF", callback_data=f"humanizer_off_{uuidstr}")
-    ])
-    keyboard.append([
-        InlineKeyboardButton("Back To Menu", callback_data=f"menu_back:{uuidstr}")
-    ])
-    await callback.edit_message_reply_markup(reply_markup=InlineKeyboardMarkup(keyboard))
-
-def inline_error(text: str):
-    return [
-        InlineQueryResultArticle(
-            title="❌ Error",
-            input_message_content=InputTextMessageContent(
-                message_text=f"⚠️ {text}"
-            )
-        )
-    ]
-
-@Client.on_inline_query(filters.regex(".*"))
-async def inline_search(client: Client, inline_query: InlineQuery):
-    user_id = inline_query.from_user.id
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        return
-    GOOGLE_CX = "8386c816e6fff4b2a"
-    search_query = inline_query.query.strip()
-    if not search_query:
-        return
-    try:
-        response = requests.get(
-            "https://www.googleapis.com/customsearch/v1",
-            params={
-                "key": GOOGLE_API_SEARCH,
-                "cx": GOOGLE_CX,
-                "q": search_query,
-                "searchType": "image"
-            }
-        )
-        response_json = response.json()
-
-        if "items" in response_json:
-            results = []
-            for i, item in enumerate(response_json["items"]):
-                title = item.get("title", "No Title")
-                description = item["image"].get("contextLink", "No Link")
-                url = item.get("link")
-
-                result = InlineQueryResultPhoto(
-                    photo_url=url,
-                    id=str(i),
-                    title=title,
-                    description=description,
-                    thumb_url=url,
-                    input_message_content=InputTextMessageContent(
-                        message_text=f"**Title:** {title}\n\n**Source:** {description}"
-                    ),
-                    reply_markup=InlineKeyboardMarkup(
-                        [[InlineKeyboardButton("🔗 Open Link", url=url)]]
-                    ),
-                )
-                results.append(result)
-
-            await inline_query.answer(results, cache_time=10)
-
-        else:
-            await inline_query.answer(inline_error("No result found."), cache_time=1)
-    except Exception as e:
-        await inline_query.answer(inline_error("Internal error. Try again later."), cache_time=1)
-        LOGS.error(f"[INLINE ERROR] {type(e).__name__}: {e}")
-
-@Client.on_callback_query(filters.regex("^humanizer_(on|off)_([a-f0-9]{8})$"))
-async def humanizermode(client, callback):
-    user_id = callback.from_user.id
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback.answer("Sorry your account is frozen", True)
-        return
-    check_is_system = await db.backup_chatbot.find_one({"user_id": user_id})
-    if check_is_system and check_is_system.get("is_deepsearch", False):
-        await callback.answer(f"You can OFF in deep search", show_alert=True)
-        return
-    mode, uuidstr = callback.matches[0].groups()
-    try:
-        if mode not in ("on", "off"):
-            await callback.answer("Mode invalid", show_alert=True)
-            return
-        is_human = mode == "on"
-        await db.backup_chatbot.update_one(
-            {"user_id": user_id},
-            {"$set": {"is_humanizer": is_human}},
-            upsert=True
-        )
-        await callback.answer(f"Humanizer mode is set to {mode}.", show_alert=True)
-        keyboard = create_keyboard(
-            user_id=user_id,
-            uuid_str=uuidstr
-        )
-        await callback.edit_message_reply_markup(reply_markup=keyboard)
-    except Exception as e:
-        LOGS.error(f"Humanizer Error: {e}")
-        await callback.answer("Please try again later..", show_alert=True)
-
-@Client.on_callback_query(filters.regex("^deeps_(on|off)_([a-f0-9]{8})$"))
-async def deepsearchmode(client, callback):
-    user_id = callback.from_user.id
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback.answer("Sorry your account is frozen", True)
-        return
-    check_is_system = await db.backup_chatbot.find_one({"user_id": user_id})
-    if check_is_system and check_is_system.get("is_humanizer", False):
-        await callback.answer(f"You can OFF in humanizer", show_alert=True)
-        return
-    mode, uuidstr = callback.matches[0].groups()
-    try:
-        if mode not in ("on", "off"):
-            await callback.answer("Mode invalid", show_alert=True)
-            return
-        is_deepsearch = mode == "on"
-        await db.backup_chatbot.update_one(
-            {"user_id": user_id},
-            {"$set": {"is_deepsearch": is_deepsearch}},
-            upsert=True
-        )
-        await callback.answer(f"Deep Search mode is set to {mode}.", show_alert=True)
-        keyboard = create_keyboard(
-            user_id=user_id,
-            uuid_str=uuidstr
-        )
-        await callback.edit_message_reply_markup(reply_markup=keyboard)
-    except Exception as e:
-        LOGS.error(f"Cohere Error: {e}")
-        await callback.answer("Please try again later..", show_alert=True)
-
-@Client.on_callback_query(filters.regex("^modelmenu:([a-f0-9]{8})$"))
-async def modelgeminimenu(client, callback):
-    uuidstr = callback.matches[0].group(1)
-    user_id = callback.from_user.id
-    check_is_system = await db.backup_chatbot.find_one({"user_id": user_id})
-    if check_is_system and check_is_system.get("is_deepsearch", False):
-        await callback.answer(f"You can OFF in deep search", show_alert=True)
-        return
-    if check_is_system and check_is_system.get("is_humanizer", False):
-        await callback.answer(f"You can OFF in humanizer", show_alert=True)
-        return
-    keyboard = []
-    keyboard.append([
-        InlineKeyboardButton("G Flash EXP", callback_data=f"us:gemini-2.0-flash-exp:{uuidstr}"),
-        InlineKeyboardButton("G EXP 1206", callback_data=f"us:gemini-exp-1206:{uuidstr}")
-    ])
-    keyboard.append([
-        InlineKeyboardButton("G 1.5 Flash 8B", callback_data=f"us:gemini-1.5-flash-8b:{uuidstr}"),
-        InlineKeyboardButton("G 2.0 Flash 001", callback_data=f"us:gemini-2.0-flash-001:{uuidstr}")
-    ])
-    keyboard.append([
-        InlineKeyboardButton("G 1.5 PRO", callback_data=f"us:gemini-1.5-pro:{uuidstr}"),
-        InlineKeyboardButton("G 1.5 Flash", callback_data=f"us:gemini-1.5-flash:{uuidstr}"),
-    ])
-    keyboard.append([
-        InlineKeyboardButton("Back To Menu", callback_data=f"menu_back:{uuidstr}")
-    ])
-    await callback.edit_message_reply_markup(reply_markup=InlineKeyboardMarkup(keyboard))
-
-@Client.on_callback_query(filters.regex(r"^us:(.*):([a-f0-9]{8})$"))
-async def gemini_setmodel(client, callback):
-    model, uuidstr = callback.matches[0].groups()
-    user_id = callback.from_user.id
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback.answer("Sorry your account is frozen", True)
-        return
-    await users_collection.update_one(
-        {"user_id": user_id},
-        {"$set": {"model": model}},
-        upsert=True
-    )
-    await callback.answer(f"Model set to {model}")
-    keyboard = create_keyboard(
-        user_id=user_id,
-        uuid_str=uuidstr
-    )
-    await callback.edit_message_reply_markup(reply_markup=keyboard)
-
-@Client.on_callback_query(filters.regex("^deletemydatagm$"))
-async def deletemydata(client, callback):
-    user_id = callback.from_user.id
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False):
-        await callback.answer("Sorry your account is frozen", True)
-        return
-
-    delm = await db._clear_chatbot_database(user_id)
-    if delm:
-        await callback.edit_message_text(delm)
-    else:
-        await callback.answer(delm, True)
-
-@Client.on_callback_query(filters.regex("^genprompt_(\d+)$"))
-async def geminigen_prompt(client, callback):
-    user_id = int(callback.matches[0].group(1))
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback.answer("Sorry your account is frozen", True)
-        return
-
-    captions = ""
-    file_path = "gemini-native-image.png"
-    try:
-        backup_chat = await db._get_chatbot_chat_from_db(user_id)
-        data = await db.backup_chatbot.find_one({"user_id": user_id})
-        if not data:
-            return await callback.answer("Can't found user", True)
-        get_response = data.get("prompt_image", None)
-        if not get_response:
-            return await callback.answer("Server busy try again later", True)
-        if regex_all_blacklist(get_response):
-            return await callback.answer("Sorry your account is frozen", True)
-
-        await callback.message.edit_text("....")
-        await client.send_chat_action(callback.message.chat.id, enums.ChatAction.UPLOAD_PHOTO)
-        await asyncio.sleep(2.0)
-        backup_chat.append({"role": "user", "parts": [{"text": get_response}]})
-        response = await gen.aio.models.generate_content(
-            model="gemini-2.0-flash-exp-image-generation",
-            contents=get_response,
-            config=ty.GenerateContentConfig(
-                response_modalities=['TEXT', 'IMAGE']
-            )
-        )
-        for part in response.candidates[0].content.parts:
-            if part.text is not None:
-                captions += part.text
-            elif part.inline_data is not None:
-                image = Image.open(BytesIO((part.inline_data.data)))
-                image.save(file_path)
-
-        uuid_code = str(uuid.uuid4())[:8]
-        keyboard = create_keyboard(
-            user_id=user_id,
-            uuid_str=uuid_code
-        )
-        view_button_user = anonymous_user(user_id=user_id) 
-        await callback.message.edit_media(
-            media=InputMediaPhoto(
-                media=file_path,
-                caption=captions
-            ),
-            reply_markup=keyboard
-        )
-        translation_entry = {
-            "uuid": uuid_code,
-            "text": captions,
-            "timestamp": dt.now().isoformat()
-        }
-        await db.backup_chatbot.update_one(
-            {"user_id": user_id},
-            {"$push": {"translate_history": translation_entry}},
-            upsert=True
-        )
-        backup_chat.append({"role": "model", "parts": [{"text": captions}]})
-        await db._update_chatbot_chat_in_db(user_id, backup_chat)
-        await client.send_chat_action(callback.message.chat.id, enums.ChatAction.CANCEL)
-        return
-    except Exception as e:
-        LOGS.error(f"geminigen_prompt failed: {str(e)}")
-        return await callback.message.edit_media(
-            media=InputMediaPhoto(
-                media="error.png",
-                caption="Server busy try again later"
-            ),
-            reply_markup=None
-        )
-    finally:
-        if file_path:
-            try:
-                os.remove(file_path)
-            except:
-                pass
-
-@Client.on_callback_query(filters.regex("^fluxprompt_(\d+)$"))
-async def flux_prompt(client, callback):
-    user_id = int(callback.matches[0].group(1))
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback.answer("Sorry your account is frozen", True)
-        return
-
-    file_path = None
-    file_photo = None
-    try:
-        backup_chat = await db._get_chatbot_chat_from_db(user_id)
-        data = await db.backup_chatbot.find_one({"user_id": user_id})
-        if not data:
-            return await callback.answer("Can't found user", True)
-        get_response = data.get("prompt_image", None)
-        if not get_response:
-            return await callback.answer("Server busy try again later", True)
-        if regex_all_blacklist(get_response):
-            return await callback.answer("Sorry your account is frozen", True)
-
-        await callback.message.edit_text("....")
-        await client.send_chat_action(callback.message.chat.id, enums.ChatAction.UPLOAD_PHOTO)
-        await asyncio.sleep(2.0)
-        backup_chat.append({"role": "user", "parts": [{"text": get_response}]})
-        response_js = await js.image.create(
-            "black-forest-labs/flux-1-schnell",
-            image_read=True,
-            params_data={"query": get_response},
-        )
-        file_path = "randydev.jpg"
-        with open(file_path, "wb") as f:
-            f.write(response_js)
-
-        file_photo = await gen.aio.files.upload(file=file_path)
-        while file_photo.state.name == "PROCESSING":
-            await client.send_chat_action(callback.message.chat.id, enums.ChatAction.UPLOAD_PHOTO)
-            await asyncio.sleep(10)
-            file_photo = await gen.aio.files.get(name=file_photo.name)
-        if file_photo.state.name == "FAILED":
-            return await callback.message.reply_text(f"Error: {file_photo.state.name}")
-        response = await gen.aio.models.generate_content(
-            model="gemini-2.0-flash",
-            contents=[
-                "You are a picture making a story use small don't be too many",
-                file_photo
-            ]
-        )
-        uuid_code = str(uuid.uuid4())[:8]
-        keyboard = create_keyboard(
-            user_id=user_id,
-            uuid_str=uuid_code
-        )
-        view_button_user = anonymous_user(user_id=user_id) 
-        await callback.message.edit_media(
-            media=InputMediaPhoto(
-                media=file_path,
-                caption=response.text
-            ),
-            reply_markup=keyboard
-        )
-        photo = await client.send_photo(
-            "LicenseAknBotDB",
-            file_path,
-            caption=f"User Mention: {callback.from_user.mention}\n"
-                    f"User ID: `{user_id}`",
-            reply_markup=view_button_user
-        )
-        await db.backup_chatbot.update_one(
-            {"user_id": user_id},
-            {"$set": {"file_id": photo.photo.file_id}},
-            upsert=True
-        )
-        translation_entry = {
-            "uuid": uuid_code,
-            "text": response.text,
-            "timestamp": dt.now().isoformat()
-        }
-        await db.backup_chatbot.update_one(
-            {"user_id": user_id},
-            {"$push": {"translate_history": translation_entry}},
-            upsert=True
-        )
-        backup_chat.append({"role": "model", "parts": [{"text": response.text}]})
-        await db._update_chatbot_chat_in_db(user_id, backup_chat)
-        await client.send_chat_action(callback.message.chat.id, enums.ChatAction.CANCEL)
-        return
-    except Exception as e:
-        LOGS.error(f"flux_prompt failed: {str(e)}")
-        return await callback.message.edit_media(
-            media=InputMediaPhoto(
-                media="error.png",
-                caption="Server busy try again later"
-            ),
-            reply_markup=None
-        )
-    finally:
-        if file_path and file_photo:
-            try:
-                os.remove(file_path)
-                await gen.aio.files.delete(name=file_photo.name)
-            except:
-                pass
-
-@Client.on_callback_query(filters.regex("^removerbg$"))
-async def remover_bg(client, callback):
-    user_id = callback.from_user.id
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback.answer("Sorry your account is frozen", True)
-        return
-    try:
-        data = await db.backup_chatbot.find_one({"user_id": user_id})
-        if not data:
-            return await callback.answer("Can't found user", True)
-        get_response = data.get("background_file_id", None)
-        if not get_response:
-            return await callback.answer("Server busy try again later", True)
-        media = await client.download_media(get_response)
-        await callback.message.edit_text(".....")
-        output_bg = await remove_bg_myapi(media)
-        if not output_bg:
-            return await callback.answer("Server busy try again later", True)
-        await callback.message.edit_media(
-            media=InputMediaPhoto(
-                media=output_bg,
-                caption="Uploaded now"
-            )
-        )
-        await callback.answer()
-    except Exception as e:
-        LOGS.error(f"remover_bg failed: {str(e)}")
-        return await callback.message.edit_media(
-            media=InputMediaPhoto(
-                media="error.png",
-                caption="Server busy try again later"
-            ),
-            reply_markup=None
-        )
-
-@Client.on_callback_query(filters.regex("^memory_([a-f0-9]{8})$"))
-async def memory_updated(client, callback):
-    uuidstr = callback.matches[0].group(1)
-    user_id = callback.from_user.id
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback.answer("Sorry your account is frozen", True)
-        return
-
-    translate_result = ""
-    if message_memory_state.get(callback.message.id, False):
-        return await callback.answer("Memory already updated!", show_alert=False)
-    try:
-        if user_id == 0:
-            return await callback.answer("Server busy, try again later", show_alert=True)
-
-        data_tr = await db.backup_chatbot.find_one({"user_id": user_id})
-        if not data_tr:
-            return await callback.answer("User data not found", show_alert=True)
-            
-        backup_chat = await db._get_chatbot_chat_from_db(user_id)
-        if not backup_chat:
-            backup_chat = []
-
-        if not data_tr or "translate_history" not in data_tr:
-            return await callback.answer("translate history not found")
-        
-        for translations in data_tr["translate_history"]:
-            if translations.get("uuid") == uuidstr:
-                translate_result += translations.get("text", "no translation")
-                break
-    
-        backup_chat.append({
-            "role": "model",
-            "parts": [{"text": translate_result}]
-        })
-        await asyncio.gather(
-            db._update_chatbot_chat_in_db(user_id, backup_chat),
-            callback.answer("Memory updated successfully!")
-        )
-        message_memory_state[callback.message.id] = True
-    except Exception as e:
-        LOGS.error(f"Memory update failed: {str(e)}")
-        await callback.answer("Server error", show_alert=True)
-
-@Client.on_callback_query(filters.regex("^tr_(\w+)_([a-f0-9]{8})$"))
-async def terjemahkan(client, callback):
-    targetlang, uuidstr = callback.matches[0].groups()
-    user_id = callback.from_user.id
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback.answer("Sorry your account is disabled", True)
-        return
-
-    translate_result = ""
-    try:
-        if user_id == 0:
-            return await callback.answer("Server busy try again later", True)
-        data_tr = await db.backup_chatbot.find_one({"user_id": user_id})
-        if not data_tr:
-            return await callback.answer("Can't found user", True)
-        if not data_tr or "translate_history" not in data_tr:
-            return await callback.answer("translate history not found")
-        
-        for translations in data_tr["translate_history"]:
-            if translations.get("uuid") == uuidstr:
-                translate_result += translations.get("text", "no translation")
-                break
-    
-        translation = trans(
-            translate_result,
-            sourcelang="auto",
-            targetlang=str(targetlang)
-        )
-        keyboard = create_keyboard(
-            user_id=user_id,
-            uuid_str=uuidstr
-        )
-        await callback.edit_message_text(
-            translation.text,
-            reply_markup=keyboard
-        )
-        await callback.answer("Translate Updated Now", False)
-    except Exception as e:
-        LOGS.error(f"Exception translate: {str(e)}")
-        await callback.answer("Server busy try again later", True)
-
-@Client.on_callback_query(filters.regex("^showchat$"))
-async def createchat_cb(client, callback):
-    user_id = callback.from_user.id
-    data = await db.backup_chatbot.find_one({"user_id": user_id})
-    if not data:
-        await callback.answer("Can't found user", True)
-        return
-    create_chat_uuid = data.get("create_chat_uuid", None)
-    if not create_chat_uuid:
-        await callback.answer("You can reset chat, this no chat found", True)
-        return
-    await callback.answer(f"Created Chat: {create_chat_uuid}", True)
-            
-@Client.on_callback_query(filters.regex("^trmulti_([a-f0-9]{8})$"))
-async def multiple_langagues(client, callback):
-    uuidstr = callback.matches[0].group(1)
-    user_id = callback.from_user.id
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback.answer("Sorry your account is frozen", True)
-        return
-
-    keyboard = []
-    keyboard.append([
-        InlineKeyboardButton("🇦🇪", callback_data=f"tr_ar_{uuidstr}"),
-        InlineKeyboardButton("🇦🇿", callback_data=f"tr_az_{uuidstr}")
-    ])
-    keyboard.append([
-        InlineKeyboardButton("🇧🇾", callback_data=f"tr_be_{uuidstr}"),
-        InlineKeyboardButton("🇪🇸", callback_data=f"tr_es_{uuidstr}")
-    ])
-    keyboard.append([
-        InlineKeyboardButton("🇹🇷", callback_data=f"tr_tr_{uuidstr}"),
-        InlineKeyboardButton("🇻🇳", callback_data=f"tr_vi_{uuidstr}")
-    ])
-    keyboard.append([
-        InlineKeyboardButton("🇮🇩", callback_data=f"tr_id_{uuidstr}"),
-        InlineKeyboardButton("🇺🇸", callback_data=f"tr_en_{uuidstr}")
-    ])
-    keyboard.append([
-        InlineKeyboardButton("🇮🇳", callback_data=f"tr_hi_{uuidstr}"),
-        InlineKeyboardButton("🇯🇵", callback_data=f"tr_ja_{uuidstr}")
-    ])
-    keyboard.append([
-        InlineKeyboardButton("🇲🇾", callback_data=f"tr_ms_{uuidstr}"),
-        InlineKeyboardButton("🇷🇺", callback_data=f"tr_ru_{uuidstr}"),
-    ])
-    keyboard.append([
-        InlineKeyboardButton("Back To Menu", callback_data=f"menu_back:{uuidstr}")
-    ])
-    try:
-        await callback.edit_message_reply_markup(
-            reply_markup=InlineKeyboardMarkup(keyboard)
-        )
-        await callback.answer("Translate List Now", False)
-    except Exception as e:
-        LOGS.error(f"Exception multiple_langagues: {str(e)}")
-        await callback.answer("Server busy try again later", True)
-
-def anonymous_user(user_id: int = None):
-    keyboard = InlineKeyboardMarkup(
-        [
-            [
-                InlineKeyboardButton(f"👀 View", url=f"tg://user?id={user_id}"),
-            ]
-        ]
-    )
-    return keyboard
-
-@Client.on_callback_query(filters.regex("^menu_back:([a-f0-9]{8})$"))
-async def menu_back(client, callback):
-    uuidstr = callback.matches[0].group(1)
-    user_id = callback.from_user.id
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback.answer("Sorry your account is frozen", True)
-        return
-
-    keyboard = create_keyboard(
-        user_id=user_id,
-        uuid_str=uuidstr
-    )
-    try:
-        await callback.edit_message_reply_markup(reply_markup=keyboard)
-    except MessageNotModified:
-        pass
-
-def create_keyboard(
-    likes: int = 0,
-    unlikes: int = 0,
-    user_id: int = None,
-    uuid_str: str = None,
-    is_menu: bool = False
-):
-    if is_menu:
-        keyboard = InlineKeyboardMarkup(
-            [
-                [
-                    InlineKeyboardButton(f"♾️", callback_data=f"trmulti_{uuid_str}"),
-                    InlineKeyboardButton(f"💾", callback_data=f"memory_{uuid_str}"),
-                ],
-                [
-                    InlineKeyboardButton(f"👍 {likes}", callback_data="vote:like"),
-                    InlineKeyboardButton(f"👎 {unlikes}", callback_data="vote:unlike")
-                ]
-            ]
-        )
-    else:
-        keyboard = InlineKeyboardMarkup(
-            [
-                [
-                    InlineKeyboardButton(f"♾️", callback_data=f"trmulti_{uuid_str}"),
-                    InlineKeyboardButton(f"🔒", callback_data=f"showchat"),
-                    InlineKeyboardButton(f"⛏️", callback_data=f"modelmenu:{uuid_str}"),
-                    InlineKeyboardButton(f"💡", callback_data=f"comode:{uuid_str}"),
-                    InlineKeyboardButton(f"🚶‍♀️", callback_data=f"human:{uuid_str}"),
-                    InlineKeyboardButton(f"💾", callback_data=f"memory_{uuid_str}")
-                ],
-                [
-                    InlineKeyboardButton(f"👍 {likes}", callback_data="vote:like"),
-                    InlineKeyboardButton(f"👎 {unlikes}", callback_data="vote:unlike"),
-                ]
-            ]
-        )
-    return keyboard
-
-@Client.on_callback_query(filters.regex(r"^vote:(like|unlike)$"))
-async def votes(client, callback_query):
-    message_id = callback_query.message.id
-    user_id = callback_query.from_user.id
-    action = callback_query.matches[0].group(1)
-
-    like_counts.setdefault(message_id, set())
-    unlike_counts.setdefault(message_id, set())
-
-    user_bl = await db.user_blacklists.find_one({"user_id": user_id})
-    if user_bl and user_bl.get("is_frozen", False) and user_id not in [6477856957]:
-        await callback_query.answer("Sorry, your account is frozen.", show_alert=True)
-        return
-
-    if action == "like":
-        if user_id in like_counts[message_id]:
-            like_counts[message_id].remove(user_id)
-        else:
-            like_counts[message_id].add(user_id)
-            unlike_counts[message_id].discard(user_id)
-            await callback_query.answer("Thank you for your feedback!", show_alert=False)
-
-    elif action == "unlike":
-        if user_id in unlike_counts[message_id]:
-            unlike_counts[message_id].remove(user_id)
-        else:
-            unlike_counts[message_id].add(user_id)
-            like_counts[message_id].discard(user_id)
-            await callback_query.answer("Got it, thank you!", show_alert=False)
-
-    likes = len(like_counts[message_id])
-    unlikes = len(unlike_counts[message_id])
-    updated_keyboard = create_keyboard(likes=likes, unlikes=unlikes)
-
-    try:
-        await callback_query.edit_message_reply_markup(reply_markup=updated_keyboard)
-    except MessageNotModified:
-        pass
-    await callback_query.answer()
-
-@Client.on_message(
-    ~filters.scheduled
-    & filters.command(["block"])
-    & filters.user(6477856957)
-    & ~filters.forwarded
-)
-async def blacklist_user(c, m):
-    if m.chat.type.value != "supergroup":
-        return await m.reply_text("You can only use this in public supergroups.")
-    try:
-        if m.reply_to_message:
-            getuser = m.reply_to_message.from_user.id
-        else:
-            if len(m.command) < 2:
-                return await m.reply_text("Reply to a user or pass a user_id to blacklist.")
-            getuser = int(m.command[1])
-    except Exception as e:
-        return await m.reply_text(f"⚠️ Invalid user ID: `{str(e)}`")
-
-    try:
-        unfreeze_at = dt.now() + timedelta(days=30)
-        await db.user_blacklists.update_one(
-            {"user_id": getuser},
-            {"$set": {
-                "is_frozen": True,
-                "reason": "abusive_language",
-                "frozen_at": dt.now(),
-                "unfreeze_at": unfreeze_at
-            }},
-            upsert=True
-        )
-        await c.send_message(
-            getuser,
-            "⚠️ Pengguna telah dibekukan selama 30 hari.\n"
-            f"⚠️ UserID: `{getuser}`.\n"
-            f"🕒 Expire: `{unfreeze_at.strftime('%Y-%m-%d %H:%M')}`",
-            reply_markup=InlineKeyboardMarkup([[
-                InlineKeyboardButton("⏳ Understood", callback_data="closedd")
-            ]])
-        )
-        await m.reply_text(
-            "⚠️ Pengguna telah dibekukan selama 30 hari.\n"
-            f"⚠️ UserID: `{getuser}`.\n"
-            f"🕒 Expire: `{unfreeze_at.strftime('%Y-%m-%d %H:%M')}`",
-            reply_markup=InlineKeyboardMarkup([[
-                InlineKeyboardButton("⏳ Understood", callback_data="closedd")
-            ]])
-        )
-    except Exception as e:
-        await m.reply_text(f"❌ Terjadi error saat memproses: `{e}`")
-
-@Client.on_message(
-    ~filters.scheduled
-    & filters.command(["start"])
-    & ~filters.forwarded
-)
-async def startbot(client: Client, message: Message):
-    user_bl = await db.user_blacklists.find_one({"user_id": message.from_user.id})
-    if user_bl and user_bl.get("is_frozen", False) and message.from_user.id not in [6477856957]:
-        return
-    users_all = await db.backup_chatbot.find_one({"bot_id": client.me.id})
-    users_count = len(users_all["broadcast"])
-    buttons = [
-        [
-            InlineKeyboardButton(
-                text="Developer",
-                url=f"https://t.me/xtdevs"
-            ),
-            InlineKeyboardButton(
-                text="Channel",
-                url='https://t.me/RendyProjects'
-            ),
-        ]
-    ]
-    await db.backup_chatbot.update_one(
-        {"bot_id": client.me.id},
-        {"$addToSet": {"broadcast": message.from_user.id}},
-        upsert=True
-    )
-    await message.reply_text(
-        text=GEMINI_START_TEXT.format(
-            user=f"{users_count * random.randint(0, 999999)}"
-        ),
-        disable_web_page_preview=True,
-        reply_markup=InlineKeyboardMarkup(buttons)
-    )
-
-@Client.on_message(
-    filters.incoming
-    & (
-        filters.text
-        | filters.photo
-        | filters.video
-        | filters.audio
-        | filters.voice
-        | filters.sticker
-        | filters.document
-    )
-    & filters.private
-    & ~filters.command(["start", "setmodel", "mypremium"])
-    & ~filters.forwarded
-)
-async def chatbot_talk(client: Client, message: Message):
-    user = await users_collection.find_one({"user_id": message.from_user.id})
-    model_ = user.get("model") if user else "gemini-2.0-flash"
-
-    if message.reply_to_message and message.reply_to_message.from_user:
-        if message.reply_to_message.from_user.id != client.me.id:
-            return
-
-    if message.photo:
-        file_photo = None
-        captions = ""
-        file_path = "gemini-native-image.png"
-        try:
-            user_bl = await db.user_blacklists.find_one({"user_id": message.from_user.id})
-            if user_bl and user_bl.get("is_frozen", False) and message.from_user.id not in [6477856957]:
-                return
-
-            caption = message.caption or "What this?"
-            await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_PHOTO)
-            await asyncio.sleep(1.5)
-
-            if regex_all_blacklist(caption):
-                await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-                return
-
-            if caption in ["--stream-images", "--edit-images"] or len(caption) > 350:
-                return await message.reply_text(
-                    "You can't type (error 404: creativity not found)"
-                )
-
-            stream_image_now = re.match(r"--stream-images\s*(.*)", caption, re.IGNORECASE)
-            if stream_image_now:
-                STREAM_IMAGE_PATH = await message.download()
-                uuid_code = str(uuid.uuid4())[:8]
-                try:
-                    backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
-                    backup_chat.append({"role": "user", "parts": [{"text": caption}]})
-                    with open(STREAM_IMAGE_PATH, 'rb') as f:
-                        image_bytes = f.read()
-                    async for chunk in await gen.aio.models.generate_content_stream(
-                        model="gemini-1.5-flash",
-                        contents=[
-                            str(stream_image_now.group(1)),
-                            ty.Part.from_bytes(data=image_bytes, mime_type="image/jpeg")
-                        ]
-                    ):
-                        captions += chunk.text
-
-                    if captions == "":
-                        return await message.reply_text("Server busy try again later")
-
-                    keyboard = create_keyboard(
-                        user_id=message.from_user.id,
-                        uuid_str=uuid_code
-                    )
-                    await message.reply_text(
-                        captions,
-                        disable_web_page_preview=True,
-                        reply_markup=keyboard
-                    )
-
-                    translation_entry = {
-                        "uuid": uuid_code,
-                        "text": captions,
-                        "timestamp": dt.now().isoformat()
-                    }
-                    await db.backup_chatbot.update_one(
-                        {"user_id": message.from_user.id},
-                        {"$push": {"translate_history": translation_entry}},
-                        upsert=True
-                    )
-                    backup_chat.append({"role": "model", "parts": [{"text": captions}]})
-                    await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
-                    await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-                    return
-                except Exception as e:
-                    return await message.reply_text("Server busy try again later")
-                finally:
-                    if STREAM_IMAGE_PATH:
-                        try:
-                            os.remove(STREAM_IMAGE_PATH)
-                        except:
-                            pass
-
-            edit_image_now = re.match(r"--edit-images\s*(.*)", caption, re.IGNORECASE)
-            if edit_image_now:
-                try:
-                    user_data = await db.user_premium.find_one({"user_id": message.from_user.id}) or {
-                        "user_id": message.from_user.id,
-                        "credits_used": 0,
-                        "last_reset": dt.now(),
-                        "is_premium": False,
-                        "premium_expiry": None
-                    }
-                    if dt.now() - user_data["last_reset"] > timedelta(days=1):
-                        await db.user_premium.update_one(
-                            {"user_id": message.from_user.id},
-                            {"$set": {"credits_used": 0, "last_reset": dt.now()}}
-                        )
-                        user_data["credits_used"] = 0
-
-                    if user_data.get("is_premium") and user_data["premium_expiry"] < dt.now():
-                        await db.user_premium.update_one(
-                            {"user_id": message.from_user.id},
-                            {"$set": {"is_premium": False}}
-                        )
-                        user_data["is_premium"] = False
-
-                    credit_limit = 50 if user_data["is_premium"] else 5
-                    remaining = credit_limit - user_data["credits_used"]
-                    if remaining <= 0:
-                        time_left = (user_data["last_reset"] + timedelta(days=1) - dt.now())
-                        hours = int(time_left.total_seconds() // 3600)
-                        return await message.reply_text(
-                            f"🚫 Credit Limit Reached\n\n"
-                            f"• Used: {user_data['credits_used']}/{credit_limit} images today\n"
-                            f"• Resets in: {hours} hours\n\n"
-                            f"💎 Upgrade to Premium for 50 daily credits!",
-                            reply_markup=InlineKeyboardMarkup([[
-                                InlineKeyboardButton("Get Premium", callback_data="get_premium")
-                            ]])
-                        )
-
-                    backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
-                    backup_chat.append({"role": "user", "parts": [{"text": caption}]})
-                    images = Image.open(await message.download())
-                    response = await gen.aio.models.generate_content(
-                        model="gemini-2.0-flash-exp-image-generation",
-                        contents=[str(edit_image_now.group(1)), images],
-                        config=ty.GenerateContentConfig(
-                            response_modalities=['TEXT', 'IMAGE']
-                        )
-                    )
-                    for part in response.candidates[0].content.parts:
-                        if part.text is not None:
-                            captions += part.text
-                        elif part.inline_data is not None:
-                            image = Image.open(BytesIO(part.inline_data.data))
-                            image.save(file_path)
-                    keyboard_like = create_keyboard(user_id=message.from_user.id)
-                    await message.reply_photo(
-                        file_path,
-                        caption=captions,
-                        reply_markup=keyboard_like
-                    )
-                    await db.backup_chatbot.update_one(
-                        {"user_id": message.from_user.id},
-                        {"$set": {"translate_text": captions}},
-                        upsert=True
-                    )
-                    backup_chat.append({"role": "model", "parts": [{"text": captions}]})
-                    await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
-                    is_active_premium = (
-                        user_data.get("is_premium", False) and 
-                        user_data.get("premium_expiry", dt.min) > dt.now()
-                    )
-                    new_credits_used = user_data.get("credits_used", 0) + 1
-                    should_reset = (dt.now() - user_data.get("last_reset", dt.now())) > timedelta(days=1)
-                    update = {
-                        "$set": {
-                            "credits_used": 1 if should_reset else new_credits_used,
-                            "last_reset": dt.now() if should_reset else user_data["last_reset"],
-                            "is_premium": is_active_premium
-                        }
-                    }
-                    if "premium_expiry" not in user_data:
-                        update["$set"]["premium_expiry"] = None
-                        
-                    await db.user_premium.update_one(
-                        {"user_id": message.from_user.id},
-                        update,
-                        upsert=True
-                    )
-                    await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-                    return
-                except Exception as e:
-                    LOGS.error(f"Error: Gemini Edit Image: {str(e)}")
-                    return await message.reply_text("Server busy try again later")
-                finally:
-                    if file_path:
-                        try:
-                            os.remove(file_path)
-                        except:
-                            pass
-
-            if re.findall(r"\b(pro:editimage)\b", caption, re.IGNORECASE):
-                await db.backup_chatbot.update_one(
-                    {"user_id": message.from_user.id},
-                    {"$set": {"background_file_id": message.photo.file_id}},
-                    upsert=True
-                )
-                buttons = [
-                    [
-                        InlineKeyboardButton(
-                            text="✂️ Background Remover",
-                            callback_data="removerbg"
-                        )
-                    ],
-                    [
-                        InlineKeyboardButton(
-                            text="❌ Cancel",
-                            callback_data="closedd"
-                        )
-                    ]
-                ]
-                await message.reply_photo(
-                    message.photo.file_id,
-                    caption="Are you sure you want to image this edit image?",
-                    reply_markup=InlineKeyboardMarkup(buttons)
-                )
-                return
-    
-            backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
-            backup_chat.append({"role": "user", "parts": [{"text": caption}]})
-            file_photo = await gen.aio.files.upload(file=await message.download())
-            while file_photo.state.name == "PROCESSING":
-                await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_PHOTO)
-                await asyncio.sleep(10)
-                file_photo = await gen.aio.files.get(name=file_photo.name)
-            if file_photo.state.name == "FAILED":
-                return await message.reply_text(f"Error: {file_photo.state.name}")
-            response = await gen.aio.models.generate_content(
-                model="gemini-1.5-flash",
-                contents=[str(caption), file_photo]
-            )
-            uuid_code = str(uuid.uuid4())[:8]
-            if len(response.text) > 4096:
-                text_parts = split_message(response.text)
-                for part in text_parts:
-                    await message.reply_text(part)
-            else:
-                keyboard_like = create_keyboard(
-                    user_id=message.from_user.id,
-                    uuid_str=uuid_code
-                )
-                await message.reply_text(
-                    response.text,
-                    disable_web_page_preview=True,
-                    reply_markup=keyboard_like
-                )
-            translation_entry = {
-                "uuid": uuid_code,
-                "text": response.text,
-                "timestamp": dt.now().isoformat()
-            }
-            await db.backup_chatbot.update_one(
-                {"user_id": message.from_user.id},
-                {"$push": {"translate_history": translation_entry}},
-                upsert=True
-            )
-            backup_chat.append({"role": "model", "parts": [{"text": response.text}]})
-            await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
-            LOGS.info(f"Response Upload Photo: {message.from_user.first_name} | {message.from_user.id}\n\nText: {caption}")
-            await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-            return
-
-        except Exception as e:
-            LOGS.error(f"Error: message.text: {str(e)}")
-            return await message.reply_text("Server busy try again later")
-        finally:
-            if file_photo:
-                await gen.aio.files.delete(name=file_photo.name)
-
-    if message.video:
-        video_file = None
-        try:
-            user_bl = await db.user_blacklists.find_one({"user_id": message.from_user.id})
-            if user_bl and user_bl.get("is_frozen", False) and message.from_user.id not in [6477856957]:
-                return
-
-            await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_VIDEO)
-            await asyncio.sleep(2.0)
-            caption = message.caption or "What this?"
-            if regex_all_blacklist(caption):
-                return
-
-            backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
-            backup_chat.append({"role": "user", "parts": [{"text": caption}]})
-            video_file = await gen.aio.files.upload(file=await message.download())
-            while video_file.state.name == "PROCESSING":
-                await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_VIDEO)
-                await asyncio.sleep(10)
-                video_file = await gen.aio.files.get(name=video_file.name)
-            if video_file.state.name == "FAILED":
-                return await message.reply_text(f"Error: {video_file.state.name}")
-            response = await gen.aio.models.generate_content(
-                model="gemini-1.5-flash",
-                contents=[str(caption), video_file]
-            )
-            uuid_code = str(uuid.uuid4())[:8]
-            if len(response.text) > 4096:
-                text_parts = split_message(response.text)
-                for part in text_parts:
-                    await message.reply_text(part)
-            else:
-                keyboard_like = create_keyboard(
-                    user_id=message.from_user.id,
-                    uuid_str=uuid_code
-                )
-                await message.reply_text(
-                    response.text,
-                    disable_web_page_preview=True,
-                    reply_markup=keyboard_like
-                )
-            translation_entry = {
-                "uuid": uuid_code,
-                "text": response.text,
-                "timestamp": dt.now().isoformat()
-            }
-            await db.backup_chatbot.update_one(
-                {"user_id": message.from_user.id},
-                {"$push": {"translate_history": translation_entry}},
-                upsert=True
-            )
-            backup_chat.append({"role": "model", "parts": [{"text": response.text}]})
-            await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
-            LOGS.info(f"Response Upload Video: {message.from_user.first_name} | {message.from_user.id}\n\nText: {caption}")
-            await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-            return
-
-        except Exception as e:
-            LOGS.error(f"Error: message.text: {str(e)}")
-            return await message.reply_text("Server busy try again later")
-        finally:
-            if video_file:
-                await gen.aio.files.delete(name=video_file.name)
-
-    if message.sticker:
-        sticker_file = None
-        media = None
-        try:
-            user_bl = await db.user_blacklists.find_one({"user_id": message.from_user.id})
-            if user_bl and user_bl.get("is_frozen", False) and message.from_user.id not in [6477856957]:
-                return
-
-            f = message.sticker.file_id
-            backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
-            await client.send_chat_action(message.chat.id, enums.ChatAction.CHOOSE_STICKER)
-            await asyncio.sleep(2.5)
-            media = await client.download_media(f, file_name=f"{str(uuid.uuid4())[:8]}.jpg")
-            if media.endswith(".jpg"):
-                sticker_file = await gen.aio.files.upload(file=media)
-                while sticker_file.state.name == "PROCESSING":
-                    await client.send_chat_action(message.chat.id, enums.ChatAction.CHOOSE_STICKER)
-                    await asyncio.sleep(10)
-                sticker_file = await gen.aio.files.get(name=sticker_file.name)
-                if sticker_file.state.name == "FAILED":
-                    return await message.reply_text(f"Error: {sticker_file.state.name}")
-                response = await gen.aio.models.generate_content(
-                    model="gemini-1.5-flash",
-                    contents=["funny random meme sticker words", sticker_file]
-                )
-                uuid_code = str(uuid.uuid4())[:8]
-                if len(response.text) > 4096:
-                    text_parts = split_message(response.text)
-                    for part in text_parts:
-                        await message.reply_text(part)
-                else:
-                    keyboard_like = create_keyboard(
-                        user_id=message.from_user.id,
-                        uuid_str=uuid_code
-                    )
-                    await message.reply_text(
-                        response.text,
-                        disable_web_page_preview=True,
-                        reply_markup=keyboard_like
-                    )
-
-                translation_entry = {
-                    "uuid": uuid_code,
-                    "text": response.text,
-                    "timestamp": dt.now().isoformat()
-                }
-                await db.backup_chatbot.update_one(
-                    {"user_id": message.from_user.id},
-                    {"$push": {"translate_history": translation_entry}},
-                    upsert=True
-                )
-                backup_chat.append({"role": "model", "parts": [{"text": response.text}]})
-                await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
-                LOGS.info(f"Response Upload Sticker: {message.from_user.first_name} | {message.from_user.id}")
-                await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-                return
-
-        except Exception as e:
-            LOGS.error(f"Error: message.text: {str(e)}")
-            return await message.reply_text("Server busy try again later")
-        finally:
-            if sticker_file:
-                await gen.aio.files.delete(name=sticker_file.name)
-                try:
-                    os.remove(media)
-                except:
-                    pass
-
-    if message.text:
-        await client.send_chat_action(message.chat.id, enums.ChatAction.TYPING)
-        await asyncio.sleep(1.5)
-        query = message.text.strip()
-        query_base = query
-        captions = ""
-        file_path = "gemini-native-image.png"
-        try:
-            user_bl = await db.user_blacklists.find_one({"user_id": message.from_user.id})
-            if user_bl and user_bl.get("is_frozen", False) and message.from_user.id not in [6477856957]:
-                await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-                return
-
-            if is_command_disabled(query_base):
-                await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-                return
-
-            if regex_all_blacklist(query_base):
-                unfreeze_at = dt.now() + timedelta(days=2)
-                await db.user_blacklists.update_one(
-                    {"user_id": message.from_user.id},
-                    {"$set": {
-                        "is_frozen": True,
-                        "reason": "abusive_language",
-                        "frozen_at": dt.now(),
-                        "unfreeze_at": unfreeze_at
-                    }},
-                    upsert=True
-                )
-                await message.reply_text(
-                    "⚠️ You've been restricted for 2 days\n"
-                    f"Expires: {unfreeze_at.strftime('%Y-%m-%d %H:%M')}",
-                    reply_markup=InlineKeyboardMarkup([[
-                        InlineKeyboardButton(
-                            "⏳ Understood", 
-                            callback_data="closedd"
-                        )
-                    ]])
-                )
-                return
-
-            if query_base in DISABLED_COMMANDS:
-                await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-                return
-
-            all_regex_disabled = re.match(r"(--stream-images|--edit-images)\s*(.*)", query_base, re.IGNORECASE)
-            if all_regex_disabled:
-                await message.reply_text(
-                    "Use upload your photo and caption instead of text is disabled"
-                )
-                return
-
-            if re.findall(r"\b(about:developer)\b", query_base, re.IGNORECASE):
-                await message.reply_text(CREDITS_DEVELOPER)
-                return
-
-            check_data = aigen_check(message.from_user.id, query_base)
-            user_result = check_data.get(message.from_user.id, {})
-            if user_result.get("is_anti_porno"):
-                return await message.reply_text(user_result["reason"])
-                
-            if user_result.get("is_image"):
-                try:
-                    buttons = [
-                        [
-                            InlineKeyboardButton(
-                                text="🎨 Gemini AI Generate Image",
-                                callback_data=f"genprompt_{message.from_user.id}"
-                            )
-                        ],
-                        [
-                            InlineKeyboardButton(
-                                text="🖌️ FLUX AI Generate Image",
-                                callback_data=f"fluxprompt_{message.from_user.id}"
-                            )
-                        ],
-                        [
-                            InlineKeyboardButton(
-                                text="❌ Cancel",
-                                callback_data="closedd"
-                            )
-                        ]
-                    ]
-                    await db.backup_chatbot.update_one(
-                        {"user_id": message.from_user.id},
-                        {"$set": {"prompt_image": user_result["prompt"]}},
-                        upsert=True
-                    )
-                    LOGS.info(f"Response Image Generate: {message.from_user.first_name} | {message.from_user.id}\n\nText: {query_base}")
-                    await message.reply_photo(
-                        photo="loading.jpg",
-                        caption="Are you sure you want to prompt this Image generate?",
-                        reply_markup=InlineKeyboardMarkup(buttons)
-                    )
-                    return
-                except Exception as e:
-                    LOGS.error(f"Error: Gemini Image: {str(e)}")
-                    return await message.reply_text("Server busy try again later")
-
-
-            if re.findall(r"\b(disabled:callusers)\b", query_base, re.IGNORECASE):
-                if message.from_user.id != 6477856957:
-                    return
-                try:
-                    data = await db.backup_chatbot.find({"is_system": True}).to_list(length=None)
-                    for user in data:
-                        await db.backup_chatbot.update_one(
-                            {"_id": user["_id"]},
-                            {"$set": {"is_system": False}},
-                        )
-                    await message.reply_text("All Users streaming is disabled now")
-                    return
-                except Exception as e:
-                    await message.reply_text(f"Error {str(e)}")
-                
-            if re.findall(r"\b(enabled:chatstream)\b", query_base, re.IGNORECASE):
-                await db.backup_chatbot.update_one(
-                    {"user_id": message.from_user.id},
-                    {"$set": {"is_system": True}},
-                    upsert=True
-                )
-                await message.reply_text(
-                    "Ok successfully streaming is enabled"
-                )
-                return
-    
-            if re.findall(r"\b(disabled:chatstream)\b", query_base, re.IGNORECASE):
-                await db.backup_chatbot.update_one(
-                    {"user_id": message.from_user.id},
-                    {"$set": {"is_system": False}},
-                    upsert=True
-                )
-                await message.reply_text(
-                    "Ok successfully streaming is disabled"
-                )
-                return
-    
-            check_is_system = await db.backup_chatbot.find_one({"user_id": message.from_user.id})
-            if not check_is_system:
-                uuid_create = str(uuid.uuid4())[:8]
-                await db.backup_chatbot.update_one(
-                    {"user_id": message.from_user.id},
-                    {"$set": {"is_system": False, "create_chat_uuid": uuid_create}},
-                    upsert=True
-                )
-                await message.reply_text(
-                    "Ok Updated Now Type anything to begin."
-                )
-                return
-
-            uuid_human = str(uuid.uuid4())[:8]
-            if check_is_system.get("is_humanizer", False):
-                backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
-                backup_chat.append({"role": "user", "parts": [{"text": query_base}]})
-                response = await ryz.aio.humanizer.rewrite(
-                    RequestHumanizer(
-                        text=str(query_base),
-                        writing_style="alay",
-                        author_id=str(message.from_user.id),
-                        timestamp=str(dt.now())
-                    ),
-                    pickle_json=True
-                )
-                data = SmallConvertDot(response).to_dot()
-                if len(data.text) > 4096:
-                    text_parts = split_message(data.text)
-                    for part in text_parts:
-                        await message.reply_text(part)
-                else:
-                    keyboard_like = create_keyboard(
-                        user_id=message.from_user.id,
-                        uuid_str=uuid_human
-                    )
-                    await message.reply_text(
-                        data.text,
-                        disable_web_page_preview=True,
-                        reply_markup=keyboard_like
-                    )
-                translation_entry = {
-                    "uuid": uuid_human,
-                    "text": data.text,
-                    "timestamp": dt.now().isoformat()
-                }
-                await db.backup_chatbot.update_one(
-                    {"user_id": message.from_user.id},
-                    {"$push": {"translate_history": translation_entry}},
-                    upsert=True
-                )
-                backup_chat.append({"role": "model", "parts": [{"text": data.text}]})
-                await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
-                LOGS.info(f"Response Humanizer: {message.from_user.first_name} | {message.from_user.id}\n\nText: {query_base}")
-                await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-                return
-
-
-            uuid_cohere = str(uuid.uuid4())[:8]
-            if check_is_system.get("is_deepsearch", False):
-                backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
-                backup_chat.append({"role": "user", "parts": [{"text": query_base}]})
-                results = await search_auto_by_cohere(message.from_user.id, query_base)
-                if len(results) > 4096:
-                    text_parts = split_message(results)
-                    for part in text_parts:
-                        await message.reply_text(part)
-                else:
-                    keyboard_like = create_keyboard(
-                        user_id=message.from_user.id,
-                        uuid_str=uuid_cohere
-                    )
-                    await message.reply_text(
-                        results,
-                        disable_web_page_preview=True,
-                        reply_markup=keyboard_like
-                    )
-                translation_entry = {
-                    "uuid": uuid_cohere,
-                    "text": results,
-                    "timestamp": dt.now().isoformat()
-                }
-                await db.backup_chatbot.update_one(
-                    {"user_id": message.from_user.id},
-                    {"$push": {"translate_history": translation_entry}},
-                    upsert=True
-                )
-                backup_chat.append({"role": "model", "parts": [{"text": results}]})
-                await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
-                LOGS.info(f"Response Deep Search: {message.from_user.first_name} | {message.from_user.id}\n\nText: {query_base}")
-                await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-                return
-
-            if check_is_system.get("is_system", False):
-                _deletemydata_match = re.match(r"^--deletemydata\s+--reason\s+(.+)$", query_base, re.IGNORECASE)
-                if _deletemydata_match:
-                    reasons = _deletemydata_match.group(1).strip()
-                    if not reasons:
-                        return await message.reply_text("Reason cannot be empty")
-                    if len(reasons) < 15:
-                        return await message.reply_text("Reason is too short (minimum 15 characters).")
-                    buttons = [
-                        [
-                            InlineKeyboardButton(
-                                text="💀 Delete my data history",
-                                callback_data="deletemydatagm"
-                            )
-                        ],
-                        [
-                            InlineKeyboardButton(
-                                text="❌ Cancel",
-                                callback_data="closedd"
-                            )
-                        ]
-                    ]
-                    LOGS.info(f"Response info data system: {message.from_user.first_name} | {message.from_user.id}\n\nText: {query_base}")
-                    await message.reply_text(
-                        "Are you sure you want to delete this data history?",
-                        reply_markup=InlineKeyboardMarkup(buttons)
-                    )
-                    return
-
-                test_result = ""
-                uuid_code = str(uuid.uuid4())[:8]
-                backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
-                backup_chat.append({"role": "user", "parts": [{"text": query_base}]})
-                async for chunk in await gen.aio.models.generate_content_stream(
-                    model=model_,
-                    contents=backup_chat,
-                    config=ty.GenerateContentConfig(
-                        system_instruction="You are my name Randy Dev and friends coding language Indonesia and English",
-                        response_mime_type="text/plain",
-                        temperature=0,
-                        top_p=0.95,
-                        top_k=20,
-                        candidate_count=1,
-                        seed=5,
-                        max_output_tokens=4096,
-                        stop_sequences=['STOP!'],
-                        presence_penalty=0.0,
-                        frequency_penalty=0.0,
-                    )
-                ):
-                    test_result += chunk.text
-
-                if test_result == "":
-                    return await message.reply_text("Server busy try again later")
-
-                if len(test_result) > 4096:
-                    text_parts = split_message(test_result)
-                    for part in text_parts:
-                        await message.reply_text(part)
-                else:
-                    keyboard_like = create_keyboard(
-                        user_id=message.from_user.id,
-                        uuid_str=uuid_code
-                    )
-                    await message.reply_text(
-                        test_result,
-                        disable_web_page_preview=True,
-                        reply_markup=keyboard_like
-                    )
-                translation_entry = {
-                    "uuid": uuid_code,
-                    "text": test_result,
-                    "timestamp": dt.now().isoformat()
-                }
-                await db.backup_chatbot.update_one(
-                    {"user_id": message.from_user.id},
-                    {"$push": {"translate_history": translation_entry}},
-                    upsert=True
-                )
-                backup_chat.append({"role": "model", "parts": [{"text": test_result}]})
-                await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
-                LOGS.info(f"Response Gemini System: {message.from_user.first_name} | {message.from_user.id}\n\nText: {query_base}")
-                await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-                return
-
-            _deletemydata_match = re.match(r"^--deletemydata\s+--reason\s+(.+)$", query_base, re.IGNORECASE)
-            if _deletemydata_match:
-                reasons = _deletemydata_match.group(1).strip()
-                if not reasons:
-                    await message.reply_text("Reason cannot be empty")
-                    return
-                if len(reasons) < 15:
-                    return await message.reply_text("Reason is too short (minimum 15 characters).")
-                buttons = [
-                    [
-                        InlineKeyboardButton(
-                            text="💀 Delete my data history",
-                            callback_data="deletemydatagm"
-                        )
-                    ],
-                    [
-                        InlineKeyboardButton(
-                            text="❌ Cancel",
-                            callback_data="closedd"
-                        )
-                    ]
-                ]
-                LOGS.info(f"Response info data: {message.from_user.first_name} | {message.from_user.id}\n\nText: {query_base}")
-                await message.reply_text(
-                    "Are you sure you want to delete this data history?",
-                    reply_markup=InlineKeyboardMarkup(buttons)
-                )
-                return
-
-            backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
-            backup_chat.append({"role": "user", "parts": [{"text": query_base}]})
-            chat_session = gen.aio.chats.create(
-                model=model_,
-                history=backup_chat,
-                config=ty.GenerateContentConfig(
-                    system_instruction="You are my name Randy Dev and friends coding language Indonesia and English",
-                    temperature=0,
-                    top_p=0.95,
-                    top_k=20,
-                    candidate_count=1,
-                    seed=5,
-                    max_output_tokens=4096,
-                    stop_sequences=['STOP!'],
-                    presence_penalty=0.0,
-                    frequency_penalty=0.0,
-                )
-            )
-            response_data = await chat_session.send_message(query_base)
-            output = response_data.text
-            uuid_code = str(uuid.uuid4())[:8]
-            if len(output) > 4096:
-                text_parts = split_message(output)
-                for part in text_parts:
-                    await message.reply_text(part)
-            else:
-                keyboard_like = create_keyboard(
-                    user_id=message.from_user.id,
-                    uuid_str=uuid_code
-                )
-                await message.reply_text(
-                    output,
-                    disable_web_page_preview=True,
-                    reply_markup=keyboard_like
-                )
-            translation_entry = {
-                "uuid": uuid_code,
-                "text": output,
-                "timestamp": dt.now().isoformat()
-            }
-            await db.backup_chatbot.update_one(
-                {"user_id": message.from_user.id},
-                {"$push": {"translate_history": translation_entry}},
-                upsert=True
-            )
-            backup_chat.append({"role": "model", "parts": [{"text": output}]})
-            await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
-            LOGS.info(f"Response Gemini: {message.from_user.first_name} | {message.from_user.id}\n\nText: {query_base}")
-            await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
-            return
-
-        except Exception as e:
-            LOGS.error(f"Error: message.text: {str(e)}")
-            return await message.reply_text("Server busy try again later")
-
-# Developer by @xtdevs

chatbot/plugins/myinfo.py

@@ -1,62 +0,0 @@
-import time
-import os
-from pyrogram import *
-from pyrogram.types import *
-
-from logger import LOGS
-from database import db
-from datetime import datetime as dt, timedelta
-
-@Client.on_message(filters.command("mypremium"))
-async def check_premium_status(client, message):
-    user_id = message.from_user.id
-    
-    try:
-        user_data = await db.user_premium.find_one({"user_id": user_id}) or {
-            "is_premium": False,
-            "credits_used": 0,
-            "last_reset": dt.now(),
-            "premium_expiry": None
-        }
-
-        credit_limit = 50 if user_data["is_premium"] else 5
-        remaining_credits = max(0, credit_limit - user_data.get("credits_used", 0))
-
-        is_active = user_data["is_premium"] and (
-            user_data.get("premium_expiry") is None or 
-            user_data["premium_expiry"] > dt.now()
-        )
-
-        reset_time = user_data["last_reset"] + timedelta(days=1)
-        time_left = reset_time - dt.now()
-        hours_left = int(time_left.total_seconds() // 3600)
-
-        status = "ACTIVE ✅" if is_active else "INACTIVE ❌"
-        premium_expiry = (
-            f"\n⌛ Expires: {user_data['premium_expiry'].strftime('%Y-%m-%d %H:%M')}" 
-            if user_data.get("premium_expiry") 
-            else ""
-        )
-
-        text = (
-            f"💎 <b>**Your Premium Status:**</b>\n\n"
-            f"• Status: **{status}{premium_expiry}**\n"
-            f"• Credits: `{remaining_credits}/{credit_limit}` images\n"
-            f"• Reset in: `{hours_left}` hours\n"
-            f"• Plan: `{'Premium' if is_active else 'Free Tier'}`\n\n"
-        )
-
-        markup = None
-        if not is_active:
-            markup = InlineKeyboardMarkup([[
-                InlineKeyboardButton("✨ Upgrade Premium", callback_data="get_premium")
-            ]])
-
-        await message.reply_text(
-            text,
-            reply_markup=markup,
-            disable_web_page_preview=True
-        )
-    except Exception as e:
-        LOGS.error(f"Premium check error: {str(e)}")
-        await message.reply_text("❌ Error checking your status. Please try again later.")

chatbot/plugins/payments.py

@@ -1,90 +0,0 @@
-import time
-import os
-from pyrogram import *
-from pyrogram.types import *
-from database import db
-from datetime import datetime as dt, timedelta
-
-PLAN_PREMIUM = """
-**✨ Premium Subscription Plans**  
-
-**🔹 Free Tier**:
-(For new users and testing)
-- **🖼️ Image Credits**: 5/day (resets at midnight UTC)  
-- **⚡ Features**: Basic generation only  
-- **⚠️ Restrictions**:  
-  => Blacklist keyword scanning enabled  
-  => Account freeze possible for violations  
-
-**💎 Monthly Premium**:
-**Rp 50,000** (~$3.50/month)  
-- **🖼️ Credits**: 50/day (10× free tier)  
-- **🎨 Advanced Tools**:  
-  => `--edit-images` full access  
-- **🛡️ Protection**:  
-  => Anti-freeze guarantee  
-  => Whitelisted from blacklists  
-
-**🚀 Yearly Premium**:
-**Rp 825,854** (~$58/year - **35% discount**)  
-✅ **All Monthly benefits PLUS**:  
-- **👨💻 VIP Support**: Direct developer contact  
-- **🔐 Early Access**: Beta features  
-- **💸 Best Value**: Only Rp 68,821/month  
-
-"""
-
-@Client.on_callback_query(filters.regex(r"^get_premium$"))
-async def get_premiums(client, callback):
-    keyboard = InlineKeyboardMarkup(
-        [
-            [
-                InlineKeyboardButton("💳 Buy Monthly", callback_data="buy_premium_monthly"),
-                InlineKeyboardButton("🚀 Buy Yearly", callback_data="buy_premium_yearly"),
-            ],
-            [
-                InlineKeyboardButton("☎️ Contact Support", url="https://t.me/xpushz"),
-            ],
-            [
-                InlineKeyboardButton(f"❌ Closed", callback_data="closedd")
-            ]
-        ]
-    )
-    return await callback.message.edit_text(
-        PLAN_PREMIUM,
-        reply_markup=keyboard
-    )
-
-@Client.on_callback_query(filters.regex(r"^buy_premium_(monthly|yearly)$"))
-async def premium_purchase(client, callback):
-    plan = callback.matches[0].group(1)
-    user_id = callback.from_user.id
-    if user_id != 6477856957:
-        return await callback.answer("Only Developer test")
-
-    if plan == "monthly":
-        expiry = dt.now() + timedelta(days=30)
-        price = "$4.99"
-    else:
-        expiry = dt.now() + timedelta(days=365)
-        price = "$49.99"
-    
-    await db.user_premium.update_one(
-        {"user_id": user_id},
-        {
-            "$set": {
-                "is_premium": True,
-                "premium_expiry": expiry,
-                "subscription_plan": plan
-            },
-            "$inc": {"credits_used": -50}
-        },
-        upsert=True
-    )
-    await callback.message.edit_text(
-        f"💎 Premium {plan.capitalize()} Activated!\n"
-        f"∙ Expires: {expiry.strftime('%Y-%m-%d')}\n"
-        f"∙ Daily credits: 50 images\n\n"
-        f"Thanks for your support!",
-        reply_markup=None
-    )