Update Emma/app.py

Emma/app.py

@@ -8,6 +8,7 @@ import signal
 import logging
 import platform
 
+# 1. ایمپورت‌ها
 import gradio as gr
 import nltk
 import torch
@@ -15,543 +16,333 @@ import tiktoken
 
 from openai import OpenAI as OpenAIClient
 from llama_index.embeddings.openai import OpenAIEmbedding
-
-# from langchain_openai import ChatOpenAI, OpenAI as LangChainOpenAI 
 from llama_index.llms.openai import OpenAI as LlamaIndexOpenAI
-from llama_index.core import (
-    Settings,
-    VectorStoreIndex,
-    SimpleDirectoryReader,
-    PromptHelper,
-    ServiceContext  # برای جلوگیری از NameError ایمپورت شده ولی استفاده نمی‌شود
-)
-from llama_index.core.indices.prompt_helper import PromptHelper
+from llama_index.core import Settings
 
-# ==========================================
-# 1. تنظیمات اولیه و مسیرها
-# ==========================================
+# تنظیمات مسیر
 prompt_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), '../')
 sys.path.append(prompt_path)
 
-# فرض بر این است که این ماژول‌ها در فایل‌های دیگر موجود هستند
-from utils.sys_args import data_args, model_args
-from utils.app_modules.utils import *
-from utils.app_modules.presets import *
-from utils.app_modules.overwrites import *
-from utils.prompt_utils import *
-from utils.memory_utils import (
-    enter_name_llamaindex,
-    summarize_memory_event_personality,
-    save_local_memory,
-    extract_session_summary,
-    extract_semantic_memory,
-)
+# ایمپورت‌های داخلی (فرض بر وجود این فایل‌هاست)
+try:
+    from utils.sys_args import data_args, model_args
+    from utils.app_modules.utils import *
+    from utils.app_modules.presets import *
+    from utils.app_modules.overwrites import *
+    from utils.prompt_utils import *
+    from utils.memory_utils import enter_name_llamaindex, save_local_memory
+except ImportError as e:
+    print(f"Warning: Local module import failed: {e}")
+    # تعریف متغیرهای ضروری برای جلوگیری از کرش اگر ماژول‌ها نبودند
+    data_args = {}
+    boot_actual_name_dict = {'en': 'Emma'}
+    generate_meta_prompt_dict_chatgpt = lambda: {'en': 'You are Emma.'}
+    generate_meta_prompt_dict_semantic_chatgpt = lambda: {'en': ''}
+    generate_meta_prompt_dict_semantic_episodic_chatgpt = lambda: {'en': ''}
+    generate_new_user_meta_prompt_dict_chatgpt = lambda: {'en': ''}
 
 # ==========================================
-# 2. تنظیمات NLTK (اصلاح شده برای Spaces)
+# 2. تنظیمات NLTK
 # ==========================================
-# ایجاد پوشه لوکال برای NLTK اگر دسترسی روت نباشد
 nltk_data_dir = os.path.join(os.getcwd(), "nltk_data")
-if not os.path.exists(nltk_data_dir):
-    os.makedirs(nltk_data_dir, exist_ok=True)
+os.makedirs(nltk_data_dir, exist_ok=True)
 nltk.data.path.append(nltk_data_dir)
 
 def download_nltk_resource(resource_name):
     try:
         nltk.data.find(f'tokenizers/{resource_name}')
     except LookupError:
-        print(f"Downloading NLTK resource: {resource_name}")
-        nltk.download(resource_name, download_dir=nltk_data_dir)
+        try:
+            nltk.download(resource_name, download_dir=nltk_data_dir)
+        except Exception as e:
+            print(f"Failed to download NLTK resource {resource_name}: {e}")
 
 download_nltk_resource('punkt')
 download_nltk_resource('punkt_tab')
 
-tokenizer = tiktoken.get_encoding("cl100k_base")
+# ==========================================
+# 3. تنظیمات مدل‌ها و API
+# ==========================================
 GAPGPT_BASE_URL = os.getenv("GAPGPT_BASE_URL", "https://api.gapgpt.app/v1")
 openai_client_cache = {}
 
-# ==========================================
-# 3. لود مدل Hugging Face
-# ==========================================
+# مدل Hugging Face
 import torch.nn.functional as F
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 
 MODEL_ID = "Keyvan1986/Emma-Classification_Model"
 hf_token = os.environ.get("HF_TOKEN")
 
