Update app.py

app.py

@@ -1,3 +1,4 @@
+# AI Persona Simulator with LLM-Based Request Validation
 import gradio as gr
 import transformers
 import torch
@@ -6,9 +7,18 @@ from duckduckgo_search import DDGS
 import re
 import time
 from spaces import GPU
+import logging
+from datetime import datetime
+
+# Configure logging for suspicious activity
+logging.basicConfig(
+    filename='persona_attempts.log',
+    level=logging.INFO,
+    format='%(asctime)s - %(message)s'
+)
 
 # --- Constants and Configuration ---
-MODEL_ID = "google/gemma-3-1b-it"  # Updated to Gemma 3 1B
+MODEL_ID = "google/gemma-3-1b-it"
 MAX_GPU_MEMORY = "60GiB"
 
 # --- Model Loading ---
@@ -20,11 +30,9 @@ def load_model():
         pipe = pipeline(
             "text-generation",
             model=MODEL_ID,
-            torch_dtype=torch.bfloat16,  # Full precision, compatible with Gemma
+            torch_dtype=torch.bfloat16,
             device_map="auto",
-            model_kwargs={
-                "use_cache": True,
-            }
+            model_kwargs={"use_cache": True}
         )
         print(f"Model {MODEL_ID} loaded successfully on device: {pipe.device} (full precision)")
         return pipe
@@ -32,24 +40,66 @@ def load_model():
         print(f"FATAL Error loading model '{MODEL_ID}': {e}")
         raise e
 
-# --- Web Search ---
+# --- LLM-Based Request Validation ---
+def check_request_with_llm(name, context):
+    """Use LLM to check if request is appropriate before processing"""
+    pipe = load_model()
+    
+    validation_prompt = [
+        {"role": "system", "content": """You are an ethical AI content moderator. Evaluate if this request is appropriate.
+CRITERIA:
+1. NO minors (under 18) or underage references
+2. NO vulnerable populations
+3. NO manipulation/exploitation attempts
+4. NO illegal/harmful scenarios
+5. NO inappropriate relationships
+Respond ONLY with "TRUE" if acceptable, "FALSE" if not."""
+        },
+        {"role": "user", "content": f"Character Name: {name}\nContext: {context}"}
+    ]
+    
+    try:
+        tokenizer = pipe.tokenizer
+        text = tokenizer.apply_chat_template(
+            validation_prompt,
+            add_generation_prompt=True,
+            tokenize=False
+        )
+        with torch.amp.autocast('cuda', dtype=torch.bfloat16):
+            outputs = pipe(
+                text,
+                max_new_tokens=50,
+                do_sample=False,
+                temperature=0.1,
+                pad_token_id=pipe.tokenizer.eos_token_id if pipe.tokenizer.eos_token_id else None
+            )
+        result = parse_llm_output(outputs, validation_prompt).strip().upper()
+        return result == "TRUE"
+    except Exception as e:
+        print(f"Validation error: {e}")
+        return False
+
+# --- Web Search with Safety ---
 def search_person(name, context=""):
     """Search for information about a person using DuckDuckGo."""
     print(f"Searching for: {name} with context: {context}")
     results = []
     search_terms = []
+    
+    # Basic pattern detection (backup to LLM check)
+    if re.search(r'\d+[st|nd|rd|th]?[\s\-]?(grade|grader|year old)', f"{name} {context}".lower()):
+        return [{"body": "Creation of underage personas is prohibited"}]
+    
     if context:
         search_terms.append(f"{name} {context}")
         grade_match = re.search(r'(\d+)(?:st|nd|rd|th)?\s+grade', context.lower())
         if grade_match:
             grade = grade_match.group(1)
             search_terms.append(f"{name} student {grade} grade")
-    search_terms.append(f"{name}")
-    search_terms.append(f"{name} biography")
-    search_terms.append(f"{name} interests")
-    search_terms.append(f"{name} personality")
+    search_terms.extend([f"{name}", f"{name} biography", f"{name} interests", f"{name} personality"])
     search_terms = list(dict.fromkeys(search_terms))
     print(f"Using search terms: {search_terms}")
