Update app.py

app.py

@@ -1,5 +1,5 @@
 """
-دستیار هوشمند فارسی با قابلیت چت تلگرام و وب
+دستیار هوشمند فارسی با قابلیت چت تلگرام
 """
 
 import os
@@ -11,16 +11,30 @@ import asyncio
 import traceback
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, Optional, Set, List, Any
-from collections import deque
+from typing import Dict, Optional
 from contextlib import asynccontextmanager
-import tempfile
 
-# تنظیم کتابخانه‌های اصلی
+# تنظیم مسیرها
+BASE_DIR = Path(__file__).parent
+CACHE_DIR = BASE_DIR / "cache"
+LOG_DIR = BASE_DIR / "logs"
+STATIC_DIR = BASE_DIR / "static"
+TEMPLATES_DIR = BASE_DIR / "templates"
+
+# ایجاد مسیرها
+for path in [CACHE_DIR, LOG_DIR, STATIC_DIR, TEMPLATES_DIR]:
+    path.mkdir(exist_ok=True, parents=True)
+
+# تنظیم متغیرهای محیطی
+os.environ["TRANSFORMERS_CACHE"] = str(CACHE_DIR)
+os.environ["HF_HOME"] = str(CACHE_DIR)
+os.environ["TORCH_HOME"] = str(CACHE_DIR / "torch")
+
+# کتابخانه‌های اصلی
 import torch
 import transformers
-from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
-from fastapi import FastAPI, WebSocket, Request, HTTPException
+from transformers import pipeline
+from fastapi import FastAPI, WebSocket, Request
 from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
@@ -28,128 +42,123 @@ import uvicorn
 from telegram import Update, Bot, InlineKeyboardButton, InlineKeyboardMarkup, BotCommand
 from telegram.ext import Application, CommandHandler, MessageHandler, CallbackQueryHandler, filters
 import hazm
+import httpx
+
+# تنظیم لاگینگ
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(LOG_DIR / "app.log", encoding='utf-8'),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger(__name__)
 
 class Config:
     """تنظیمات اصلی برنامه"""
     
     # تنظیمات تلگرام
     TELEGRAM_TOKEN = "7437859619:AAGeGG3ZkLM0OVaw-Exx1uMRE55JtBCZZCY"
-    CHAT_ID = "-1002228627548"  # شناسه چت خودتون رو اینجا قرار بدید
-    ADMIN_CHAT_ID = "-1002228627548"  # شناسه ادمین رو اینجا قرار بدید
-    ALLOWED_CHAT_IDS = {CHAT_ID, ADMIN_CHAT_ID}  # چت‌های مجاز
+    CHAT_ID = "-1002228627548"
     
     # تنظیمات مسیرها
-    BASE_DIR = Path(__file__).parent
-    CACHE_DIR = Path(tempfile.gettempdir()) / "ai_assistant_cache"
-    LOG_DIR = Path(tempfile.gettempdir()) / "ai_assistant_logs"
+    BASE_DIR = BASE_DIR
+    CACHE_DIR = CACHE_DIR
+    LOG_DIR = LOG_DIR
+    STATIC_DIR = STATIC_DIR
+    TEMPLATES_DIR = TEMPLATES_DIR
     
     # تنظیمات مدل
-    MODEL_NAME = "HooshvareLab/bert-fa-base-uncased"
-    MAX_LENGTH = 512
+    MODEL_NAME = "bigscience/bloom-1b1"
+    MAX_LENGTH = 200
     MIN_LENGTH = 20
     TEMPERATURE = 0.7
+    TOP_K = 50
+    TOP_P = 0.95
     DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
     
     # تنظیمات عمومی
     DEBUG = True
     HOST = "0.0.0.0"
     PORT = 8000
+    MAX_RETRIES = 3
+    TIMEOUT = 30
+    CLEANUP_INTERVAL = 3600  # یک ساعت
 
