Upload 2 files

app_fixed_v3.py

@@ -0,0 +1,960 @@
+import gradio as gr
+import re
+import os
+import requests
+import json
+import logging
+from typing import Dict, List, Tuple, Optional
+from llm_sender_unified import create_llm_sender
+
+# ✅ مدل‌های موجود - به‌روزرسانی نوامبر 2024
+AVAILABLE_MODELS = {
+    "chatgpt": [
+        # GPT-5 Series (جدیدترین)
+        "gpt-5.1",           # بهترین برای کدنویسی و وظایف agentic
+        "gpt-5",             # مدل reasoning قبلی
+        # GPT-4 Series
+        "gpt-4.1",           # هوشمندترین non-reasoning
+        "gpt-4o",            # قدرتمند
+        "gpt-4o-mini",       # سریع و ارزان
+        "gpt-4-turbo",       # سریع‌تر از GPT-4
+    ],
+    "grok": [
+        # Grok-4 Series (جدیدترین)
+        "grok-4-fast-reasoning",      # سریع با reasoning
+        "grok-4-fast-non-reasoning",  # سریع بدون reasoning
+        "grok-4-0709",                # نسخه پایدار
+        # Grok-3 Series
+        "grok-3",                     # قدرتمند
+        "grok-3-mini",                # سبک
+        # Grok-2 Series
+        "grok-2-vision-1212",         # با قابلیت بینایی
+        "grok-2-1212",                # نسخه پایدار
+        "grok-2"                      # نسخه قدیمی
+    ]
+}
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class AnonymizerAdvanced:
+    """ناشناس‌ساز پیشرفته با روش‌های متعدد"""
+    
+    def __init__(
+        self, 
+        cerebras_key: str = None, 
+        llm_provider: str = "chatgpt", 
+        llm_model: str = None,
+        entities_to_anonymize: List[str] = None
+    ):
+        self.cerebras_key = cerebras_key or os.getenv("CEREBRAS_API_KEY")
+        self.llm_provider = llm_provider
+        self.llm_model = llm_model
+        self.entities_to_anonymize = entities_to_anonymize or ["person", "company", "amount", "percent"]
+        self.mapping_table = {}
+        self.reverse_mapping = {}
+        
+        # ایجاد LLM sender
+        self._create_llm_sender()
+        
+        logger.info(f"✅ Anonymizer Advanced مقداردهی شد با {llm_provider}")
+    
+    def _create_llm_sender(self):
+        """ایجاد LLM sender مناسب"""
+        try:
+            # ✅ همیشه از Hugging Face Secrets استفاده کن
+            if self.llm_provider == "chatgpt":
+                api_key = os.getenv("OPENAI_API_KEY")
+                logger.info("🔑 استفاده از OPENAI_API_KEY از Secrets")
+            elif self.llm_provider == "grok":
+                api_key = os.getenv("XAI_API_KEY")
+                logger.info("🔑 استفاده از XAI_API_KEY از Secrets")
+            else:
+                api_key = None
+                logger.warning("⚠️ Provider ناشناخته")
+            
+            # ایجاد sender
+            self.llm_sender = create_llm_sender(
+                provider=self.llm_provider,
+                api_key=api_key,
+                model=self.llm_model
+            )
+            
+            logger.info(f"✅ LLM Sender ایجاد شد: {self.llm_provider} - {self.llm_sender.model}")
+            
+        except Exception as e:
+            logger.error(f"❌ خطا در ایجاد LLM Sender: {e}")
+            # fallback to ChatGPT
+            self.llm_sender = create_llm_sender("chatgpt")
+
+    def set_llm_provider(self, provider: str, model: str = None, entities: List[str] = None):
+        """تغییر provider و مدل LLM و موجودیت‌های ناشناس‌سازی"""
+        self.llm_provider = provider
+        self.llm_model = model
+        if entities is not None:
+            self.entities_to_anonymize = entities
+        self._create_llm_sender()
+        logger.info(f"✅ LLM تغییر یافت به: {provider} - {model}")
+        logger.info(f"✅ موجودیت‌های ناشناس‌سازی: {self.entities_to_anonymize}")
+
+    def anonymize_with_cerebras(self, text: str) -> Tuple[str, Dict]:
+        """ناشناس‌سازی با Cerebras - بر اساس موجودیت‌های انتخابی"""
+        logger.info("🧠 روش Cerebras...")
+        
+        if not self.cerebras_key:
+            logger.error("❌ Cerebras API Key موجود نیست")
+            raise ValueError("Cerebras API Key مورد نیاز است")
+        
+        # ✅ ساخت دستورات بر اساس موجودیت‌های انتخابی
+        instructions = []
+        instruction_number = 1
+        
+        if "person" in self.entities_to_anonymize:
+            instructions.append(f"{instruction_number}. اسامی اشخاص → person-01, person-02, ...")
+            instruction_number += 1
+        
+        if "company" in self.entities_to_anonymize:
+            instructions.append(f"{instruction_number}. نام شرکت‌ها/سازمان‌ها → company-01, company-02, ...")
+            instruction_number += 1
+        
+        if "amount" in self.entities_to_anonymize:
+            instructions.append(f"{instruction_number}. مقادیر پولی → amount-01, amount-02, ...")
+            instruction_number += 1
+        
+        if "percent" in self.entities_to_anonymize:
+            instructions.append(f"{instruction_number}. درصدها → percent-01, percent-02, ...")
+            instruction_number += 1
+        
+        # اگه هیچی انتخاب نشده، متن رو همون‌طور برگردون
+        if not instructions:
+            logger.warning("⚠️ هیچ موجودیتی برای ناشناس‌سازی انتخاب نشده!")
+            return text, {}
+        
+        instructions_text = "\n".join(instructions)
+        instructions_text += f"\n{instruction_number}. فقط این توکن‌ها استفاده کنید"
+        instructions_text += f"\n{instruction_number + 1}. شماره‌های نسخه را درست حفظ کنید"
+        instructions_text += f"\n{instruction_number + 2}. اگر موجودیت تکرار شود از شماره قدیمی استفاده کنید"
+        
+        try:
+            # مرحله 1: ناشناس‌سازی متن
+            prompt1 = f"""متن زیر را ناشناس کنید. قوانین:
+{instructions_text}
+
+متن:
+{text}
+
+خروجی: فقط متن ناشناس شده"""
+            
+            response1 = requests.post(
+                "https://api.cerebras.ai/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {self.cerebras_key}",
+                    "Content-Type": "application/json"
+                },
+                json={
+                    "model": "llama-3.3-70b",
+                    "messages": [{"role": "user", "content": prompt1}],
+                    "max_tokens": 4096,
+                    "temperature": 0.1
+                },
+                timeout=60
+            )
+            
+            if response1.status_code != 200:
+                logger.error(f"❌ Cerebras Error: {response1.status_code}")
+                raise Exception(f"Cerebras API Error: {response1.status_code}")
+            
+            anonymized_text = response1.json()['choices'][0]['message']['content'].strip()
+            logger.info("✅ Cerebras: ناشناس‌سازی موفق")
+            
+            # مرحله 2: استخراج mapping - فقط برای موجودیت‌های انتخابی
+            mapping_instructions = []
+            json_example = "{\n"
+            
+            if "person" in self.entities_to_anonymize:
+                mapping_instructions.append('- برای person-XX: نام کامل شخص (مثلاً "علی احمدی")')
+                json_example += '  "person-01": "متن اصلی کامل",\n'
+            
+            if "company" in self.entities_to_anonymize:
+                mapping_instructions.append('- برای company-XX: نام کامل شرکت/سازمان (مثلاً "شرکت پتروشیمی")')
+                json_example += '  "company-01": "متن اصلی کامل",\n'
+            
+            if "amount" in self.entities_to_anonymize:
+                mapping_instructions.append('- برای amount-XX: عدد + واحد (مثلاً "80 هزار تومان" یا "50 میلیارد ریال")')
+                json_example += '  "amount-01": "متن اصلی کامل با واحد",\n'
+            
+            if "percent" in self.entities_to_anonymize:
+                mapping_instructions.append('- برای percent-XX: عدد + کلمه "درصد" (مثلاً "40 درصد" نه فقط "40")')
+                json_example += '  "percent-01": "عدد + درصد",\n'
+            
+            json_example += "  ...\n}"
+            mapping_instructions_text = "\n".join(mapping_instructions)
+            
+            prompt2 = f"""متن اصلی:
+{text}
+
+متن ناشناس شده:
+{anonymized_text}
+
+لطفاً یک جدول mapping برای همه توکن‌های ناشناس ایجاد کن.
+برای هر توکن، متن اصلی کامل آن را مشخص کن.
+
+**مهم:** 
+{mapping_instructions_text}
+
+خروجی را به این فرمت JSON بده (فقط JSON، بدون توضیح اضافی):
+{json_example}"""
+            
+            response2 = requests.post(
+                "https://api.cerebras.ai/v1/chat/completions",
+                headers={
+                    "Authorization": f"Bearer {self.cerebras_key}",
+                    "Content-Type": "application/json"
+                },
+                json={
+                    "model": "llama-3.3-70b",
+                    "messages": [{"role": "user", "content": prompt2}],
+                    "max_tokens": 2048,
+                    "temperature": 0.1
+                },
+                timeout=60
+            )
+            
+            if response2.status_code == 200:
+                mapping_text = response2.json()['choices'][0]['message']['content'].strip()
+                mapping_text = mapping_text.replace('```json', '').replace('```', '').strip()
+                
+                try:
+                    self.mapping_table = json.loads(mapping_text)
+                    self._fix_percent_mapping()
+                    self.reverse_mapping = {v: k for k, v in self.mapping_table.items()}
+                    logger.info(f"✅ Mapping استخراج شد: {len(self.mapping_table)} موجودیت")
+                except json.JSONDecodeError:
+                    logger.warning("⚠️ خطا در parse کردن JSON mapping - استفاده از روش fallback")
+                    self._extract_mapping_from_text(text, anonymized_text)
+            else:
+                logger.warning("⚠️ خطا در دریافت mapping - استفاده از روش fallback")
+                self._extract_mapping_from_text(text, anonymized_text)
+            
+            return anonymized_text, self.mapping_table
+                
+        except Exception as e:
+            logger.error(f"❌ Cerebras Exception: {e}")
+            raise
+    
+    def _fix_percent_mapping(self):
+        """اصلاح mapping برای درصدها"""
+        for token, value in self.mapping_table.items():
+            value_str = str(value).strip()
+            
+            if token.startswith('percent-'):
+                if not re.search(r'(درصد|%|درصدی)', value_str):
+                    self.mapping_table[token] = f"{value_str} درصد"
+                    logger.info(f"✅ اصلاح {token}: '{value_str}' → '{value_str} درصد'")
+            
+            elif token.startswith('amount-'):
+                if not re.search(r'(میلیارد|میلیون|هزار|تومان|ریال|دلار|یورو|تن)', value_str):
+                    logger.warning(f"⚠️ {token}: فقط عدد '{value_str}' - واحد مشخص نیست")
+
+    def _extract_mapping_from_text(self, original: str, anonymized: str):
+        """استخراج mapping از متن‌های اصلی و ناشناس شده - فقط برای موجودیت‌های انتخابی"""
+        
+        # ✅ استخراج فقط توکن‌های انتخابی
+        all_tokens = []
+        for entity_type in self.entities_to_anonymize:
+            tokens = re.findall(f'{entity_type}-\\d+', anonymized)
+            all_tokens.extend([(t, entity_type) for t in tokens])
+        
+        all_tokens = sorted(set(all_tokens), key=lambda x: (x[1], int(x[0].split('-')[1])))
+        
+        # ✅ الگوهای موجودیت - فقط برای انتخابی‌ها
+        patterns = {}
+        if "person" in self.entities_to_anonymize:
+            patterns['person'] = r'\b[ء-ي]+\s+[ء-ي]+(?:\s+[ء-ي]+)*\b'
+        if "company" in self.entities_to_anonymize:
+            patterns['company'] = r'(?:شرکت|بانک|سازمان|گروه|هلدینگ)\s+[ء-ي]+(?:\s+[ء-ي]+)*'
+        if "amount" in self.entities_to_anonymize:
+            patterns['amount'] = r'\d+(?:\.\d+)?\s*(?:میلیارد|میلیون|هزار|تومان|ریال|دلار|یورو|تن)'
+        if "percent" in self.entities_to_anonymize:
+            patterns['percent'] = r'\d+(?:\.\d+)?\s*(?:درصد|%|درصدی)'
+        
+        original_entities = {}
+        for entity_type, pattern in patterns.items():
+            matches = list(re.finditer(pattern, original))
+            original_entities[entity_type] = [m.group().strip() for m in matches]
+        
+        for token, entity_type in all_tokens:
+            if entity_type in original_entities and original_entities[entity_type]:
+                token_num = int(token.split('-')[1]) - 1
+                
+                if token_num < len(original_entities[entity_type]):
+                    original_text = original_entities[entity_type][token_num]
+                    self.mapping_table[token] = original_text
+                    self.reverse_mapping[original_text] = token
+                else:
+                    original_text = original_entities[entity_type][-1]
+                    if token not in self.mapping_table:
+                        self.mapping_table[token] = original_text
+                        self.reverse_mapping[original_text] = token
+    
+    def analyze_with_llm(self, anonymized_text: str, analysis_prompt: str = None) -> str:
+        """استفاده از LLM یکپارچه"""
+        logger.info(f"🤖 {self.llm_provider.upper()} اجرای پرامپت...")
+        
+        if not analysis_prompt or not analysis_prompt.strip():
+            logger.info("⚠️  پرامپت خالی - بدون تحلیل")
+            return "⚠️ هیچ دستور تحلیل داده نشده است"
+        
+        # ✅ ساخت پیام توجه بر اساس موجودیت‌های انتخاب‌شده
+        tokens_instruction = []
+        examples = []
+        
+        if "person" in self.entities_to_anonymize:
+            tokens_instruction.append("person-XX")
+            examples.append("✅ صحیح: person-01 در جلسه حضور داشت\n❌ غلط: آقای person-01 یا شخص person-01")
+        
+        if "company" in self.entities_to_anonymize:
+            tokens_instruction.append("company-XX")
+            examples.append("✅ صحیح: company-01 فعالیت کرد\n❌ غلط: شرکت company-01 یا سازمان company-01")
+        
+        if "amount" in self.entities_to_anonymize:
+            tokens_instruction.append("amount-XX")
+            examples.append("✅ صحیح: فروش amount-01 بود\n❌ غلط: فروش مبلغ amount-01 یا فروش با amount-01")
+            examples.append("⚠️ بسیار مهم: فقط amount-01 بنویس، نه 'مبلغ amount-01' یا 'با amount-01' یا 'به amount-01'")
+        
+        if "percent" in self.entities_to_anonymize:
+            tokens_instruction.append("percent-XX")
+            examples.append("✅ صحیح: رشد percent-01 داشت\n❌ غلط: رشد درصد percent-01")
+        
+        tokens_str = ", ".join(tokens_instruction)
+        examples_str = "\n".join(examples)
+        
+        # ✅ اضافه کردن هشدار ویژه برای amount
+        special_warning = ""
+        if "amount" in self.entities_to_anonymize:
+            special_warning = """
+🚨 هشدار ویژه برای amount-XX:
+- NEVER write: "مبلغ amount-01" → ONLY write: "amount-01"
+- NEVER write: "فروش به amount-01" → ONLY write: "فروش amount-01"
+- NEVER write: "با amount-02" → ONLY write: "amount-02"
+- NEVER add ANY word before or after amount tokens!
+"""
+        
+        combined_text = f"""متن ناشناس‌سازی شده:
+{anonymized_text}
+
+دستورات:
+{analysis_prompt}
+
+⚠️ قوانین مهم:
+1. فقط از کدهای ناشناس موجود استفاده کن: {tokens_str}
+2. هیچ کلمه‌ای قبل یا بعد از این کدها اضافه نکن
+3. کد جدید ایجاد نکن
+4. ساختار دقیق متن را حفظ کن
+5. فرمت دقیق را حفظ کن: amount-01 نه amount- 01 یا amount -01
+
+{special_warning}
+
+مثال‌های صحیح و غلط:
+{examples_str}
+
+هشدار: اگر کلمه‌ای مثل "شرکت"، "آقای"، "مبلغ"، "با"، "به" قبل از کدها بگذاری، پاسخ غلط است!"""
+        
+        try:
+            # ✅ برای GPT-4 از temperature پایین‌تر استفاده کن
+            temp_to_use = 0.1 if self.llm_model and 'gpt-4' in self.llm_model.lower() else 0.2
+            logger.info(f"🌡️ Temperature: {temp_to_use} (مدل: {self.llm_model})")
+            
+            # استفاده از متد send با temperature سفارشی
+            response = self.llm_sender.send(
+                combined_text, 
+                lang='fa',
+                temperature=temp_to_use,
+                max_tokens=2000
+            )
+            
+            # ✅ پاکسازی کلمات اضافی (لایه امنیتی دوم)
+            response = self._clean_llm_response(response)
+            
+            logger.info(f"✅ {self.llm_provider.upper()}: {len(response)} کاراکتر")
+            return response
+        except Exception as e:
+            logger.error(f"❌ {self.llm_provider.upper()} Exception: {e}")
+            return f"❌ خطا در ارتباط با {self.llm_provider.upper()}: {str(e)}"
+    
+    def _clean_llm_response(self, text: str) -> str:
+        """پاکسازی کلمات اضافی که LLM ممکن است قبل از موجودیت‌ها اضافه کرده باشد"""
+        logger.info("🧹 پاکسازی کلمات اضافی...")
+        
+        cleaned = text
+        changes_made = 0
+        
+        # الگوهای کلمات اضافی برای هر نوع موجودیت
+        patterns = []
+        
+        if "person" in self.entities_to_anonymize:
+            patterns.extend([
+                (r'(?:آقای|خانم|شخص)\s+(person-\d+)', r'\1'),
+                (r'(person-\d+)\s+(?:نامدار|محترم)', r'\1'),
+            ])
+        
+        if "company" in self.entities_to_anonymize:
+            patterns.extend([
+                (r'(?:شرکت|سازمان|گروه|هلدینگ|بانک)\s+(company-\d+)', r'\1'),
+                (r'(company-\d+)\s+(?:محترم)', r'\1'),
+            ])
+        
+        if "amount" in self.entities_to_anonymize:
+            patterns.extend([
+                # ✅ الگوهای بیشتر برای amount
+                (r'(?:مبلغ|رقم|عدد|قیمت|ارزش|فروش|درآمد|هزینه|سود|زیان)\s+(amount-\d+)', r'\1'),
+                (r'(amount-\d+)\s+(?:ریال|تومان|دلار|یورو|میلیون|میلیارد|هزار)', r'\1'),
+                # ✅ حذف "به" قبل از amount
+                (r'\bبه\s+(amount-\d+)', r'\1'),
+                # ✅ حذف "با" قبل از amount  
+                (r'\bبا\s+(amount-\d+)', r'\1'),
+                # ✅ حذف "از" قبل از amount
+                (r'\bاز\s+(amount-\d+)', r'\1'),
+                # ✅ حذف "تا" قبل از amount
+                (r'\bتا\s+(amount-\d+)', r'\1'),
+            ])
+        
+        if "percent" in self.entities_to_anonymize:
+            patterns.extend([
+                (r'(?:درصد|%)\s+(percent-\d+)', r'\1'),
+                (r'(percent-\d+)\s+(?:درصد|درصدی|%)', r'\1'),
+            ])
+        
+        # اعمال الگوها
+        for pattern, replacement in patterns:
+            new_text = re.sub(pattern, replacement, cleaned)
+            if new_text != cleaned:
+                changes_made += re.subn(pattern, replacement, cleaned)[1]
+                cleaned = new_text
+        
+        if changes_made > 0:
+            logger.info(f"✅ {changes_made} کلمه اضافی حذف شد")
+        else:
+            logger.info("✅ کلمه اضافی یافت نشد")
+        
+        return cleaned
+    
+    def restore_text(self, anonymized_text: str) -> str:
+        """بازگردانی متن"""
+        logger.info("🔄 بازگردانی متن...")
+        
+        if not self.mapping_table:
+            logger.warning("⚠️ جدول نگاشت خالی است")
+            return anonymized_text
+        
+        logger.info(f"📋 تعداد موجودیت‌ها در mapping: {len(self.mapping_table)}")
+        
+        # ✅ STEP 1: ابتدا normalize کن (فاصله‌ها را درست کن)
+        restored = self._normalize_tokens(anonymized_text)
+        
+        # ✅ STEP 2: بعد clean کن (کلمات اضافی را حذف کن)
+        # این ترتیب مهمه چون بعد از normalize، clean بهتر کار می‌کنه
+        restored = self._clean_for_restore(restored)
+        
+        replacements_count = 0
+        
+        # جایگزینی با ترتیب از طولانی‌ترین به کوتاه‌ترین برای جلوگیری از جایگزینی اشتباه
+        for placeholder, original in sorted(self.mapping_table.items(), key=lambda x: len(x[0]), reverse=True):
+            if placeholder in restored:
+                restored = restored.replace(placeholder, original)
+                replacements_count += 1
+                logger.info(f"✅ {placeholder} → {original[:30]}...")
+            else:
+                logger.warning(f"⚠️ {placeholder} در متن یافت نشد!")
+        
+        logger.info(f"✅ بازگردانی کامل - {replacements_count}/{len(self.mapping_table)} جایگزین شد")
+        
+        # ✅ اگر amount ها جایگزین نشدن، سعی کن با regex پیداشون کنی
+        if replacements_count < len(self.mapping_table):
+            logger.info("🔍 تلاش برای یافتن توکن‌های گم‌شده با regex...")
+            restored = self._restore_with_regex(restored)
+        
+        # اگر هیچ جایگزینی انجام نشد، احتمالاً مشکل وجود دارد
+        if replacements_count == 0 and len(self.mapping_table) > 0:
+            logger.error("❌ هیچ توکنی جایگزین نشد! متن ورودی احتمالاً متفاوت است.")
+        
+        return restored
+    
+    def _clean_for_restore(self, text: str) -> str:
+        """پاکسازی خاص برای بازگردانی (شبیه _clean_llm_response اما سبک‌تر)"""
+        logger.info("🧹 پاکسازی قبل از بازگردانی...")
+        
+        cleaned = text
+        changes_made = 0
+        
+        patterns = []
+        
+        if "amount" in self.entities_to_anonymize:
+            patterns.extend([
+                (r'(?:مبلغ|رقم|عدد|قیمت|ارزش|فروش|درآمد|هزینه|سود|زیان)\s+(amount-\d+)', r'\1'),
+                (r'\bبه\s+(amount-\d+)', r'\1'),
+                (r'\bبا\s+(amount-\d+)', r'\1'),
+                (r'\bاز\s+(amount-\d+)', r'\1'),
+                (r'\bتا\s+(amount-\d+)', r'\1'),
+            ])
+        
+        for pattern, replacement in patterns:
+            new_text = re.sub(pattern, replacement, cleaned)
+            if new_text != cleaned:
+                changes_made += re.subn(pattern, replacement, cleaned)[1]
+                cleaned = new_text
+        
+        if changes_made > 0:
+            logger.info(f"✅ {changes_made} کلمه اضافی حذف شد")
+        
+        return cleaned
+    
+    def _restore_with_regex(self, text: str) -> str:
+        """بازگردانی با استفاده از regex برای پیدا کردن توکن‌های دارای کلمات اضافی"""
+        restored = text
+        
+        for placeholder, original in self.mapping_table.items():
+            # اگر قبلاً جایگزین شده، رد شو
+            if placeholder not in text:
+                # الگوی regex: کلمه اضافی (اختیاری) + توکن
+                # مثلاً: "فروش amount-01" یا "مبلغ amount-05"
+                entity_type = placeholder.split('-')[0]
+                entity_num = placeholder.split('-')[1]
+                
+                # الگوهای مختلف
+                patterns = [
+                    # کلمه فارسی + فاصله + توکن
+                    rf'[ء-ي]+\s+({entity_type}-{entity_num})\b',
+                    # توکن + فاصله + کلمه فارسی
+                    rf'\b({entity_type}-{entity_num})\s+[ء-ي]+',
+                    # فاصله اضافی داخل توکن
+                    rf'\b{entity_type}\s+-\s+{entity_num}\b',
+                ]
+                
+                for pattern in patterns:
+                    matches = list(re.finditer(pattern, restored))
+                    if matches:
+                        logger.info(f"✅ پیدا شد با regex: {pattern}")
+                        for match in matches:
+                            # جایگزینی کل عبارت با فقط original
+                            full_match = match.group(0)
+                            # اگر توکن داخل match هست، فقط اون رو جایگزین کن
+                            if placeholder in full_match:
+                                restored = restored.replace(full_match, full_match.replace(placeholder, original))
+                            else:
+                                # اگر فرمت توکن متفاوت بود
+                                restored = restored.replace(full_match, original)
+                            logger.info(f"✅ regex: {placeholder} → {original[:30]}...")
+                        break
+        
+        return restored
+    
+    def _normalize_tokens(self, text: str) -> str:
+        """نرمال‌سازی توکن‌ها - حذف فاصله‌های اضافی"""
+        logger.info("🧹 نرمال‌سازی توکن‌ها...")
+        
+        normalized = text
+        changes = 0
+        
+        # الگوهای فاصله اضافی در توکن‌ها
+        patterns = [
+            # حذف فاصله‌های اضافی داخل توکن
+            (r'(person|company|amount|percent)\s*-\s*(\d+)', r'\1-\2'),
+            # حذف فاصله‌های اضافی بعد از توکن
+            (r'(person|company|amount|percent)-(\d+)\s+(?=[^\d])', r'\1-\2 '),
+        ]
+        
+        for pattern, replacement in patterns:
+            new_text = re.sub(pattern, replacement, normalized)
+            if new_text != normalized:
+                changes += re.subn(pattern, replacement, normalized)[1]
+                normalized = new_text
+        
+        if changes > 0:
+            logger.info(f"✅ {changes} فاصله اضافی حذف شد")
+        
+        return normalized
+    
+    def get_mapping_table_md(self) -> str:
+        """تبدیل جدول نگاشت به Markdown"""
+        if not self.mapping_table:
+            return "### 📋 جدول نگاشت\n\nهیچ موجودیتی شناسایی نشد"
+        
+        table = "### 📋 جدول نگاشت\n\n"
+        table += "| شناسه | متن اصلی |\n"
+        table += "|-------|----------|\n"
+        
+        for token, original in sorted(self.mapping_table.items()):
+            table += f"| **{token}** | {original} |\n"
+        
+        return table
+
+# متغیر سراسری
+anonymizer = None
+
+def process(
+    input_text: str, 
+    analysis_prompt: str, 
+    llm_provider: str, 
+    llm_model: str,
+    anonymize_all: bool,
+    anonymize_person: bool,
+    anonymize_company: bool,
+    anonymize_amount: bool,
+    anonymize_percent: bool
+):
+    """پردازش متن - 4 مرحله"""
+    global anonymizer
+    
+    if not input_text.strip():
+        return "", "", "", ""
+    
+    # ✅ ساخت لیست موجودیت‌های انتخابی
+    if anonymize_all:
+        entities = ["person", "company", "amount", "percent"]
+    else:
+        entities = []
+        if anonymize_person:
+            entities.append("person")
+        if anonymize_company:
+            entities.append("company")
+        if anonymize_amount:
+            entities.append("amount")
+        if anonymize_percent:
+            entities.append("percent")
+    
+    # اگه هیچی انتخاب نشده
+    if not entities:
+        return "", "❌ لطفاً حداقل یک موجودیت برای ناشناس‌سازی انتخاب کنید", "", ""
+    
+    cerebras_key = os.getenv("CEREBRAS_API_KEY")
+    
+    # ایجاد یا آپدیت anonymizer
+    if not anonymizer:
+        anonymizer = AnonymizerAdvanced(
+            cerebras_key, 
+            llm_provider=llm_provider,
+            llm_model=llm_model,
+            entities_to_anonymize=entities
+        )
+    else:
+        anonymizer.set_llm_provider(llm_provider, llm_model, entities)
+        anonymizer.mapping_table = {}
+        anonymizer.reverse_mapping = {}
+    
+    try:
+        logger.info("=" * 70)
+        logger.info(f"🚀 شروع پردازش - LLM: {llm_provider} ({llm_model})")
+        logger.info(f"🎯 موجودیت‌های انتخابی: {', '.join(entities)}")
+        logger.info("=" * 70)
+        
+        # مرحله 1: ناشناس‌سازی
+        logger.info("🔐 مرحله 1: ناشناس‌سازی...")
+        anonymized_text, _ = anonymizer.anonymize_with_cerebras(input_text)
+        logger.info(f"✅ ناشناس‌سازی: {len(anonymized_text)} کاراکتر")
+        
+        # مرحله 2: LLM (فقط اگر analysis_prompt داده شده باشد)
+        has_analysis = analysis_prompt and analysis_prompt.strip()
+        
+        if has_analysis:
+            logger.info(f"🤖 مرحله 2: {llm_provider.upper()}...")
+            llm_response = anonymizer.analyze_with_llm(anonymized_text, analysis_prompt)
+            logger.info(f"✅ {llm_provider.upper()}: {len(llm_response)} کاراکتر")
+        else:
+            logger.info("⚠️ مرحله 2: بدون تحلیل LLM (پرامپت خالی)")
+            llm_response = "⚠️ هیچ دستور تحلیل داده نشده است"
+        
+        # مرحله 3: بازگردانی
+        logger.info("🔄 مرحله 3: بازگردانی...")
+        
+        # ✅ اصلاح: اگر تحلیل انجام نشده، متن ناشناس اصلی رو restore کن
+        if has_analysis:
+            # اگر LLM تحلیل کرده، خروجی LLM رو restore کن
+            restored_text = anonymizer.restore_text(llm_response)
+        else:
+            # اگر تحلیل نشده، متن ناشناس اصلی رو restore کن
+            restored_text = anonymizer.restore_text(anonymized_text)
+        
+        logger.info("✅ بازگردانی کامل")
+        
+        # مرحله 4: جدول نگاشت
+        logger.info("📋 مرحله 4: جدول نگاشت...")
+        mapping_str = anonymizer.get_mapping_table_md()
+        logger.info(f"✅ {len(anonymizer.mapping_table)} موجودیت")
+        
+        logger.info("=" * 70)
+        logger.info("✅ تمام مراحل کامل!")
+        logger.info("=" * 70)
+        
+        return restored_text, llm_response, anonymized_text, mapping_str
+        
+    except Exception as e:
+        logger.error(f"❌ خطا: {str(e)}", exc_info=True)
+        return "", f"❌ خطا: {str(e)}", "", ""
+
+def clear_all():
+    """پاک کردن همه"""
+    return "", "", "", "", "", "", True, False, False, False, False
+
+# Gradio Interface
+css_rtl = """
+.input-box { 
+    direction: rtl; 
+    text-align: right; 
+}
+.textbox textarea { 
+    direction: rtl; 
+    text-align: right; 
+    font-family: 'Tahoma', serif; 
+}
+.thick-divider {
+    border-top: 2px solid #333;
+    margin: 10px 0;
+}
+.compact-group {
+    margin: 0;
+    padding: 0;
+}
+.compact-checkbox label {
+    padding: 5px 10px !important;
+    margin: 3px 0 !important;
+    font-size: 0.95em !important;
+}
+"""
+
+with gr.Blocks(title="سیستم ناشناس‌سازی متون", theme=gr.themes.Soft(), css=css_rtl) as app:
+    
+    gr.Markdown("# 🔐 پلتفرم امن چت با مدل‌های متنوع و ناشناس‌سازی داده‌ها", elem_classes="input-box")
+    
+    # ردیف اول: تنظیمات مدل و انتخاب موجودیت‌ها
+    with gr.Row():
+        # سمت راست: تنظیمات مدل
+        with gr.Column(scale=1):
+            with gr.Group():
+                gr.Markdown("### ⚙️ تنظیمات مدل", elem_classes="input-box")
+                
+                llm_provider = gr.Dropdown(
+                    choices=["chatgpt", "grok"],
+                    value="chatgpt",
+                    label="🤖 انتخاب مدل زبانی",
+                    interactive=True
+                )
+                
+                llm_model = gr.Dropdown(
+                    choices=AVAILABLE_MODELS["chatgpt"],
+                    value="gpt-4o-mini",
+                    label="📦 انتخاب نسخه مدل",
+                    interactive=True
+                )
+        
+        # سمت چپ: انتخاب موجودیت‌ها
+        with gr.Column(scale=1):
+            with gr.Group():
+                gr.Markdown("### 🎯 انتخاب موجودیت‌ها", elem_classes="input-box")
+                
+                anonymize_all = gr.Checkbox(
+                    label="✅ همه موجودیت‌ها",
+                    value=True,
+                    elem_classes="input-box compact-checkbox"
+                )
+                
+                anonymize_person = gr.Checkbox(
+                    label="👤 اسامی اشخاص",
+                    value=False,
+                    elem_classes="input-box compact-checkbox"
+                )
+                
+                anonymize_company = gr.Checkbox(
+                    label="🏢 نام شرکت‌ها",
+                    value=False,
+                    elem_classes="input-box compact-checkbox"
+                )
+                
+                anonymize_amount = gr.Checkbox(
+                    label="💰 ارقام مالی",
+                    value=False,
+                    elem_classes="input-box compact-checkbox"
+                )
+                
+                anonymize_percent = gr.Checkbox(
+                    label="📊 درصدها",
+                    value=False,
+                    elem_classes="input-box compact-checkbox"
+                )
+    
+    # خط جداکننده پررنگ
+    gr.Markdown("---", elem_classes="thick-divider")
+    
+    # ردیف دوم: دستورات پردازش و متن ورودی
+    with gr.Row():
+        # سمت راست: دستورات پردازش
+        with gr.Column(scale=1):
+            gr.Markdown("### 📋 دستورات پردازش", elem_classes="input-box")
+            
+            analysis_prompt = gr.Textbox(
+                lines=22,
+                placeholder="مثال: این متن را خلاصه کن\nیا: نکات کلیدی را استخراج کن",
+                label="📋 دستورات LLM (اختیاری)",
+                elem_classes="textbox"
+            )
+        
+        # سمت چپ: متن ورودی
+        with gr.Column(scale=1):
+            gr.Markdown("### 📝 متن ورودی", elem_classes="input-box")
+            
+            input_text = gr.Textbox(
+                lines=22,
+                placeholder="متن مالی/خبری را وارد کنید...",
+                label="",
+                elem_classes="textbox"
+            )
+    
+    # دکمه‌های پردازش و پاک کردن
+    with gr.Row():
+        process_btn = gr.Button(
+            "▶️ پردازش",
+            variant="primary",
+            size="lg",
+            scale=2
+        )
+        
+        clear_btn = gr.Button(
+            "🗑️ پاک کردن",
+            variant="stop",
+            size="lg",
+            scale=1
+        )
+    
+    # نتایج
+    gr.Markdown("## 📊 نتایج پردازش", elem_classes="input-box")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            restored_text = gr.Textbox(
+                lines=12,
+                label="✅ متن بازگردانی شده",
+                interactive=False,
+                elem_classes="textbox"
+            )
+        
+        with gr.Column(scale=1):
+            llm_analysis = gr.Textbox(
+                lines=12,
+                label="🤖 تحلیل LLM",
+                interactive=False,
+                elem_classes="textbox"
+            )
+        
+        with gr.Column(scale=1):
+            anonymized_text = gr.Textbox(
+                lines=12,
+                label="🔒 متن ناشناس‌شده",
+                interactive=False,
+                elem_classes="textbox"
+            )
+    
+    mapping_table = gr.Markdown(
+        value="### 📋 جدول نگاشت\n\nهنوز پردازشی انجام نشده",
+        label="📋 جدول نگاشت",
+        elem_classes="input-box"
+    )
+    
+    
+    # Event Handler برای تغییر provider
+    def handle_provider_change(provider):
+        models = AVAILABLE_MODELS.get(provider, [])
+        default_model = models[0] if models else None
+        return gr.update(choices=models, value=default_model)
+    
+    llm_provider.change(
+        fn=handle_provider_change,
+        inputs=[llm_provider],
+        outputs=[llm_model]
+    )
+    
+    def handle_select_all(select_all):
+        if select_all:
+            return (
+                gr.update(value=False, interactive=False),
+                gr.update(value=False, interactive=False),
+                gr.update(value=False, interactive=False),
+                gr.update(value=False, interactive=False)
+            )
+        else:
+            return (
+                gr.update(value=False, interactive=True),
+                gr.update(value=False, interactive=True),
+                gr.update(value=False, interactive=True),
+                gr.update(value=False, interactive=True)
+            )
+    
+    anonymize_all.change(
+        fn=handle_select_all,
+        inputs=[anonymize_all],
+        outputs=[anonymize_person, anonymize_company, anonymize_amount, anonymize_percent]
+    )
+    
+    # پردازش
+    process_btn.click(
+        fn=process,
+        inputs=[
+            input_text, 
+            analysis_prompt, 
+            llm_provider, 
+            llm_model,
+            anonymize_all,
+            anonymize_person,
+            anonymize_company,
+            anonymize_amount,
+            anonymize_percent
+        ],
+        outputs=[restored_text, llm_analysis, anonymized_text, mapping_table]
+    )
+    
+    # پاک کردن
+    clear_btn.click(
+        fn=clear_all,
+        outputs=[
+            input_text, 
+            analysis_prompt,
+            restored_text, 
+            llm_analysis, 
+            anonymized_text, 
+            mapping_table,
+            anonymize_all,
+            anonymize_person,
+            anonymize_company,
+            anonymize_amount,
+            anonymize_percent
+        ]
+    )
+
+if __name__ == "__main__":
+    print("=" * 70)
+    print("🚀 سیستم ناشناس‌سازی متون در حال راه‌اندازی...")
+    print("=" * 70)
+    print("\n📋 نحوه استفاده:\n")
+    print("1. API Keyها را در Hugging Face Secrets تنظیم کنید:")
+    print("   - CEREBRAS_API_KEY (ضروری برای ناشناس‌سازی)")
+    print("   - OPENAI_API_KEY (برای ChatGPT)")
+    print("   - XAI_API_KEY (برای Grok)")
+    print("2. http://localhost:7860 را باز کنید")
+    print("3. مدل زبانی (ChatGPT/Grok) و نسخه مدل را انتخاب کنید")
+    print("4. موجودیت‌های مورد نظر برای ناشناس‌سازی را انتخاب کنید")
+    print("5. متن و دستورات پردازش را وارد کنید")
+    print("6. 'پردازش' را کلیک کنید\n")
+    print("🔐 تمام API Keyها از Hugging Face Secrets خوانده می‌شوند")
+    print("📦 مدل‌های پشتیبانی شده:")
+    print("   • ChatGPT GPT-5: gpt-5.1, gpt-5")
+    print("   • ChatGPT GPT-4: gpt-4.1, gpt-4o, gpt-4o-mini, gpt-4-turbo")
+    print("   • Grok-4: grok-4-fast-reasoning, grok-4-fast-non-reasoning, grok-4-0709")
+    print("   • Grok-3: grok-3, grok-3-mini")
+    print("   • Grok-2: grok-2-vision-1212, grok-2-1212, grok-2")
+    print("=" * 70 + "\n")
+    
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )

llm_sender_unified_fixed (3).py

@@ -0,0 +1,334 @@
+"""
+🤖 LLM Sender Unified Module
+ماژول یکپارچه برای ارسال به ChatGPT و Grok
+✨ با پشتیبانی از GPT-5 models و رفع مشکل temperature
+"""
+
+import requests
+import os
+import logging
+from typing import Optional
+import time
+from abc import ABC, abstractmethod
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class LLMSender(ABC):
+    """کلاس پایه برای ارسال به مدل‌های مختلف LLM"""
+    
+    def __init__(self, api_key: Optional[str] = None, model: str = None):
+        self.api_key = api_key
+        self.model = model
+        self.base_url = ""
+        
+    @abstractmethod
+    def get_default_model(self) -> str:
+        """مدل پیش‌فرض"""
+        pass
+    
+    @abstractmethod
+    def get_base_url(self) -> str:
+        """URL پایه API"""
+        pass
+    
+    def set_api_key(self, api_key: str):
+        """تنظیم کلید API"""
+        self.api_key = api_key
+        logger.info("✅ کلید API تنظیم شد")
+    
+    def set_model(self, model: str):
+        """تغییر مدل"""
+        self.model = model
+        logger.info(f"✅ مدل تغییر یافت به: {model}")
+    
+    def _uses_max_completion_tokens(self) -> bool:
+        """بررسی اینکه آیا مدل از max_completion_tokens استفاده می‌کند"""
+        models_with_completion_tokens = [
+            'gpt-5',        # تمام مدل‌های GPT-5
+            'gpt-5.1'       # GPT-5.1
+        ]
+        return any(self.model.startswith(prefix) for prefix in models_with_completion_tokens)
+    
+    def _requires_default_temperature(self) -> bool:
+        """بررسی اینکه آیا مدل فقط temperature=1 را قبول می‌کند"""
+        models_requiring_default_temp = [
+            'gpt-5',        # تمام مدل‌های GPT-5
+            'o1'            # تمام مدل‌های O1
+        ]
+        return any(self.model.startswith(prefix) for prefix in models_requiring_default_temp)
+    
+    def send_simple(self, text: str, lang: str = 'fa') -> str:
+        """ارسال ساده بدون system message سفارشی"""
+        system_msg = (
+            "شما یک تحلیلگر متخصص هستید. متن حاوی کدهای ناشناس است. "
+            "به درخواست‌ها با دقت و حرفه‌ای پاسخ دهید."
+            if lang == 'fa' 
+            else "You are a professional analyst. The text contains anonymous codes. "
+                 "Answer requests accurately and professionally."
+        )
+        
+        return self.send(text, system_msg=system_msg, lang=lang)
+    
+    def send(
+        self,
+        text: str,
+        system_msg: Optional[str] = None,
+        max_tokens: int = 2000,
+        temperature: float = 0.2,  # ✅ کاهش از 0.7 به 0.2 برای دقت بیشتر
+        timeout: int = 60,
+        lang: str = 'fa',
+        retry_count: int = 3
+    ) -> str:
+        """ارسال متن به LLM با کنترل کامل"""
+        try:
+            # بررسی اولیه
+            if not text or not text.strip():
+                error_msg = "متن خالی است!" if lang == 'fa' else "Text is empty!"
+                logger.error(f"❌ {error_msg}")
+                return f"❌ {error_msg}"
+            
+            if not self.api_key:
+                error_msg = "کلید API تنظیم نشده است!" if lang == 'fa' else "API Key not configured!"
+                logger.error(f"❌ {error_msg}")
+                return f"❌ {error_msg}"
+            
+            # تنظیم system message پیش‌فرض
+            if system_msg is None:
+                system_msg = (
+                    "شما یک تحلیلگر مالی حرفه‌ای هستید. متن حاوی کدهای ناشناس است. "
+                    "به سوالات با دقت پاسخ دهید."
+                    if lang == 'fa'
+                    else "You are a professional financial analyst. The text contains anonymous codes. "
+                         "Answer questions accurately."
+                )
+            
+            # تهیه headers
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            # ✨ تنظیم temperature مناسب
+            if self._requires_default_temperature():
+                actual_temperature = 1.0
+                if temperature != 1.0:
+                    logger.info(f"⚠️ مدل {self.model} فقط temperature=1 را قبول می‌کند")
+            else:
+                actual_temperature = temperature
+            
+            # ساخت request body
+            data = {
+                "model": self.model,
+                "messages": [
+                    {"role": "system", "content": system_msg},
+                    {"role": "user", "content": text}
+                ],
+                "temperature": actual_temperature
+            }
+            
+            # ✨ انتخاب پارامتر مناسب برای max tokens
+            if self._uses_max_completion_tokens():
+                data["max_completion_tokens"] = max_tokens
+            else:
+                data["max_tokens"] = max_tokens
+            
+            # ارسال با retry mechanism
+            for attempt in range(retry_count):
+                try:
+                    logger.info(f"📤 ارسال درخواست به {self.__class__.__name__} (تلاش {attempt + 1}/{retry_count})...")
+                    
+                    response = requests.post(
+                        self.base_url,
+                        headers=headers,
+                        json=data,
+                        timeout=timeout
+                    )
+                    
+                    # پردازش پاسخ موفق
+                    if response.status_code == 200:
+                        result = response.json()
+                        llm_response = result['choices'][0]['message']['content']
+                        logger.info("✅ پاسخ دریافت شد")
+                        return llm_response
+                    
+                    # پردازش خطاهای مختلف
+                    elif response.status_code == 429:  # Rate limiting
+                        wait_time = 5 * (attempt + 1)
+                        logger.warning(f"⚠️  Rate limit | صبر: {wait_time} ثانیه")
+                        if attempt < retry_count - 1:
+                            time.sleep(wait_time)
+                            continue
+                        else:
+                            return (
+                                "❌ سهمیه API تمام شده است. لطفاً بعداً تلاش کنید."
+                                if lang == 'fa'
+                                else "❌ API quota exceeded. Please try later."
+                            )
+                    
+                    elif response.status_code == 401:
+                        return (
+                            "❌ کلید API نامعتبر است!"
+                            if lang == 'fa'
+                            else "❌ Invalid API key!"
+                        )
+                    
+                    elif response.status_code in [502, 503, 504]:  # Server errors
+                        wait_time = 2 * (attempt + 1)
+                        logger.warning(f"⚠️  Server error {response.status_code} | صبر: {wait_time} ثانیه")
+                        if attempt < retry_count - 1:
+                            time.sleep(wait_time)
+                            continue
+                        else:
+                            return (
+                                f"❌ خطای سرور: {response.status_code}"
+                                if lang == 'fa'
+                                else f"❌ Server error: {response.status_code}"
+                            )
+                    
+                    else:
+                        # خطای دیگر
+                        try:
+                            error_data = response.json() if response.content else {}
+                            if isinstance(error_data, dict):
+                                error_msg = error_data.get('error', {}).get('message', response.text)
+                            else:
+                                error_msg = str(error_data)
+                        except:
+                            error_msg = response.text[:200]
+                        
+                        logger.error(f"❌ API Error: {error_msg}")
+                        return f"❌ API Error: {error_msg}"
+                
+                except requests.exceptions.Timeout:
+                    logger.warning("⚠️  Timeout | صبر: 3 ثانیه و تلاش مجدد")
+                    if attempt < retry_count - 1:
+                        time.sleep(3)
+                        continue
+                    else:
+                        return (
+                            "❌ خطای اتصال: timeout"
+                            if lang == 'fa'
+                            else "❌ Connection error: timeout"
+                        )
+                
+                except requests.exceptions.ConnectionError as e:
+                    logger.warning("⚠️  Connection error | صبر: 2 ثانیه و تلاش مجدد")
+                    if attempt < retry_count - 1:
+                        time.sleep(2)
+                        continue
+                    else:
+                        return (
+                            f"❌ خطای اتصال: {str(e)}"
+                            if lang == 'fa'
+                            else f"❌ Connection error: {str(e)}"
+                        )
+        
+        except Exception as e:
+            logger.error(f"❌ خطای غیرمنتظره: {str(e)}")
+            return (
+                f"❌ خطا در ارتباط با LLM: {str(e)}"
+                if lang == 'fa'
+                else f"❌ Error connecting to LLM: {str(e)}"
+            )
+
+
+class ChatGPTSender(LLMSender):
+    """کلاس برای ارسال به ChatGPT"""
+    
+    def __init__(self, api_key: Optional[str] = None, model: str = "gpt-4o-mini"):
+        raw_key = api_key or os.getenv("OPENAI_API_KEY", "")
+        cleaned_key = raw_key.strip() if raw_key else ""
+        
+        super().__init__(cleaned_key, model)
+        self.base_url = self.get_base_url()
+        
+        if not self.api_key:
+            logger.warning("⚠️  کلید OpenAI API تنظیم نشده است!")
+    
+    def get_default_model(self) -> str:
+        return "gpt-4o-mini"
+    
+    def get_base_url(self) -> str:
+        return "https://api.openai.com/v1/chat/completions"
+
+
+class GrokSender(LLMSender):
+    """کلاس برای ارسال به Grok (xAI)"""
+    
+    def __init__(self, api_key: Optional[str] = None, model: str = "grok-beta"):
+        raw_key = api_key or os.getenv("XAI_API_KEY", "")
+        cleaned_key = raw_key.strip() if raw_key else ""
+        
+        super().__init__(cleaned_key, model)
+        self.base_url = self.get_base_url()
+        
+        if not self.api_key:
+            logger.warning("⚠️  کلید xAI API تنظیم نشده است!")
+    
+    def get_default_model(self) -> str:
+        return "grok-beta"
+    
+    def get_base_url(self) -> str:
+        return "https://api.x.ai/v1/chat/completions"
+
+
+def create_llm_sender(
+    provider: str = "chatgpt",
+    api_key: Optional[str] = None,
+    model: Optional[str] = None
+) -> LLMSender:
+    """ایجاد LLM sender بر اساس provider"""
+    provider = provider.lower()
+    
+    if provider == "chatgpt":
+        if model is None:
+            model = "gpt-4o-mini"
+        return ChatGPTSender(api_key=api_key, model=model)
+    
+    elif provider == "grok":
+        if model is None:
+            model = "grok-beta"
+        return GrokSender(api_key=api_key, model=model)
+    
+    else:
+        raise ValueError(f"Provider نامعتبر: {provider}")
+
+
+# ✅ مدل‌های موجود (اصلاح شده)
+AVAILABLE_MODELS = {
+    "chatgpt": [
+        "gpt-5.1",          # ✅ بهترین GPT-5
+        "gpt-5",            # ✅ GPT-5 پایه
+        "gpt-4.1",
+        "gpt-4o-mini",
+        "gpt-4o",
+        "gpt-4-turbo",
+        "gpt-3.5-turbo"
+    ],
+    "grok": [
+        "grok-3-mini",
+        "grok-3",
+        "grok-2-1212"
+    ]
+}
+
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("🤖 LLM Sender - نسخه اصلاح شده")
+    print("✨ رفع مشکل temperature برای GPT-5")
+    print("=" * 60)
+    
+    # تست
+    print("\n🧪 تست مدل‌ها:")
+    test_models = ['gpt-5', 'gpt-5.1', 'gpt-4o']
+    for model in test_models:
+        sender = create_llm_sender("chatgpt", model=model)
+        uses_completion = sender._uses_max_completion_tokens()
+        requires_default_temp = sender._requires_default_temperature()
+        
+        print(f"\n  مدل: {model}")
+        print(f"    • max_tokens: {'max_completion_tokens' if uses_completion else 'max_tokens'}")
+        print(f"    • temperature: {'1.0 (default only)' if requires_default_temp else '0.7 (custom)'}")