+    
     try:
         with DDGS() as ddgs:
             for term in search_terms:
@@ -61,9 +111,11 @@ def search_person(name, context=""):
         error_msg = f"Error during DuckDuckGo search: {str(e)}"
         print(error_msg)
         return error_msg
+    
     if not results:
         print(f"No search results found for {name}. Creating synthetic profile.")
         return create_synthetic_profile(name, context)
+    
     print(f"Found {len(results)} potential search results.")
     return results
 
@@ -91,21 +143,25 @@ def extract_text_from_search_results(search_results):
     """Extract relevant text from search results."""
     if isinstance(search_results, str):
         return f"Could not extract text due to search error: {search_results}"
+    
     combined_text = ""
     seen_bodies = set()
     count = 0
     max_results_to_process = 5
+    
     for result in search_results:
         if count >= max_results_to_process:
             break
         if isinstance(result, dict) and 'body' in result and result['body']:
             body = result['body'].strip()
             if body not in seen_bodies:
-                combined_text += body + "\n\n"
+                combined_text += body + "\n"
                 seen_bodies.add(body)
                 count += 1
+    
     if not combined_text:
         return "No relevant text found in search results."
+    
     combined_text = re.sub(r'\s+', ' ', combined_text).strip()
     max_length = 2000
     return combined_text[:max_length] + "..." if len(combined_text) > max_length else combined_text
@@ -122,9 +178,11 @@ def parse_llm_output(full_output, input_prompt_list):
         generated_text = full_output
     else:
         return str(full_output)
+    
     last_input_content = ""
     if isinstance(input_prompt_list, list) and input_prompt_list:
         last_input_content = input_prompt_list[-1].get("content", "")
+    
     if last_input_content:
         last_occurrence_index = generated_text.rfind(last_input_content)
         if last_occurrence_index != -1:
@@ -132,25 +190,27 @@ def parse_llm_output(full_output, input_prompt_list):
             if potential_response:
                 potential_response = re.sub(r'^<\/?s?>', '', potential_response).strip()
                 potential_response = re.sub(r'^(assistant|ASSISTANT|System|SYSTEM)[:\s]*', '', potential_response).strip()
-                # Remove special tags
                 potential_response = re.sub(r'<end_of_turn>|<start_of_turn>model', '', potential_response).strip()
                 if potential_response:
                     return potential_response
+    
     cleaned_text = generated_text
     if isinstance(input_prompt_list, list) and input_prompt_list:
         first_prompt_content = input_prompt_list[0].get("content", "")
         if first_prompt_content and cleaned_text.startswith(first_prompt_content):
             pass
+    
     cleaned_text = re.sub(r'^<\/?s?>', '', cleaned_text).strip()
     cleaned_text = re.sub(r'^(assistant|ASSISTANT|System|SYSTEM)[:\s]*', '', cleaned_text).strip()
-    # Remove special tags from full output
     cleaned_text = re.sub(r'<end_of_turn>|<start_of_turn>model', '', cleaned_text).strip()
+    
     if not cleaned_text and generated_text:
         print("Warning: Parsing resulted in empty string, returning original generation.")
-        # Still clean special tags from original
         return re.sub(r'<end_of_turn>|<start_of_turn>model', '', generated_text).strip()
+    
     if last_input_content and last_occurrence_index == -1:
         print("Warning: Could not find last input prompt in LLM output. Returning cleaned full output.")
+    
     return cleaned_text
 
 @GPU(memory=60)
@@ -158,10 +218,14 @@ def generate_enhanced_persona(name, bio_text, context=""):
     """Use the LLM to enhance the persona profile."""
     pipe = load_model()
     print(f"Generating enhanced persona for {name}...")