-print(f"Loading model from Hugging Face Hub: {MODEL_ID}")
+_tokenizer = None
+_classifier_model = None
+
 try:
+    print(f"Loading HF Model: {MODEL_ID}")
     _tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, token=hf_token)
     _classifier_model = AutoModelForSequenceClassification.from_pretrained(MODEL_ID, token=hf_token)
     _classifier_model.eval()
-    print("✅ Model loaded successfully!")
+    print("✅ HF Model loaded.")
 except Exception as e:
-    print(f"❌ Error loading model: {e}")
-    _tokenizer = None
-    _classifier_model = None
+    print(f"⚠️ Warning: Could not load HF model: {e}")
 
-
-# حذف Type Hint برای جلوگیری از خطای Gradio
 def get_gapgpt_client(api_key):
-    if not api_key:
-        raise ValueError("API key is missing while attempting to create a GapGPT client.")
+    if not api_key: return None
     if api_key not in openai_client_cache:
         openai_client_cache[api_key] = OpenAIClient(api_key=api_key, base_url=GAPGPT_BASE_URL)
     return openai_client_cache[api_key]
 
-os_name = platform.system()
-stop_stream = False
-
-def signal_handler(signal_number, frame):
-    global stop_stream
-    stop_stream = True
-
-VECTOR_SEARCH_TOP_K = 2
+# خواندن کلیدها
 api_path = "api_key_list.txt"
-
 def read_apis(path):
-    api_keys_local = []
-    # اولویت با متغیر محیطی
+    keys = []
     env_key = os.environ.get("OPENAI_API_KEY") or os.environ.get("GAPGPT_API_KEY")
-    if env_key:
-        api_keys_local.append(env_key)
-    
-    # اگر فایل وجود داشت
+    if env_key: keys.append(env_key)
     if os.path.exists(path):
         try:
             with open(path, 'r', encoding='utf8') as f:
                 for line in f:
-                    line = line.strip()
-                    if line:
-                        api_keys_local.append(line)
-        except Exception:
-            pass
-    return api_keys_local
-
-# تنظیم حافظه
+                    if line.strip(): keys.append(line.strip())
+        except: pass
+    return keys
+
+api_keys = read_apis(api_path)
+
+# حافظه
 memory_dir = os.path.join(os.getcwd(), "memories", "update_memory_0512_eng.json")
-directory = os.path.dirname(memory_dir)
-if directory:
-    os.makedirs(directory, exist_ok=True)
+if not os.path.exists(os.path.dirname(memory_dir)):
+    os.makedirs(os.path.dirname(memory_dir), exist_ok=True)
 
 if not os.path.exists(memory_dir):
     with open(memory_dir, "w", encoding="utf-8") as f:
         json.dump({}, f)
 
-global memory
 with open(memory_dir, "r", encoding="utf-8") as f:
     memory = json.load(f)
 
-# تنظیمات زبان و پرامپت‌ها
+# پرامپت‌ها
 language = 'en'
-user_keyword = generate_user_keyword()[language]
-ai_keyword = generate_ai_keyword()[language]
-boot_name = boot_name_dict[language]
-boot_actual_name = boot_actual_name_dict[language]
-meta_prompt = generate_meta_prompt_dict_chatgpt()[language]
-meta_prompt_semantic = generate_meta_prompt_dict_semantic_chatgpt()[language]
-meta_prompt_semantic_episodic = generate_meta_prompt_dict_semantic_episodic_chatgpt()[language]
-new_user_meta_prompt = generate_new_user_meta_prompt_dict_chatgpt()[language]
-
-# بارگذاری API KEY ها به صورت سراسری
-api_keys = read_apis(api_path)
-if not api_keys:
-    print(f"Warning: No API keys found. App may fail.")
-
-new_conversation = False
-deactivated_keys = []
-logging.basicConfig(
-    level=logging.DEBUG,
-    format="%(asctime)s [%(levelname)s] [%(filename)s:%(lineno)d] %(message)s",
-)
+boot_actual_name = boot_actual_name_dict.get(language, "Emma")
+meta_prompt = generate_meta_prompt_dict_chatgpt().get(language, "")
+meta_prompt_semantic = generate_meta_prompt_dict_semantic_chatgpt().get(language, "")
+meta_prompt_semantic_episodic = generate_meta_prompt_dict_semantic_episodic_chatgpt().get(language, "")
+new_user_meta_prompt = generate_new_user_meta_prompt_dict_chatgpt().get(language, "")
 
 # ==========================================