-    @classmethod
-    def setup(cls):
-        """راه‌اندازی اولیه تنظیمات"""
-        # ایجاد مسیرها
-        cls.CACHE_DIR.mkdir(parents=True, exist_ok=True)
-        cls.LOG_DIR.mkdir(parents=True, exist_ok=True)
-        
-        # تنظیم متغیرهای محیطی
-        os.environ["TRANSFORMERS_CACHE"] = str(cls.CACHE_DIR)
-        os.environ["TORCH_HOME"] = str(cls.CACHE_DIR / "torch")
-        
-        # تنظیم لاگینگ
-        logging.basicConfig(
-            level=logging.DEBUG if cls.DEBUG else logging.INFO,
-            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-            handlers=[
-                logging.FileHandler(cls.LOG_DIR / "app.log", encoding='utf-8'),
-                logging.StreamHandler(sys.stdout)
-            ]
-        )
-
-class AIModel:
+class BloomAI:
     """کلاس مدیریت مدل هوش مصنوعی"""
     
     def __init__(self):
-        self.device = Config.DEVICE
-        self.model = None
-        self.tokenizer = None
         self.pipeline = None
-        self._initialize_model()
-    
-    def _initialize_model(self):
-        """راه‌اندازی مدل"""
+        self.device = Config.DEVICE
+        
+    async def initialize(self) -> bool:
         try:
-            logging.info(f"بارگذاری مدل {Config.MODEL_NAME}...")
-            
-            # بارگذاری توکنایزر
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                Config.MODEL_NAME,
-                cache_dir=Config.CACHE_DIR,
-                use_fast=True
-            )
-            
-            # بارگذاری مدل
-            self.model = AutoModelForCausalLM.from_pretrained(
-                Config.MODEL_NAME,
-                cache_dir=Config.CACHE_DIR,
-                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
-                low_cpu_mem_usage=True
-            )
-            
-            # انتقال مدل به GPU در صورت وجود
-            self.model.to(self.device)
-            
-            # ایجاد پایپلاین
-            self.pipeline = pipeline(
-                "text-generation",
-                model=self.model,
-                tokenizer=self.tokenizer,
-                device=0 if self.device == "cuda" else -1
-            )
-            
-            logging.info("مدل با موفقیت بارگذاری شد")
-            return True
-            
+            logger.info(f"Loading AI model: {Config.MODEL_NAME}")
+            for attempt in range(Config.MAX_RETRIES):
+                try:
+                    self.pipeline = pipeline(
+                        "text-generation",
+                        model=Config.MODEL_NAME,
+                        device=self.device,
+                        trust_remote_code=True
+                    )
+                    logger.info("AI model loaded successfully")
+                    return True
+                except Exception as e:
+                    if attempt < Config.MAX_RETRIES - 1:
+                        logger.warning(f"Attempt {attempt + 1} failed, retrying in 5 seconds...")
+                        await asyncio.sleep(5)
+                    else:
+                        raise e
         except Exception as e:
-            logging.error(f"خطا در بارگذاری مدل: {e}")
+            logger.error(f"Failed to load model: {str(e)}")
+            logger.error(traceback.format_exc())
             return False
-    
+
     async def generate_response(self, text: str) -> str:
-        """تولید پاسخ برای متن ورودی"""
+        """تولید پاسخ با استفاده از مدل"""
         try:
-            # نرمال‌سازی متن
-            normalizer = hazm.Normalizer()
-            text = normalizer.normalize(text)
-            
-            # تولید پاسخ
-            response = self.pipeline(
+            if not self.pipeline:
+                logger.error("Model not initialized")
+                return "مدل در دسترس نیست."
+                
+            outputs = self.pipeline(
                 text,
                 max_length=Config.MAX_LENGTH,
                 min_length=Config.MIN_LENGTH,
-                temperature=Config.TEMPERATURE,
                 do_sample=True,
-                no_repeat_ngram_size=3
+                top_k=Config.TOP_K,
+                top_p=Config.TOP_P,
+                temperature=Config.TEMPERATURE,
+                num_return_sequences=1,
+                pad_token_id=self.pipeline.tokenizer.eos_token_id
             )
             
-            # استخراج و پاکسازی پاسخ
-            generated_text = response[0]["generated_text"]
-            cleaned_response = generated_text.replace(text, "").strip()
+            generated_text = outputs[0]['generated_text']
+            # حذف متن ورودی از پاسخ
+            response = generated_text.replace(text, "").strip()
             
-            return cleaned_response
+            if not response:
+                return "متأسفم، نتوانستم پاسخ مناسبی تولید کنم."
+                
+            return response
             
         except Exception as e:
-            logging.error(f"خطا در تولید پاسخ: {e}")
-            return "متأسفانه در تولید پاسخ مشکلی پیش آمد."
+            logger.error(f"Error generating response: {e}")
+            logger.error(traceback.format_exc())
+            return "خطا در تولید پاسخ."
+
+    async def cleanup(self):
+        """پاکسازی حافظه و کش مدل"""
+        try:
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            gc.collect()
+            logger.info("Model cleanup completed")
+        except Exception as e:
+            logger.error(f"Error in cleanup: {e}")
 
 class TelegramUI:
     """کلاس مدیریت رابط کاربری تلگرام"""
@@ -191,28 +200,10 @@ class TelegramUI:
         ]
         return InlineKeyboardMarkup(keyboard)
 