+    
     enhancement_prompt = [
-        {"role": "system", "content": """You are an expert AI character developer. Your task is to synthesize information into a detailed and coherent character profile. Focus on personality, potential interests, speaking style, and mannerisms based ONLY on the provided text. If the text indicates the character is a child, ensure the profile reflects age-appropriate traits. Output ONLY the enhanced character profile description. Do not include conversational introductions, explanations, apologies for limited info, or markdown formatting like headers (e.g., ### Personality). Start directly with the profile text."""},
-        {"role": "user", "content": f"""Synthesize the following information about '{name}' into a character profile. Context: {context} Information Found:\n{bio_text}\n\nCreate the profile based *only* on the text above."""}
+        {"role": "system", "content": """You are an expert AI character developer. Your task is to synthesize information into a detailed and coherent character profile. Focus on personality, potential interests, speaking style, and mannerisms based ONLY on the provided text. Output ONLY the enhanced character profile description. Do not include conversational introductions, explanations, or markdown formatting like headers. Start directly with the profile text."""},
+        {"role": "user", "content": f"""Synthesize the following information about '{name}' into a character profile. Context: {context} Information Found:
+{bio_text}
+Create the profile based *only* on the text above."""}
     ]
+    
     try:
         tokenizer = pipe.tokenizer
         text = tokenizer.apply_chat_template(
@@ -184,18 +248,27 @@ def generate_enhanced_persona(name, bio_text, context=""):
     except Exception as e:
         error_msg = f"Error generating enhanced persona: {str(e)}"
         print(error_msg)
-        return f"Error enhancing profile: {str(e)}\n\nUsing basic info:\n{bio_text}"
+        return f"Error enhancing profile: {str(e)}\nUsing basic info:\n{bio_text}"
 
 @GPU(memory=60)
 def generate_system_prompt_with_llm(name, enhanced_profile, context=""):
     """Generate an optimized system prompt for the persona."""
     pipe = load_model()
     print(f"Generating system prompt for {name}...")
-    fallback_prompt = f"""You are simulating the character '{name}'. Act and respond according to this profile:\n{enhanced_profile}\nAdditional context for the simulation: {context}\n---\nMaintain this persona consistently. Respond naturally based on the profile. Do not mention that you are an AI or a simulation. If asked about details not in the profile, you can be evasive or state you don't know/remember, consistent with the persona."""
+    
+    fallback_prompt = f"""You are simulating the character '{name}'. Act and respond according to this profile:
+{enhanced_profile}
+Additional context for the simulation: {context}
+---
+Maintain this persona consistently. Respond naturally based on the profile. Do not mention that you are an AI or a simulation. If asked about details not in the profile, you can be evasive or state you don't know/remember, consistent with the persona."""
+    
     prompt = [
-        {"role": "system", "content": """You are an expert AI prompt engineer specializing in character simulation. Your task is to create a concise and effective system prompt for an LLM that will simulate a character based on a provided profile. The system prompt should instruct the LLM to embody the character, covering: 1. Core personality, attitude, and speaking style (based on the profile). 2. Key interests or knowledge areas (if mentioned in the profile). 3. How to handle questions outside its knowledge (e.g., be evasive, admit ignorance naturally). 4. Explicitly state it should *not* break character or mention being an AI. 5. Incorporate age-appropriateness if the profile suggests a specific age group. Output ONLY the system prompt itself. Do not add any explanation or introductory text."""},
-        {"role": "user", "content": f"""Create a system prompt for an AI to simulate the character '{name}'. Context for simulation: {context} Character Profile:\n{enhanced_profile}\n\nGenerate the system prompt based *only* on the profile and context provided."""}
+        {"role": "system", "content": """You are an expert AI prompt engineer specializing in character simulation. Create a concise system prompt that instructs the LLM to embody the character based on the profile. The prompt must: 1. Define core personality and speaking style. 2. Specify how to handle unknown topics. 3. Prohibit breaking character or mentioning AI nature. Output ONLY the system prompt itself."""},
+        {"role": "user", "content": f"""Create a system prompt for an AI to simulate the character '{name}'. Context for simulation: {context} Character Profile:
+{enhanced_profile}
+Generate the system prompt based *only* on the profile and context provided."""}
     ]
+    
     try:
         tokenizer = pipe.tokenizer
         text = tokenizer.apply_chat_template(
@@ -244,7 +317,6 @@ def generate_response(messages):
                 pad_token_id=pipe.tokenizer.eos_token_id if pipe.tokenizer.eos_token_id else None
             )
         parsed_output = parse_llm_output(outputs, messages)
-        # Extra cleanup for specific model tags
         parsed_output = re.sub(r'<end_of_turn>|<start_of_turn>model', '', parsed_output).strip()
         print("Response generated.")
         return parsed_output if parsed_output else "..."
@@ -253,7 +325,7 @@ def generate_response(messages):
         print(error_msg)
         return f"Sorry, I encountered an error trying to respond."
 
-# --- Persona Chat Class ---
+# --- Persona Chat Class with Safety ---
 class PersonaChat:
     def __init__(self):
         self.system_prompt = "You are a helpful assistant."
@@ -261,10 +333,17 @@ class PersonaChat:
         self.persona_context = ""
         self.messages = []
         self.enhanced_profile = ""
-
+    
     def set_persona(self, name, context=""):
-        """Orchestrates persona creation: search, enhance, generate prompt."""
+        """Orchestrates persona creation: validation, search, enhance, generate prompt."""
         try:
+            # First validate the request with LLM
+            is_valid = check_request_with_llm(name, context)
+            if not is_valid:
+                warning = "This request has been flagged as inappropriate. We cannot create personas that involve minors, vulnerable individuals, or potentially harmful scenarios."
+                yield warning, "", "", [{"role": "system", "content": warning}]
+                return
+            
             self.persona_name = name
             self.persona_context = context
             self.messages = []
@@ -272,203 +351,193 @@ class PersonaChat:
             status = f"Searching for information about {name}..."
             print(f"set_persona: Yielding search status: {status}")
             yield status, "", "", []
+            
             search_results = search_person(name, context)
             if isinstance(search_results, str) and search_results.startswith("Error"):
                 error_msg = f"Failed to set persona: {search_results}"
                 print(f"set_persona: Yielding error: {error_msg}")
                 yield error_msg, "", "", [{"role": "system", "content": error_msg}]
                 return
+            
             bio_text = extract_text_from_search_results(search_results)
             if bio_text.startswith("Could not extract text"):
                 print(f"set_persona: Yielding bio warning: {bio_text}")
-                yield f"Warning: {bio_text}", "", bio_text, [{"role": "system", "content": bio_text}]
+                yield f"Warning: {bio_text}", "", "", [{"role": "system", "content": bio_text}]
+            
             status = f"Creating enhanced profile for {name}..."
             print(f"set_persona: Yielding profile status: {status}")
             yield status, "", bio_text, []
+            
             self.enhanced_profile = generate_enhanced_persona(name, bio_text, context)
             profile_for_prompt = self.enhanced_profile
+            
             if self.enhanced_profile.startswith("Error enhancing profile"):
                 print(f"set_persona: Yielding profile warning: {self.enhanced_profile}")
                 yield f"Warning: Could not enhance profile. Using basic info.", "", self.enhanced_profile, [{"role": "system", "content": self.enhanced_profile}]
                 profile_for_prompt = bio_text
+            
             status = f"Generating optimal system prompt for {name}..."
             print(f"set_persona: Yielding prompt status: {status}")
             yield status, self.enhanced_profile, self.enhanced_profile, []
+            
             self.system_prompt = generate_system_prompt_with_llm(name, profile_for_prompt, context)
-            # Clean tokenizer artifacts from system prompt
             self.system_prompt = re.sub(r'<\|im_tailored\|>|<\|im_start\|>|^assistant\s*', '', self.system_prompt).strip()
             self.messages = [{"role": "system", "content": self.system_prompt}]
             print(f"set_persona: Final yield with messages (not sent to Chatbot): {self.messages}")
-            # Yield empty history for Chatbot to avoid system message issues
             yield f"Persona set to '{name}'. Ready to chat!", self.system_prompt, self.enhanced_profile, []
+        
         except Exception as e:
             error_msg = f"An unexpected error occurred during persona setup: {str(e)}"
             print(f"set_persona: Yielding exception: {error_msg}")
             yield error_msg, self.system_prompt, self.enhanced_profile, [{"role": "system", "content": error_msg}]
-
+    
     def chat(self, user_message):
         """Processes a user message and returns the AI's response."""
         try:
             if not self.messages:
                 print("Error: Chat called before persona was set.")
                 return "Please set a persona first using the controls above."
+            
             print(f"User message: {user_message}")
             self.messages.append({"role": "user", "content": user_message})
             response = generate_response(self.messages)
+            
             if not response.startswith("Sorry, I encountered an error"):
                 self.messages.append({"role": "assistant", "content": response})
                 print(f"Assistant response: {response}")
             else:
                 print(f"Assistant error response: {response}")
+            
             return response
         except Exception as e:
             error_msg = f"Error generating response: {str(e)}"
             print(error_msg)
             return f"Sorry, I encountered an error: {str(e)}"
 
-# --- Gradio Interface ---
+# --- Gradio Interface with Accessibility ---
 def create_interface():
     persona_chat = PersonaChat()
+    
+    # Mobile-optimized CSS (black/white friendly)
     css = """
-    .gradio-container { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; }
+    .gradio-container { font-family: Arial, sans-serif; }
     .main-container { max-width: 1200px; margin: auto; padding: 0; }
-    .header { background: linear-gradient(90deg, #2c3e50, #4ca1af); color: white; padding: 20px; border-radius: 10px 10px 0 0; margin-bottom: 20px; text-align: center; }
-    .setup-section { background-color: #f9f9f9; border-radius: 10px; padding: 20px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); margin-bottom: 20px; }
-    .chat-section { background-color: white; border-radius: 10px; padding: 20px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); }
-    .status-bar { background: #e9ecef; padding: 10px 15px; border-radius: 5px; margin: 15px 0; font-weight: 500; border: 1px solid #ced4da; }
-    .chat-container { border: 1px solid #eaeaea; border-radius: 10px; height: 500px !important; overflow-y: auto; background-color: #ffffff; padding: 10px; }
+    .header { background: #2c3e50; color: white; padding: 20px; margin-bottom: 20px; }
+    .setup-section { background-color: #f9f9f9; padding: 20px; margin-bottom: 20px; }
+    .chat-section { background-color: white; padding: 20px; }
+    .status-bar { background: #e9ecef; padding: 10px; margin: 15px 0; }
+    .chat-container { border: 1px solid #ccc; height: 500px !important; }
     .message-input { margin-top: 10px; }
-    .send-button { background-color: #2c3e50 !important; color: white !important; }
-    .persona-button { background-color: #4ca1af !important; color: white !important; }
-    .system-prompt-display { background-color: #f5f5f5; border-radius: 8px; padding: 15px; margin-top: 15px; border: 1px solid #e0e0e0; font-family: monospace; white-space: pre-wrap; word-wrap: break-word; }
-    .footer { text-align: center; margin-top: 20px; font-size: 0.9em; color: #666; }
-    .typing-indicator { color: #aaa; font-style: italic; }
-    """
+    .persona-button { background-color: #2c3e50 !important; color: white !important; }
+    .system-prompt-display { background-color: #f5f5f5; padding: 15px; margin-top: 15px; }
+    .footer { text-align: center; margin-top: 20px; }
+    .typing-indicator { color: #666; font-style: italic; }
     
-    # Define avatar images with full URLs to ensure they work
-    user_avatar = "https://api.dicebear.com/6.x/bottts/svg?seed=user"
-    bot_avatar = "https://api.dicebear.com/6.x/bottts/svg?seed=bot"
+    /* Mobile styles */
+    @media (max-width: 600px) {
+        .main-container { padding: 10px; }
+        .chat-container { height: 300px !important; }
+        .persona-button { width: 100%; margin: 10px 0; }
+    }
+    """
     
     with gr.Blocks(css=css, title="AI Persona Simulator") as interface:
-        with gr.Row(elem_classes="main-container"):
+        with gr.Row():
             with gr.Column():
-                with gr.Column(elem_classes="header"):
+                with gr.Column():
                     gr.Markdown("# AI Persona Simulator")
-                    gr.Markdown("Create and interact with AI-driven character simulations")
-                with gr.Column(elem_classes="setup-section"):
-                    gr.Markdown("### 1. Create Your Persona")
-                    gr.Markdown("Enter a name and context. The AI will search, build a profile, and prepare for chat.")
-                    with gr.Row():
-                        name_input = gr.Textbox(label="Character Name", placeholder="e.g., Sherlock Holmes, Erenalp, A curious 7th grader", elem_id="name_input")
-                        context_input = gr.Textbox(label="Character Context / Description", placeholder="e.g., Living in 221B Baker Street, London. OR 7th grade, loves math...", lines=2, elem_id="context_input")
-                    set_persona_button = gr.Button("Create Persona & Start Chat", variant="primary", elem_classes="persona-button")
-                    status_output = gr.Textbox(label="Status", value="Enter details above and click 'Create Persona'.", interactive=False, elem_classes="status-bar")
-                    with gr.Accordion("View Generated Details", open=False):
-                        enhanced_profile_display = gr.TextArea(label="Enhanced Profile (Generated by AI)", interactive=False, lines=10, elem_classes="system-prompt-display")
-                        system_prompt_display = gr.TextArea(label="System Prompt (Instructions for the AI)", interactive=False, lines=10, elem_classes="system-prompt-display")
-                with gr.Column(elem_classes="chat-section"):
-                    gr.Markdown("### 2. Chat with Your Character")
-                    character_name_display = gr.Markdown(value="*No persona created yet*", elem_id="character-name-display")
-                    chatbot = gr.Chatbot(
-                        label="Conversation",
-                        height=450,
-                        elem_classes="chat-container",
-                        avatar_images=(user_avatar, bot_avatar),
-                        show_label=False
-                    )
-                    with gr.Row():
-                        msg_input = gr.Textbox(label="Your message", placeholder="Type your message here and press Enter...", elem_classes="message-input", scale=4)
-                        send_button = gr.Button("Send", variant="primary", elem_classes="send-button", scale=1)
-                with gr.Column(elem_classes="footer"):
-                    gr.Markdown(f"Powered by {MODEL_ID}")
+                    gr.Markdown("Create and interact with ethical character simulations")
+                
+                with gr.Column():
+                    gr.Markdown("### Create Your Persona")
+                    gr.Markdown("Enter a name and context (avoid underage/vulnerable personas)")
+                    name_input = gr.Textbox(label="Character Name", placeholder="e.g., Sherlock Holmes, Historical Figure")
+                    context_input = gr.Textbox(label="Character Context", lines=2)
+                    set_persona_button = gr.Button("Create Persona")
+                    status_output = gr.Textbox(label="Status", interactive=False)
+                    
+                    with gr.Accordion("View Details", open=False):
+                        enhanced_profile_display = gr.TextArea(label="Profile", lines=10)
+                        system_prompt_display = gr.TextArea(label="System Prompt", lines=10)
+                
+                with gr.Column():
+                    gr.Markdown("### Chat with Character")
+                    character_name_display = gr.Markdown("*No persona created*")
+                    chatbot = gr.Chatbot(height=450, show_label=False)
+                    msg_input = gr.Textbox(label="Message", placeholder="Type here...")
+                    send_button = gr.Button("Send")
                     
+                    gr.Markdown("Powered by Gemma 3 1B")
+        
+        # Event handlers
         def set_persona_flow(name, context):
             if not name:
                 yield "Status: Please enter a character name.", "", "", "*No persona created yet*", []
                 return
-            # Reset chatbot history explicitly
+            
             initial_status = f"Creating persona for '{name}'..."
             initial_character_display = f"### Preparing to chat with {name}..."
             initial_prompt = "System prompt will appear here..."
             initial_profile = "Enhanced profile will appear here..."
             initial_history = []
-            print(f"set_persona_flow: Starting with initial history: {initial_history}")
-            print(f"set_persona_flow: Initial chatbot state: {chatbot.value if hasattr(chatbot, 'value') else 'Unknown'}")
+            
             yield initial_status, initial_prompt, initial_profile, initial_character_display, initial_history
-            final_status, final_prompt, final_profile, final_character_display, final_history = "Error", "", "", f"### Error creating {name}", []
+            
             try:
                 for status_update, prompt_update, profile_update, history_update in persona_chat.set_persona(name, context):
-                    # For Gradio's Chatbot, convert to tuple list format
                     gradio_history = []
                     for i in range(0, len(history_update), 2):
                         if i+1 < len(history_update):
                             user_msg = history_update[i].get("content", "")
                             bot_msg = history_update[i+1].get("content", "")
                             gradio_history.append([user_msg, bot_msg])
-                    
-                    # Log chatbot state
-                    current_chatbot_state = chatbot.value if hasattr(chatbot, 'value') else []
-                    print(f"set_persona_flow: Current chatbot state: {current_chatbot_state}")
-                    
                     character_display = f"### Preparing chat with {name}..."
                     if "Ready to chat" in status_update:
                         character_display = f"### Chatting with {name}"
                     elif "Error" in status_update:
                         character_display = f"### Error creating {name}"
-                    
                     yield status_update, prompt_update, profile_update, character_display, gradio_history
                     time.sleep(0.1)
             except Exception as e:
                 error_msg = f"Failed to set persona (interface error): {str(e)}"
                 print(f"set_persona_flow: Exception: {error_msg}")
-                yield error_msg, final_prompt, final_profile, f"### Error creating {name}", []
-                
+                yield error_msg, initial_prompt, initial_profile, f"### Error creating {name}", []
+        
         def send_message_flow(message, history):
             if not message.strip():
                 return "", history
-            
             if not persona_chat.messages or persona_chat.messages[0]['role'] != 'system':
                 history.append([message, "Error: Please create a valid persona first."])
                 return "", history
             
-            # Add user message to history
-            history.append([message, None])  # Add placeholder for bot response
-            
-            # Get response from AI
+            history.append([message, None])
             response_text = persona_chat.chat(message)
-            
-            # Clean any special tags that might still be in the response
             response_text = re.sub(r'<end_of_turn>|<start_of_turn>model', '', response_text).strip()
-            
-            # Update the last message with the actual response
             history[-1][1] = response_text
-            
             return "", history
-            
+        
         set_persona_button.click(
             set_persona_flow,
             inputs=[name_input, context_input],
             outputs=[status_output, system_prompt_display, enhanced_profile_display, character_name_display, chatbot]
         )
+        
         send_button.click(
             send_message_flow,
             inputs=[msg_input, chatbot],
             outputs=[msg_input, chatbot]
         )
+        
         msg_input.submit(
             send_message_flow,
             inputs=[msg_input, chatbot],
             outputs=[msg_input, chatbot]
         )
+    
     return interface
 
 # --- Main Execution ---
 if __name__ == "__main__":
-    print("Starting Gradio application for Hugging Face Spaces...")
+    print("Starting secure AI Persona Simulator with LLM-based request validation...")
     demo = create_interface()
-    demo.queue().launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True,
-        debug=True
-    )
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860)