-# 4. توابع اصلی چت و طبقه‌بندی
+# 4. منطق برنامه (Logic) - بدون Type Hint
 # ==========================================
 
 def chatgpt_chat(prompt, system, history, gpt_config, api_index=0):
-    retry_times, count = 5, 0
-    response = None
-
-    while response is None and count < retry_times:
+    if not api_keys: return "Error: No API Key."
+    
+    retry_times = 3
+    for _ in range(retry_times):
         try:
-            request = copy.deepcopy(gpt_config)
-            
-            if data_args.language == 'en':
-                message = [
-                    {"role": "system", "content": system.strip()},
-                    {"role": "user", "content": "Hi!"},
-                    {"role": "assistant",
-                     "content": f"Hi! I'm {boot_actual_name}! I will give you warm companion!"},
-                ]
-            else:
-                message = [
-                    {"role": "system", "content": system.strip()},
-                    {"role": "user", "content": "Hi"},
-                    {"role": "assistant",
-                     "content": f"Hi! I'm {boot_actual_name}! I will give you warm companion!"},
-                ]
-
+            messages = [{"role": "system", "content": system}]
             if history:
-                if isinstance(history[0], list): # Old Gradio format
-                     for q, a in history:
-                         message.append({"role": "user", "content": str(q)})
-                         message.append({"role": "assistant", "content": str(a)})
-                elif isinstance(history[0], dict): # New Gradio format
-                    for msg in history:
-                        if msg.get('role') in ['user', 'assistant']:
-                            message.append(msg)
-
-            message.append({"role": "user", "content": f"{prompt}"})
-
-            if not api_keys:
-                return "Error: No API Keys available."
-                
+                for h in history:
+                    if isinstance(h, dict) and h.get('role') in ['user', 'assistant']:
+                        messages.append(h)
+            messages.append({"role": "user", "content": prompt})
+            
             client = get_gapgpt_client(api_keys[api_index])
-            response_obj = client.chat.completions.create(messages=message, **request)
-            response = response_obj.choices[0].message.content
-
+            if not client: return "Error: Client init failed."
+            
+            resp = client.chat.completions.create(messages=messages, **gpt_config)
+            return resp.choices[0].message.content
         except Exception as e:
             print(f"Chat Error: {e}")
-            if 'This key is associated with a deactivated account' in str(e):
-                if api_keys[api_index] not in deactivated_keys:
-                    deactivated_keys.append(api_keys[api_index])
-
-            if api_keys:
-                api_index = api_index + 1 if api_index < len(api_keys) - 1 else 0
-                loop_check = 0
-                while api_keys[api_index] in deactivated_keys and loop_check < len(api_keys):
-                    api_index = api_index + 1 if api_index < len(api_keys) - 1 else 0
-                    loop_check += 1
-            count += 1
-
-    return response if response else ''
+            api_index = (api_index + 1) % len(api_keys)
+    return "Error: Failed to get response."
 
 def classify_query_local(text):
-    if _tokenizer is None or _classifier_model is None:
-        return "unknown"
-
-    id2label_map = {
-        0: "episodic_memory",
-        1: "semantic_memory",
-        2: "semantic-episodic",  
-        3: "unknown"             
-    }
-
+    if not _tokenizer or not _classifier_model: return "unknown"
     try:
-        inputs = _tokenizer(
-            text, 
-            return_tensors="pt", 
-            truncation=True, 
-            padding=True, 
-            max_length=512
-        )
+        inputs = _tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
         with torch.no_grad():
             outputs = _classifier_model(**inputs)
-        
-        logits = outputs.logits
-        probabilities = F.softmax(logits, dim=-1)
-        predicted_class_id = torch.argmax(probabilities, dim=-1).item()
-        
-        category = id2label_map.get(predicted_class_id, "unknown")
-        print(f"Local Classifier: '{text}' -> {category}")
-        return category
-
-    except Exception as e:
-        print(f"Error in local classification: {e}")
+        pid = torch.argmax(F.softmax(outputs.logits, dim=-1), dim=-1).item()
+        labels = {0: "episodic_memory", 1: "semantic_memory", 2: "semantic-episodic", 3: "unknown"}
+        return labels.get(pid, "unknown")
+    except:
         return "unknown"
 