-    @staticmethod
-    def get_settings_menu() -> InlineKeyboardMarkup:
-        """منوی تنظیمات"""
-        keyboard = [
-            [
-                InlineKeyboardButton("🔊 تنظیمات زبان", callback_data="lang_settings"),
-                InlineKeyboardButton("⚡️ حالت پاسخگویی", callback_data="response_mode")
-            ],
-            [
-                InlineKeyboardButton("📊 آمار عملکرد", callback_data="stats"),
-                InlineKeyboardButton("👤 پروفایل", callback_data="profile")
-            ],
-            [
-                InlineKeyboardButton("🏠 بازگشت به ��نوی اصلی", callback_data="main_menu")
-            ]
-        ]
-        return InlineKeyboardMarkup(keyboard)
-
 class TelegramBot:
     """کلاس اصلی ربات تلگرام"""
     
-    def __init__(self, ai_model: AIModel):
+    def __init__(self, ai_model: BloomAI):
         self.model = ai_model
         self.ui = TelegramUI()
         self.application = (
@@ -221,24 +212,10 @@ class TelegramBot:
             .build()
         )
         self.normalizer = hazm.Normalizer()
+        self.client = httpx.AsyncClient(timeout=Config.TIMEOUT)
         self._setup_handlers()
-        self.setup_commands()
-
-    def setup_commands(self):
-        """تنظیم دستورات ربات"""
-        commands = [
-            BotCommand("start", "شروع گفتگو با ربات"),
-            BotCommand("help", "راهنمای استفاده"),
-            BotCommand("menu", "نمایش منوی اصلی"),
-            BotCommand("settings", "تنظیمات"),
-            BotCommand("stats", "آمار عملکرد"),
-        ]
-        
-        async def set_commands():
-            bot = Bot(Config.TELEGRAM_TOKEN)
-            await bot.set_my_commands(commands)
-            
-        asyncio.create_task(set_commands())
+        self.message_queue = asyncio.Queue()
+        self.response_cache = {}
 
     def _setup_handlers(self):
         """تنظیم هندلرهای ربات"""
@@ -246,8 +223,7 @@ class TelegramBot:
         self.application.add_handler(CommandHandler("start", self.start_command))
         self.application.add_handler(CommandHandler("help", self.help_command))
         self.application.add_handler(CommandHandler("menu", self.menu_command))
-        self.application.add_handler(CommandHandler("settings", self.settings_command))
-        self.application.add_handler(CommandHandler("stats", self.stats_command))
+        self.application.add_handler(CommandHandler("cancel", self.cancel_command))
         
         # هندلر دکمه‌ها
         self.application.add_handler(CallbackQueryHandler(self.handle_callback))
@@ -283,17 +259,12 @@ class TelegramBot:
 /start - شروع مجدد ربات
 /menu - نمایش منوی اصلی
 /help - نمایش این راهنما
-/settings - تنظیمات ربات
-/stats - مشاهده آمار
+/cancel - لغو عملیات فعلی
 
 🔹 نحوه استفاده:
 1. از منوی اصلی بخش مورد نظر را انتخاب کنید
 2. در بخش چت، سوال یا متن خود را وارد کنید
 3. منتظر پاسخ بمانید
-
-🔹 نکات مهم:
-• سوالات خود را واضح و دقیق مطرح کنید
-• برای بازگشت به منو از دکمه "🏠 بازگشت" استفاده کنید
 """
         await update.message.reply_text(
             help_text,
@@ -307,27 +278,21 @@ class TelegramBot:
             reply_markup=self.ui.get_main_menu()
         )
 
-    async def settings_command(self, update: Update, context):
-        """نمایش منوی تنظیمات"""
+    async def cancel_command(self, update: Update, context):
+        """لغو عملیات فعلی"""
+        # پاک کردن صف پیام‌ها
+        while not self.message_queue.empty():
+            self.message_queue.get_nowait()
+        
         await update.message.reply_text(
-            "⚙️ تنظیمات:",
-            reply_markup=self.ui.get_settings_menu()
+            "❌ عملیات فعلی لغو شد.",
+            reply_markup=self.ui.get_main_menu()
         )
 
-    async def stats_command(self, update: Update, context):
-        """نمایش آمار"""
-        stats_text = """
-📊 آمار استفاده از ربات:
-• تعداد پیام‌های دریافتی: 0
-• تعداد پاسخ‌های ارسالی: 0
-• زمان آنلاین بودن: 0 ساعت
-"""
-        await update.message.reply_text(stats_text)
-
     async def handle_callback(self, update: Update, context):
         """پردازش دکمه‌های فشرده شده"""
         query = update.callback_query
-        await query.answer()  # پاسخ به کلیک دکمه
+        await query.answer()
         
         if query.data == "main_menu":
             await query.message.edit_text(
@@ -341,64 +306,36 @@ class TelegramBot:
                 reply_markup=self.ui.get_chat_menu()
             )
             
-        elif query.data == "settings":
-            await query.message.edit_text(
-                "⚙️ تنظیمات:",
-                reply_markup=self.ui.get_settings_menu()
-            )
-            
-        elif query.data == "help":
-            help_text = """
-📚 راهنمای استفاده از ربات:
-
-🔹 دستورات اصلی:
-/start - شروع مجدد ربات
-/menu - نمایش منوی اصلی
-/help - نمایش این راهنما
-/settings - تنظیمات ربات
-/stats - مشاهده آمار
-
-🔹 نحوه استفاده:
-1. از منوی اصلی بخش مورد نظر را انتخاب کنید
-2. در بخش چت، سوال یا متن خود را وارد کنید
-3. منتظر پاسخ بمانید
-"""
-            await query.message.edit_text(
-                help_text,
-                reply_markup=self.ui.get_main_menu()
-            )
-            
         elif query.data in ["general_chat", "qa_chat"]:
             chat_type = "عمومی" if query.data == "general_chat" else "سوال و جواب"
             await query.message.edit_text(
                 f"💬 وارد بخش چت {chat_type} شدید.\nلطفاً پیام خود را بنویسید..."
             )
-            
-        elif query.data == "translate":
-            await query.message.edit_text(
-                "📝 لطفاً متن مورد نظر برای ترجمه را وارد کنید..."
-            )
-            
-        elif query.data == "correct_text":
-            await query.message.edit_text(
-                "🔄 لطفاً متن مورد نظر برای تصحیح را وارد کنید..."
-            )
 
     async def handle_message(self, update: Update, context):
         """پردازش پیام‌های دریافتی"""
         try:
-            # بررسی دسترسی کاربر
-            if str(update.message.chat_id) not in Config.ALLOWED_CHAT_IDS:
-                await update.message.reply_text(
-                    "⚠️ شما مجوز استفاده از این ربات را ندارید."
-                )
-                return
-
             # نرمال‌سازی متن
             text = self.normalizer.normalize(update.message.text)
             
-            # دریافت پاسخ از مدل
-            response = await self.model.generate_response(text)
+            # بررسی کش
+            if text in self.response_cache:
+                response = self.response_cache[text]
+                logger.info("Using cached response")
+            else:
+                # ارسال پیام در حال پردازش
+                processing_message = await update.message.reply_text(
+                    "🤔 در حال پردازش پیام شما..."
+                )
+                
+                # دریافت پاسخ از مدل
+                response = await self.model.generate_response(text)
+                
+                # ذخیره در کش
+                self.response_cache[text] = response
+                
+                # حذف پیام در حال پردازش
+                await processing_message.delete()
             
             # ارسال پاسخ با دکمه برگشت به منو
             keyboard = [[InlineKeyboardButton("🏠 بازگشت به منو", callback_data="main_menu")]]
@@ -410,173 +347,117 @@ class TelegramBot:
             )
             
         except Exception as e:
-            logging.error(f"خطا در پردازش پیام: {e}")
+            logger.error(f"خطا در پردازش پیام: {e}")
+            logger.error(traceback.format_exc())
             await update.message.reply_text(
                 "❌ متأسفانه در پردازش پیام مشکلی پیش آمد. لطفاً دوباره تلاش کنید."
             )
 
+    async def periodic_cleanup(self):
+        """پاکسازی دوره‌ای حافظه و کش"""
+        while True:
+            await asyncio.sleep(Config.CLEANUP_INTERVAL)
+            logger.info("Starting periodic cleanup...")
+            
+            # پاکسازی کش پاسخ‌ها
+            self.response_cache.clear()
+            
+            # پاکسازی حافظه
+            await self.model.cleanup()
+            
+            logger.info("Periodic cleanup completed")
+
     async def run(self):
         """اجرای ربات"""
         try:
+            # شروع پاکسازی دوره‌ای
+            asyncio.create_task(self.periodic_cleanup())
+            
+            # راه‌اندازی ربات
             await self.application.initialize()
             await self.application.start()
-            await self.application.run_polling()
+            await self.application.run_polling(
+                allowed_updates=Update.ALL_TYPES,
+                drop_pending_updates=True
+            )
             
         except Exception as e:
-            logging.error(f"خطا در اجرای ربات: {e}")
+            logger.error(f"خطا در اجرای ربات: {e}")
+            logger.error(traceback.format_exc())
             raise
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """مدیریت چرخه حیات برنامه"""
     # راه‌اندازی
-    Config.setup()
+    logger.info("Starting application...")
     
     # ایجاد نمونه از مدل
-    app.state.model = AIModel()
-    app.state.is_ready = asyncio.Event()
+    app.state.model = BloomAI()
+    if not await app.state.model.initialize():
+        logger.error("Failed to initialize AI model")
+        sys.exit(1)
     
     # راه‌اندازی ربات تلگرام
     app.state.bot = TelegramBot(app.state.model)
     asyncio.create_task(app.state.bot.run())
     
     # آماده‌سازی کامل شد
-    app.state.is_ready.set()
+    logger.info("Application startup completed")
     
     yield
     
     # خاتمه برنامه
+    logger.info("Shutting down application...")
+    
     tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
     for task in tasks:
         task.cancel()
+    
     await asyncio.gather(*tasks, return_exceptions=True)
     
     if hasattr(app.state, "bot"):
         await app.state.bot.application.stop()
+        await app.state.bot.client.aclose()
     
-    logging.info("برنامه با موفقیت خاتمه یافت")
+    logger.info("Application shutdown completed")
 
 # ساخت نمونه FastAPI
 app = FastAPI(
     title="دستیار هوشمند",
-    description="API دستیار هوشمند مبتنی بر هوش مصنوعی",
+    description="دستیار هوشمند فارسی با قابلیت چت تلگرام",
     version="1.0.0",
     lifespan=lifespan
 )
 
-# محتوای پیش‌فرض HTML
-DEFAULT_HTML = """
-<!DOCTYPE html>
-<html dir="rtl" lang="fa">
-<head>
-    <meta charset="UTF-8">
-    <title>دستیار هوشمند</title>
-    <style>
-        body {
-            font-family: Tahoma, Arial;
-            background-color: #f5f5f5;
-            margin: 0;
-            padding: 20px;
-        }
-        .container {
-            max-width: 800px;
-            margin: 0 auto;
-            background: white;
-            padding: 20px;
-            border-radius: 10px;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        }
-        h1 { color: #1a73e8; }
-        .chat-container {
-            margin-top: 20px;
-            border: 1px solid #e0e0e0;
-            border-radius: 8px;
-            padding: 10px;
-            min-height: 300px;
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>دستیار هوشمند</h1>
-        <div id="status"></div>
-        <div class="chat-container" id="chat-container"></div>
-        <input 
-            type="text" 
-            id="message-input" 
-            placeholder="پیام خود را بنویسید..."
-            style="width: 100%; padding: 10px; margin-top: 10px;">
-        <button 
-            onclick="sendMessage()" 
-            style="margin-top: 10px; padding: 10px 20px;">
-            ارسال
-        </button>
-    </div>
-    
-    <script>
-        const ws = new WebSocket(`ws://${window.location.host}/ws`);
-        const chatContainer = document.getElementById('chat-container');
-        const messageInput = document.getElementById('message-input');
-        const statusDiv = document.getElementById('status');
-        
-        ws.onopen = () => {
-            statusDiv.textContent = 'وضعیت: متصل';
-            statusDiv.style.color = 'green';
-        };
-        
-        ws.onclose = () => {
-            statusDiv.textContent = 'وضعیت: قطع شده';
-            statusDiv.style.color = 'red';
-        };
-        
-        ws.onmessage = (event) => {
-            const response = JSON.parse(event.data);
-            appendMessage('bot', response.response);
-        };
-        
-        function appendMessage(type, text) {
-            const messageDiv = document.createElement('div');
-            messageDiv.className = `message ${type}`;
-            messageDiv.style.padding = '10px';
-            messageDiv.style.margin = '5px';
-            messageDiv.style.borderRadius = '5px';
-            
-            if (type === 'user') {
-                messageDiv.style.backgroundColor = '#e3f2fd';
-                messageDiv.style.marginLeft = '20%';
-            } else {
-                messageDiv.style.backgroundColor = '#f5f5f5';
-                messageDiv.style.marginRight = '20%';
-            }
-            
-            messageDiv.textContent = text;
-            chatContainer.appendChild(messageDiv);
-            chatContainer.scrollTop = chatContainer.scrollHeight;
-        }
-        
-        function sendMessage() {
-            const message = messageInput.value.trim();
-            if (message) {
-                appendMessage('user', message);
-                ws.send(message);
-                messageInput.value = '';
-            }
-        }
-        
-        messageInput.addEventListener('keypress', function(e) {
-            if (e.key === 'Enter') {
-                sendMessage();
-            }
-        });
-    </script>
-</body>
-</html>
-"""
+# اضافه کردن فایل‌های استاتیک
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+templates = Jinja2Templates(directory=TEMPLATES_DIR)
 
+# مسیرهای وب
 @app.get("/", response_class=HTMLResponse)
 async def home(request: Request):
     """صفحه اصلی"""
-    return HTMLResponse(content=DEFAULT_HTML)
+    return templates.TemplateResponse(
+        "index.html",
+        {
+            "request": request,
+            "bot_name": "دستیار هوشمند",
+            "model_name": Config.MODEL_NAME,
+            "is_gpu_available": torch.cuda.is_available()
+        }
+    )
+
+@app.get("/health")
+async def health_check():
+    """بررسی سلامت برنامه"""
+    return {
+        "status": "ok",
+        "timestamp": datetime.now().isoformat(),
+        "model_loaded": hasattr(app.state, "model"),
+        "bot_running": hasattr(app.state, "bot"),
+        "gpu_available": torch.cuda.is_available()
+    }
 
 @app.websocket("/ws")
 async def websocket_endpoint(websocket: WebSocket):
@@ -592,22 +473,15 @@ async def websocket_endpoint(websocket: WebSocket):
             response = await app.state.model.generate_response(text)
             
             # ارسال پاسخ
-            await websocket.send_json({"response": response})
+            await websocket.send_json({
+                "response": response,
+                "timestamp": datetime.now().isoformat()
+            })
             
     except Exception as e:
-        logging.error(f"خطا در WebSocket: {e}")
+        logger.error(f"خطا در WebSocket: {e}")
         await websocket.close()
 
-@app.get("/health")
-async def health_check():
-    """بررسی سلامت برنامه"""
-    return {
-        "status": "ok",
-        "timestamp": datetime.utcnow().isoformat(),
-        "model_loaded": hasattr(app.state, "model"),
-        "bot_running": hasattr(app.state, "bot")
-    }
-
 if __name__ == "__main__":
     # اجرای برنامه
     uvicorn.run(