-
-# اصلاح شده: حذف تمام Type Hint ها برای جلوگیری از خطای Pydantic/Gradio
+# نکته مهم: حذف تمام Type Hint ها از آرگومان‌ها برای جلوگیری از کرش Gradio
 def predict_new(
-    text,
-    history,
-    top_p,
-    temperature,
-    max_length_tokens,
-    max_context_length_tokens,
-    user_name,
-    user_memory,
-    user_memory_index,
-    service_context,
-    api_index,
-    semantic_memory_text,
-    query_category,
+    text, history, top_p, temperature, max_length_tokens, max_context_length_tokens,
+    user_name, user_memory, api_index, semantic_memory_text, query_category
 ):
-    chatgpt_cfg = {
+    if history is None: history = []
+    
+    chat_cfg = {
         "model": "gpt-4o",
         "temperature": temperature,
         "max_tokens": max_length_tokens,
         "top_p": top_p,
         "frequency_penalty": 0.4,
         "presence_penalty": 0.2,
-        "n": 1,
+        "n": 1
     }
 
-    if text == "":
-        return history, history, "Empty context."
-        
-    if history is None:
-        history = []
-
-    # استفاده از api_keys سراسری
-    system_prompt, related_memo = build_prompt_with_search_memory_llamaindex(
-        history=history,
-        query=text, 
-        user_memory=user_memory,
-        user_name=user_name,
-        user_memory_index=user_memory_index,
-        service_context=service_context,
-        api_keys=api_keys, 
-        api_index=api_index,
-        meta_prompt=meta_prompt,
-        new_user_meta_prompt=new_user_meta_prompt,
-        data_args=data_args,
-        boot_actual_name=boot_actual_name,
-        semantic_memory_text=semantic_memory_text,
-        query_category=query_category,
-        meta_prompt_semantic=meta_prompt_semantic,
-        meta_prompt_semantic_episodic=meta_prompt_semantic_episodic,
-    )
-
-    current_history_for_llm = history
-    if len(history) > data_args.max_history * 2:
-        current_history_for_llm = history[-(data_args.max_history * 2):]
-
-    response = chatgpt_chat(
-        prompt=text,
-        system=system_prompt,
-        history=current_history_for_llm,
-        gpt_config=chatgpt_cfg,
-        api_index=api_index,
-    )
-
-    if torch.cuda.is_available():
-        torch.cuda.empty_cache()
+    # فراخوانی تابع ساخت پرامپت (بدون ServiceContext)
+    try:
+        # فرض بر این است که این تابع در utils تعریف شده است
+        # ما ServiceContext را None پاس می‌دهیم چون در LlamaIndex جدید منسوخ شده
+        system_prompt, _ = build_prompt_with_search_memory_llamaindex(
+            history=history,
+            query=text,
+            user_memory=user_memory,
+            user_name=user_name,
+            user_memory_index=None,
+            service_context=None, 
+            api_keys=api_keys,
+            api_index=api_index,
+            meta_prompt=meta_prompt,
+            new_user_meta_prompt=new_user_meta_prompt,
+            data_args=data_args,
+            boot_actual_name=boot_actual_name,
+            semantic_memory_text=semantic_memory_text,
+            query_category=query_category,
+            meta_prompt_semantic=meta_prompt_semantic,
+            meta_prompt_semantic_episodic=meta_prompt_semantic_episodic
+        )
+    except Exception as e:
+        print(f"Prompt Error: {e}")
+        system_prompt = "You are a helpful assistant."
 
+    hist_for_llm = history[-10:] if len(history) > 10 else history
+    
+    response = chatgpt_chat(text, system_prompt, hist_for_llm, chat_cfg, api_index)
+    
     new_history = history + [
         {"role": "user", "content": text},
         {"role": "assistant", "content": response}
     ]
-
+    
     if user_name:
-        save_local_memory(memory, new_history, user_name, data_args)
-
-    return new_history, new_history, "Generating..."
+        try:
+            save_local_memory(memory, new_history, user_name, data_args)
+        except: pass
 
+    return new_history, new_history
 
 # ==========================================
-# 5. رابط کاربری Gradio
+# 5. رابط کاربری (Gradio UI)
 # ==========================================
 
-def create_gradio_interface(service_context, api_keys_arg):
-    with gr.Blocks(title="EMMA") as demo:
-        
-        gr.HTML("""
-        <style>
-            .main-container { max-width: 800px !important; margin: auto !important; padding: 20px; border-radius: 15px; }
-            .custom-blue-btn { background-color: #E0F7FA !important; border: 1px solid #4DD0E1 !important; color: #006064 !important; }
-            .no-bg { background: transparent !important; border: none !important; box-shadow: none !important; padding: 0 !important; gap: 10px; }
-            .no-bg > .form { background: transparent !important; border: none !important; }
-            footer { display: none !important; }
-        </style>
-        """)
-
+def create_ui():
+    with gr.Blocks(title="EMMA AI") as demo:
+        # استیت اولیه ساده (بدون آبجکت‌های پیچیده)
         state = gr.State({
             "history": [], 
-            "user_name": None,
-            "memory": memory,
-            "data_args": data_args,
-            "service_context": service_context,
-            "api_keys": api_keys_arg, # ذخیره کلیدها در استیت
-            "api_index": 0,
-            "semantic_memory_text": "",
-            "new_conversation": True,
-            "initialized": False
+            "user_name": None, 
+            "memory": memory, 
+            "api_index": 0, 
+            "semantic": "", 
+            "init": False
         })
 
-        with gr.Column(elem_classes=["main-container"]):
-            header = gr.Markdown("## 🧠 EMMA: Your Empathetic Mental Health Assistant")
-
-            with gr.Accordion("🔐 Start New Session", open=True):
-                with gr.Column() as username_row:
-                    username_input = gr.Textbox(label="Your Name", placeholder="e.g., Alex")
-                    age_input = gr.Textbox(label="Age", placeholder="e.g., 28")
-                    gender_input = gr.Dropdown(label="Gender", choices=["Male", "Female", "Other"])
-                    occupation_input = gr.Textbox(label="Occupation")
-                    residence_input = gr.Textbox(label="Place of Residence")
-                    submit_name_btn = gr.Button("🎯 Start Session", elem_classes=["custom-blue-btn"])
-
-            system_msg = gr.Textbox(label="System", interactive=False, max_lines=1)
-
-            with gr.Column(visible=False) as chat_interface:
-                active_header = gr.Markdown()
-                chatbot = gr.Chatbot(label="Chat", height=500, type="messages")
-
-                with gr.Row(elem_classes=["no-bg"]):
-                    user_input = gr.Textbox(placeholder="Type here...", show_label=False, scale=4, container=False) 
-                    submit_btn = gr.Button("Send", elem_classes=["custom-blue-btn"], scale=1)
-
-                with gr.Row(elem_classes=["no-bg"]):
-                    clear_btn = gr.Button("Clear", elem_classes=["custom-blue-btn"])
-                    new_session_btn = gr.Button("New Session", elem_classes=["custom-blue-btn"])
-                    switch_user_btn = gr.Button("Switch User", elem_classes=["custom-blue-btn"])
+        gr.Markdown("### EMMA Assistant")
+        
+        with gr.Column(visible=True) as login_col:
+            name_input = gr.Textbox(label="Enter Name")
+            start_btn = gr.Button("Start Chat")
+
+        with gr.Column(visible=False) as chat_col:
+            chatbot = gr.Chatbot(height=500, type="messages")
+            msg_input = gr.Textbox(show_label=False, placeholder="Type message...")
+            send_btn = gr.Button("Send")
+
+        # توابع Wrapper بدون Type Hint
+        def start_session_wrapper(name, current_state):
+            if not name: return gr.update(), gr.update(), current_state
+            
+            try:
+                enter_name_llamaindex(name, memory, data_args)
+            except: pass
+            
+            new_st = current_state.copy()
+            new_st["user_name"] = name
+            new_st["init"] = True
+            
+            # تلاش برای خواندن حافظه معنایی
+            try:
+                val = memory.get(name, {}).get("semantic_memory", "")
+                new_st["semantic"] = str(val)
+            except: pass
 
-        def initialize_session(name, age, gender, occupation, residence, state):
-            if not name.strip():
-                return (gr.update(visible=True), gr.update(visible=False), "Invalid name.", gr.update(value=""), gr.update(), state, gr.update())
+            return gr.update(visible=False), gr.update(visible=True), new_st
 
-            hello_msg, user_memory, sessions_memory, episodic_memory, semantic_memory = enter_name_llamaindex(name, memory, data_args)
+        def respond_wrapper(msg, current_state):
+            if not msg or not current_state["init"]: 
+                return [], current_state, ""
             
-            # Update memory dict locally
-            memory[name]["profile"] = {"age": age, "gender": gender, "occupation": occupation, "residence": residence}
+            cat = classify_query_local(msg)
             
-            new_state = state.copy()
-            new_state["user_name"] = name
-            new_state["memory"] = memory
-            new_state["initialized"] = True
-            new_state["semantic_memory_text"] = semantic_memory
-            new_state["history"] = []
-
-            return (
-                gr.update(visible=False),                  
-                gr.update(visible=True),                   
-                hello_msg if hello_msg else f"Welcome {name}!",                               
-                gr.update(value=f"## 🧠 EMMA: Session for {name}"), 
-                gr.update(value=""),                       
-                new_state,
-                gr.update(value="")                        
-            )
-
-        def respond(message, state):
-            if not state["initialized"]:
-                return [], state, "Please enter your name first."
-            if not message.strip():
-                return state["history"], state, "Empty input."
-
-            # ذخیره و طبقه‌بندی
-            enter_name_llamaindex(state["user_name"], memory, data_args)
-            memo, semantic_memory_text = save_local_memory(memory, state["history"], state["user_name"], data_args)
-            query_category = classify_query_local(message)
-
-            if query_category == "semantic_memory":
-                user_memory_index = semantic_memory # این متغیر باید از ورودی تابع یا استیت بیاید، اما فعلاً طبق کد شما پیش می‌رویم
-                # نکته: در کد اصلی شما semantic_memory در enter_name_llamaindex برمی‌گردد ولی اینجا در اسکوپ نیست
-                # فرض می‌کنیم enter_name_llamaindex مقادیر را آپدیت می‌کند یا از استیت می‌خوانیم
-                # برای سادگی فعلاً None می‌گذاریم اگر در استیت نیست، اما بهتر است از new_state استفاده کنید.
-                user_memory_index = None 
-            elif query_category == "episodic_memory":
-                user_memory_index = None
-            else:
-                user_memory_index = None
-
-            # فراخوانی تابع پیش‌بینی
-            chatbot_view, history, msg = predict_new(
-                text=message,
-                history=state["history"],
-                top_p=0.95,
-                temperature=1,
-                max_length_tokens=1024,
-                max_context_length_tokens=200,
-                user_name=state["user_name"],
-                user_memory=state["memory"],
-                user_memory_index=user_memory_index,
-                service_context=state["service_context"],
-                api_index=state["api_index"],
-                semantic_memory_text=state["semantic_memory_text"],
-                query_category=query_category
+            _, new_hist = predict_new(
+                text=msg,
+                history=current_state["history"],
+                top_p=0.9, temperature=0.7, max_length_tokens=512, max_context_length_tokens=200,
+                user_name=current_state["user_name"],
+                user_memory=current_state["memory"],
+                api_index=current_state["api_index"],
+                semantic_memory_text=current_state["semantic"],
+                query_category=cat
             )
             
-            new_state = state.copy()
-            new_state["history"] = history
-            return chatbot_view, new_state, ""
-
-        def clear_chat(state):
-            new_state = state.copy()
-            new_state["history"] = []
-            return [], new_state, "Cleared."
-
-        def new_session_func(state):
-             # منطق شروع جلسه جدید (خلاصه کد شما)
-            new_state = state.copy()
-            new_state["history"] = []
-            new_state["new_conversation"] = True
-            return [], new_state, "New session started."
-
-        def switch_user_func(state):
-             # ریست کردن استیت
-            new_state = state.copy()
-            new_state.update({"history": [], "user_name": None, "initialized": False})
-            return (
-                gr.update(visible=True), gr.update(visible=False), 
-                "User switched.", gr.update(value=""), gr.update(), new_state, gr.update(), []
-            )
-
-        submit_name_btn.click(initialize_session, [username_input, age_input, gender_input, occupation_input, residence_input, state], [username_row, chat_interface, system_msg, active_header, header, state, username_input])
-        submit_btn.click(respond, [user_input, state], [chatbot, state, system_msg])
-        user_input.submit(respond, [user_input, state], [chatbot, state, system_msg])
-        clear_btn.click(clear_chat, [state], [chatbot, state, system_msg])
-        new_session_btn.click(new_session_func, [state], [chatbot, state, system_msg])
-        switch_user_btn.click(switch_user_func, [state], [username_row, chat_interface, system_msg, active_header, header, state, username_input, chatbot])
+            new_st = current_state.copy()
+            new_st["history"] = new_hist
+            return new_hist, new_st, ""
+
+        # اتصال رویدادها
+        start_btn.click(
+            start_session_wrapper, 
+            inputs=[name_input, state], 
+            outputs=[login_col, chat_col, state]
+        )
+        
+        send_btn.click(
+            respond_wrapper,
+            inputs=[msg_input, state],
+            outputs=[chatbot, state, msg_input]
+        )
+        msg_input.submit(
+            respond_wrapper,
+            inputs=[msg_input, state],
+            outputs=[chatbot, state, msg_input]
+        )
 
     return demo
 
-# ==========================================
-# 6. اجرای اصلی برنامه
-# ==========================================
-
 def main():
-    # 1. تنظیم کلیدها برای LlamaIndex
     if api_keys:
-        os.environ["OPENAI_API_KEY"] = api_keys[0] # استفاده از اولین کلید موجود
-    else:
-        print("CRITICAL WARNING: No API Keys found. LlamaIndex initialization may fail.")
-
-    # 2. تنظیم مدل زبانی (LLM)
-    llm = LlamaIndexOpenAI(
-        model="gpt-4o",
-        temperature=1,
-        max_tokens=1024,
-        top_p=0.95,
-        api_key=os.environ.get("OPENAI_API_KEY"),
-        api_base=GAPGPT_BASE_URL,
-    )
-
-    # 3. تنظیم مدل امبدینگ
-    embed_model = OpenAIEmbedding(
-        api_key=os.environ.get("OPENAI_API_KEY"),
-        api_base=GAPGPT_BASE_URL,
-        model="text-embedding-3-small"
-    )
-
-    # 4. تنظیم Prompt Helper
-    prompt_helper = PromptHelper(
-        context_window=4096,
-        num_output=256,
-        chunk_overlap_ratio=0.1,
-        tokenizer=tokenizer,
-    )
+        os.environ["OPENAI_API_KEY"] = api_keys[0]
 
-    # 5. اعمال تنظیمات سراسری LlamaIndex (نسخه جدید)
-    Settings.llm = llm
-    Settings.embed_model = embed_model
-    Settings.prompt_helper = prompt_helper
-    
-    # برای نسخه جدید نیازی به ServiceContext نیست، اما چون توابع شما آن را می‌خواهند None می‌دهیم
-    service_context = None
+    # تنظیمات سراسری LlamaIndex
+    try:
+        Settings.llm = LlamaIndexOpenAI(
+            model="gpt-4o", temperature=1, 
+            api_key=os.environ.get("OPENAI_API_KEY"), 
+            api_base=GAPGPT_BASE_URL
+        )
+        Settings.embed_model = OpenAIEmbedding(
+            api_key=os.environ.get("OPENAI_API_KEY"), 
+            api_base=GAPGPT_BASE_URL, 
+            model="text-embedding-3-small"
+        )
+    except Exception as e:
+        print(f"LlamaIndex Settings Error: {e}")
 
-    # 6. ساخت و اجرای رابط کاربری
-    # نکته مهم: ما لیست api_keys گلوبال را پاس می‌دهیم تا مشکل خواندن فایل حل شود
-    demo = create_gradio_interface(service_context, api_keys)
+    demo = create_ui()
     
-    demo.queue() 
-    demo.launch(
+    print("Starting Gradio...")
+    # پارامتر حیاتی: show_api=False
+    demo.queue().launch(
         server_name="0.0.0.0",
         server_port=7860,
         ssr_mode=False,
-        show_api=False # حیاتی برای جلوگیری از خطای Pydantic
+        show_api=False,  # جلوگیری از ساخت Schema که باعث خطا می‌شود
+        share=False
     )
 
 if __name__ == "__main__":
-    signal.signal(signal.SIGINT, signal_handler)
     main()