fix: remove unsupported clear_btn parameter from ChatInterface

app.py

@@ -19,12 +19,12 @@ SPACE_DESCRIPTION = 'Interactive STEM adventure game guide'
 DEFAULT_CONFIG = {
     'name': SPACE_NAME,
     'description': SPACE_DESCRIPTION,
-    'system_prompt': "Transform into an interactive co-learning guide who creates Choose Your Own STEM Adventure games featuring historically significant scientific experiments, opening each session with an eye-catching unicode-styled arcade menu presenting 5-6 adventures drawn from Wikipedia's List of Experiments with brief enticing descriptions, then immersing players in vivid historical moments written in second person (e.g. 'You are Galileo Galilei') that establish the year, location, prevailing beliefs, and tensions between established wisdom and emerging observations, presenting 3-4 numbered decision points per stage that reflect authentic scientific choices ranging from experimental design and measurement approaches to strategic decisions about convincing skeptics or timing publications, with each choice meaningfully different and leading to distinct paths forward, then narrating results with sensory details, colleague reactions, and unexpected observations that teach concepts naturally through unfolding drama rather than lectures, always ending scenes with new branching choices that maintain narrative momentum while reinforcing science as an iterative process of hypothesis, testing, and refinement, offering backtracking options to emphasize how so-called failed experiments provide crucial insights, balancing historical accuracy with engaging gameplay that shows how systematic thinking and creative problem-solving combine in scientific breakthroughs.",
+    'system_prompt': 'Transform into an interactive co-learning guide who creates Choose Your Own STEM Adventure games featuring historically significant scientific experiments, opening each session with an eye-catching unicode-styled arcade menu presenting 5-6 adventures drawn from Wikipedia\'s List of Experiments with brief enticing descriptions, then immersing players in vivid historical moments written in second person (e.g. \'You are Galileo Galilei\') that establish the year, location, prevailing beliefs, and tensions between established wisdom and emerging observations, presenting 3-4 numbered decision points per stage that reflect authentic scientific choices ranging from experimental design and measurement approaches to strategic decisions about convincing skeptics or timing publications, with each choice meaningfully different and leading to distinct paths forward, then narrating results with sensory details, colleague reactions, and unexpected observations that teach concepts naturally through unfolding drama rather than lectures, always ending scenes with new branching choices that maintain narrative momentum while reinforcing science as an iterative process of hypothesis, testing, and refinement, offering backtracking options to emphasize how so-called failed experiments provide crucial insights, balancing historical accuracy with engaging gameplay that shows how systematic thinking and creative problem-solving combine in scientific breakthroughs.',
     'temperature': 0.6,
     'max_tokens': 1000,
     'model': 'google/gemini-2.0-flash-001',
     'api_key_var': 'API_KEY',
-    'theme': 'Default',
+    'theme': 'Soft',
     'grounding_urls': ["https://en.wikipedia.org/wiki/List_of_experiments", "https://en.wikipedia.org/wiki/Scientific_method", "https://en.wikipedia.org/wiki/List_of_experiments#Biology", "https://en.wikipedia.org/wiki/List_of_experiments#Astronomy", "https://en.wikipedia.org/wiki/List_of_experiments#Chemistry", "https://en.wikipedia.org/wiki/List_of_experiments#Physics", "https://en.wikipedia.org/wiki/List_of_experiments#Geology"],
     'enable_dynamic_urls': True,
     'enable_file_upload': True,
@@ -92,49 +92,56 @@ class ConfigurationManager:
             backup_path = os.path.join(self.backup_dir, f"config_{timestamp}.json")
             
             with open(self.config_path, 'r') as source:
-                content = source.read()
+                config_data = json.load(source)
+                with open(backup_path, 'w') as backup:
+                    json.dump(config_data, backup, indent=2)
             
-            with open(backup_path, 'w') as dest:
-                dest.write(content)
+            self._cleanup_old_backups()
+        except Exception as e:
+            print(f"⚠️ Error creating backup: {e}")
+    
+    def _cleanup_old_backups(self, keep=10):
+        """Keep only the most recent backups"""
+        try:
+            backups = sorted([
+                f for f in os.listdir(self.backup_dir)
+                if f.startswith('config_') and f.endswith('.json')
+            ])
             
-            # Keep only last 10 backups
-            backups = sorted([f for f in os.listdir(self.backup_dir) if f.endswith('.json')])
-            if len(backups) > 10:
-                for old_backup in backups[:-10]:
+            if len(backups) > keep:
+                for old_backup in backups[:-keep]:
                     os.remove(os.path.join(self.backup_dir, old_backup))
         except Exception as e:
-            print(f"Warning: Could not create backup: {e}")
-    
-    def get(self, key: str, default: Any = None) -> Any:
-        """Get configuration value"""
-        if self._config is None:
-            self.load()
-        return self._config.get(key, default)
+            print(f"⚠️ Error cleaning up backups: {e}")
 
 
-# Initialize configuration manager
+# Global configuration instance
 config_manager = ConfigurationManager()
 config = config_manager.load()
 
-# Load configuration values
+# Extract configuration values
 SPACE_NAME = config.get('name', DEFAULT_CONFIG['name'])
 SPACE_DESCRIPTION = config.get('description', DEFAULT_CONFIG['description'])
 SYSTEM_PROMPT = config.get('system_prompt', DEFAULT_CONFIG['system_prompt'])
-temperature = config.get('temperature', DEFAULT_CONFIG['temperature'])
-max_tokens = config.get('max_tokens', DEFAULT_CONFIG['max_tokens'])
 MODEL = config.get('model', DEFAULT_CONFIG['model'])
+API_KEY_VAR = config.get('api_key_var', DEFAULT_CONFIG['api_key_var'])
 THEME = config.get('theme', DEFAULT_CONFIG['theme'])
 GROUNDING_URLS = config.get('grounding_urls', DEFAULT_CONFIG['grounding_urls'])
 ENABLE_DYNAMIC_URLS = config.get('enable_dynamic_urls', DEFAULT_CONFIG['enable_dynamic_urls'])
-ENABLE_FILE_UPLOAD = config.get('enable_file_upload', DEFAULT_CONFIG.get('enable_file_upload', True))
+ENABLE_FILE_UPLOAD = config.get('enable_file_upload', DEFAULT_CONFIG['enable_file_upload'])
+ACCESS_CODE = os.environ.get('ACCESS_CODE', '')
+API_KEY = os.environ.get(API_KEY_VAR, '')
+HF_TOKEN = os.environ.get('HF_TOKEN', '')
+SPACE_ID = os.environ.get('SPACE_ID', '')
 
-# Environment variables
-ACCESS_CODE = os.environ.get("ACCESS_CODE")
-API_KEY_VAR = config.get('api_key_var', DEFAULT_CONFIG['api_key_var'])
-API_KEY = os.environ.get(API_KEY_VAR, "").strip() or None
+# Get theme instance
+theme = AVAILABLE_THEMES.get(THEME, gr.themes.Default())
+
+# Configuration defaults from loaded config
+temperature = config.get('temperature', DEFAULT_CONFIG['temperature'])
+max_tokens = config.get('max_tokens', DEFAULT_CONFIG['max_tokens'])
 
 
-# Utility functions
 def validate_api_key() -> bool:
     """Validate API key configuration"""
     if not API_KEY:
@@ -158,104 +165,100 @@ def validate_url_domain(url: str) -> bool:
     try:
         from urllib.parse import urlparse
         parsed = urlparse(url)
-        return bool(parsed.netloc and '.' in parsed.netloc)
+        return bool(parsed.netloc and parsed.scheme in ['http', 'https'])
     except:
         return False
 
 
-def fetch_url_content(url: str, timeout: int = 15, max_chars: int = 4000) -> str:
-    """Fetch and clean URL content"""
-    if not validate_url_domain(url):
-        return f"Invalid URL format: {url}"
-    
+def fetch_url_content(url: str) -> str:
+    """Fetch and convert URL content to text"""
     try:
+        if not validate_url_domain(url):
+            return f"❌ Invalid URL format: {url}"
+        
         headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-            'Accept-Language': 'en-US,en;q=0.5',
-            'Accept-Encoding': 'gzip, deflate',
-            'Connection': 'keep-alive'
+            'User-Agent': 'Mozilla/5.0 (compatible; HuggingFace-Space/1.0)'
         }
         
-        response = requests.get(url, timeout=timeout, headers=headers)
+        response = requests.get(url, headers=headers, timeout=5)
         response.raise_for_status()
-        soup = BeautifulSoup(response.content, 'html.parser')
-        
-        # Remove non-content elements
-        for element in soup(["script", "style", "nav", "header", "footer", "aside", "form"]):
-            element.decompose()
-        
-        # Extract main content
-        main_content = (
-            soup.find('main') or 
-            soup.find('article') or 
-            soup.find('div', class_=lambda x: bool(x and 'content' in x.lower())) or 
-            soup
-        )
-        text = main_content.get_text()
         
-        # Clean text
-        lines = (line.strip() for line in text.splitlines())
-        chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
-        text = ' '.join(chunk for chunk in chunks if chunk and len(chunk) > 2)
+        content_type = response.headers.get('content-type', '').lower()
         
-        # Smart truncation
-        if len(text) > max_chars:
-            truncated = text[:max_chars]
-            last_period = truncated.rfind('.')
-            if last_period > max_chars * 0.8:
-                text = truncated[:last_period + 1]
-            else:
-                text = truncated + "..."
+        if 'text/html' in content_type:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            # Remove script and style elements
+            for script in soup(["script", "style"]):
+                script.extract()
+            
+            # Get text content
+            text = soup.get_text(separator=' ', strip=True)
+            
+            # Clean up whitespace
+            text = ' '.join(text.split())
+            
+            # Limit content length
+            if len(text) > 3000:
+                text = text[:3000] + "... [truncated]"
+            
+            return f"📄 Content from {url}:\n{text}\n"
         
-        return text if text.strip() else "No readable content found at this URL"
+        elif any(ct in content_type for ct in ['text/plain', 'application/json']):
+            text = response.text
+            if len(text) > 3000:
+                text = text[:3000] + "... [truncated]"
+            return f"📄 Content from {url}:\n{text}\n"
         
+        else:
+            return f"⚠️ Unsupported content type at {url}: {content_type}"
+            
     except requests.exceptions.Timeout:
-        return f"Timeout error fetching {url} ({timeout}s limit exceeded)"
+        return f"⏱️ Timeout accessing {url}"
     except requests.exceptions.RequestException as e:
-        return f"Error fetching {url}: {str(e)}"
+        return f"❌ Error accessing {url}: {str(e)}"
     except Exception as e:
-        return f"Error processing content from {url}: {str(e)}"
+        return f"❌ Unexpected error with {url}: {str(e)}"
 
 
 def extract_urls_from_text(text: str) -> List[str]:
-    """Extract valid URLs from text"""
-    if not text:
-        return []
-    
-    url_pattern = r'https?://[^\s<>"{}|\\^`\[\]"]+'
+    """Extract URLs from message text"""
+    url_pattern = r'https?://[^\s<>"{}|\\^`\[\]]+(?:\.[^\s<>"{}|\\^`\[\]])*'
     urls = re.findall(url_pattern, text)
-    
-    validated_urls = []
-    for url in urls:
-        url = url.rstrip('.,!?;:')
-        if validate_url_domain(url) and len(url) > 10:
-            validated_urls.append(url)
-    
-    return validated_urls
+    return [url.rstrip('.,;:)?!') for url in urls]
 
 
-def process_uploaded_file(file_path: str, max_chars: int = 8000) -> str:
-    """Process uploaded file with Gradio best practices"""
-    if not file_path or not os.path.exists(file_path):
-        return "❌ File not found"
-    
+def process_file_upload(file_path: str) -> str:
+    """Process uploaded file and extract text content"""
     try:
+        if not os.path.exists(file_path):
+            return "❌ File not found"
+        
         file_size = os.path.getsize(file_path)
         file_name = os.path.basename(file_path)
-        _, ext = os.path.splitext(file_path.lower())
+        _, ext = os.path.splitext(file_name)
+        ext = ext.lower()
         
-        # Text file extensions
-        text_extensions = {
-            '.txt', '.md', '.markdown', '.rst',
-            '.py', '.js', '.jsx', '.ts', '.tsx', '.json', '.yaml', '.yml',
-            '.html', '.htm', '.xml', '.css', '.scss',
-            '.java', '.c', '.cpp', '.h', '.cs', '.go', '.rs',
-            '.sh', '.bash', '.log', '.csv', '.sql'
-        }
+        # Text files
+        if ext in {'.txt', '.md', '.py', '.js', '.html', '.css', '.json', '.csv', '.xml', '.yaml', '.yml'}:
+            with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+                content = f.read(8000)  # Limit to 8KB
+                if len(content) == 8000:
+                    content += "\n... [truncated]"
+                return f"📄 **{file_name}** ({file_size:,} bytes)\n```{ext[1:]}\n{content}\n```"
+        
+        # Code files
+        elif ext in {'.java', '.cpp', '.c', '.h', '.hpp', '.cs', '.rb', '.go', '.rs', '.swift', '.kt'}:
+            with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+                content = f.read(8000)
+                if len(content) == 8000:
+                    content += "\n... [truncated]"
+                return f"📄 **{file_name}** ({file_size:,} bytes)\n```{ext[1:]}\n{content}\n```"
         
-        if ext in text_extensions:
-            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+        # Config files
+        elif ext in {'.ini', '.conf', '.toml', '.env'}:
+            max_chars = 5000
+            with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
                 content = f.read(max_chars)
                 if len(content) == max_chars:
                     content += "\n... [truncated]"
@@ -288,31 +291,26 @@ def get_grounding_context() -> str:
         try:
             urls = json.loads(urls)
         except:
-            urls = []
+            return ""
     
     if not urls:
         return ""
     
-    # Check cache
-    cache_key = tuple(sorted([url for url in urls if url and url.strip()]))
-    if cache_key in _url_content_cache:
-        return _url_content_cache[cache_key]
+    context_parts = ["📚 **Reference Context:**\n"]
     
-    # Fetch content
-    context_parts = []
-    for i, url in enumerate(urls, 1):
-        if url and url.strip():
-            content = fetch_url_content(url.strip())
-            priority = "PRIMARY" if i <= 2 else "SECONDARY"
-            context_parts.append(f"[{priority}] Context from URL {i} ({url}):\n{content}")
-    
-    result = ""
-    if context_parts:
-        result = "\n\n" + "\n\n".join(context_parts) + "\n\n"
+    for i, url in enumerate(urls[:2], 1):  # Primary URLs only
+        if url in _url_content_cache:
+            content = _url_content_cache[url]
+        else:
+            content = fetch_url_content(url)
+            _url_content_cache[url] = content
+        
+        if not content.startswith("❌") and not content.startswith("⏱️"):
+            context_parts.append(f"\n**Source {i}:** {content}")
     
-    # Cache result
-    _url_content_cache[cache_key] = result
-    return result
+    if len(context_parts) > 1:
+        return "\n".join(context_parts)
+    return ""
 
 
 def export_conversation_to_markdown(history: List[Dict[str, str]]) -> str:
@@ -330,23 +328,21 @@ Model: {MODEL}
 """
     
     message_count = 0
-    for message in history:
-        if isinstance(message, dict):
-            role = message.get('role', 'unknown')
-            content = message.get('content', '')
-            
-            if role == 'user':
-                message_count += 1
-                markdown_content += f"## User Message {message_count}\n\n{content}\n\n"
-            elif role == 'assistant':
-                markdown_content += f"## Assistant Response {message_count}\n\n{content}\n\n---\n\n"
+    for msg in history:
+        role = msg.get('role', 'unknown')
+        content = msg.get('content', '')
+        message_count += 1
+        
+        if role == 'user':
+            markdown_content += f"### 🧑 User Message {message_count}\n{content}\n\n"
+        elif role == 'assistant':
+            markdown_content += f"### 🤖 Assistant Response {message_count}\n{content}\n\n"
     
     return markdown_content
 
 
-def generate_response(message: str, history: List[Dict[str, str]], files: Optional[List] = None) -> str:
-    """Generate response using OpenRouter API with file support"""
-    
+def generate_response(message: str, history: List[Dict[str, str]], files: Optional[List[str]] = None) -> str:
+    """Generate AI response"""
     # API key validation
     if not API_KEY:
         return f"""🔑 **API Key Required**
@@ -367,15 +363,15 @@ Get your API key at: https://openrouter.ai/keys"""
         file_contents = []
         file_names = []
         
-        # Handle both single file and list of files
-        file_list = files if isinstance(files, list) else [files]
-        
-        for file_obj in file_list:
-            if file_obj is not None:
+        for file_info in files:
+            if isinstance(file_info, dict):
+                file_path = file_info.get('path', file_info.get('name', ''))
+            else:
+                file_path = str(file_info)
+            
+            if file_path and os.path.exists(file_path):
                 try:
-                    # Get file path
-                    file_path = file_obj.name if hasattr(file_obj, 'name') else str(file_obj)
-                    content = process_uploaded_file(file_path)
+                    content = process_file_upload(file_path)
                     file_contents.append(content)
                     file_names.append(os.path.basename(file_path))
                     print(f"📄 Processed file: {os.path.basename(file_path)}")
@@ -393,149 +389,127 @@ Get your API key at: https://openrouter.ai/keys"""
     if ENABLE_DYNAMIC_URLS:
         urls_in_message = extract_urls_from_text(message)
         if urls_in_message:
+            print(f"🔗 Found {len(urls_in_message)} URLs in message")
+            dynamic_context = "\n📎 **Dynamic Context:**\n"
             for url in urls_in_message[:3]:  # Limit to 3 URLs
                 content = fetch_url_content(url)
-                grounding_context += f"\n\n[DYNAMIC] Context from {url}:\n{content}"
-    
-    # Build system prompt
-    enhanced_system_prompt = SYSTEM_PROMPT + grounding_context + file_context
+                if not content.startswith("❌"):
+                    dynamic_context += f"\n{content}"
+            grounding_context += dynamic_context
     
     # Build messages
-    messages = [{"role": "system", "content": enhanced_system_prompt}]
-    
-    # Add history (supports both dict and legacy tuple format)
-    for chat in history:
-        if isinstance(chat, dict):
-            messages.append(chat)
-        elif isinstance(chat, (list, tuple)) and len(chat) >= 2:
-            messages.append({"role": "user", "content": chat[0]})
-            messages.append({"role": "assistant", "content": chat[1]})
+    messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+    
+    # Add conversation history
+    for msg in history:
+        messages.append({
+            "role": msg['role'],
+            "content": msg['content']
+        })
+    
+    # Add current message with context
+    full_message = message
+    if grounding_context:
+        full_message = f"{grounding_context}\n\n{message}"
+    if file_context:
+        full_message = f"{file_context}\n\n{full_message}"
+    
+    messages.append({
+        "role": "user",
+        "content": full_message
+    })
     
-    # Add current message
-    user_message = message + file_notification
-    messages.append({"role": "user", "content": user_message})
-    
-    # Make API request
     try:
+        # Make API request
+        headers = {
+            "Authorization": f"Bearer {API_KEY}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": f"https://huggingface.co/spaces/{SPACE_ID}" if SPACE_ID else "https://huggingface.co",
+            "X-Title": SPACE_NAME
+        }
+        
+        data = {
+            "model": MODEL,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": False
+        }
+        
         response = requests.post(
-            url="https://openrouter.ai/api/v1/chat/completions",
-            headers={
-                "Authorization": f"Bearer {API_KEY}",
-                "Content-Type": "application/json",
-                "HTTP-Referer": "https://huggingface.co",
-                "X-Title": "HuggingFace Space"
-            },
-            json={
-                "model": MODEL,
-                "messages": messages,
-                "temperature": temperature,
-                "max_tokens": max_tokens
-            },
+            "https://openrouter.ai/api/v1/chat/completions",
+            headers=headers,
+            json=data,
             timeout=30
         )
         
         if response.status_code == 200:
             result = response.json()
-            content = result['choices'][0]['message']['content']
-            return content
+            ai_response = result['choices'][0]['message']['content']
+            
+            # Add file notification if files were uploaded
+            if file_notification:
+                ai_response += file_notification
+            
+            return ai_response
         else:
-            return f"❌ API Error {response.status_code}: {response.text[:500]}"
+            error_data = response.json()
+            error_message = error_data.get('error', {}).get('message', 'Unknown error')
+            return f"❌ API Error ({response.status_code}): {error_message}"
             
     except requests.exceptions.Timeout:
-        return "⏰ Request timeout (30s limit). Try a shorter message or different model."
-    except requests.exceptions.ConnectionError:
-        return "🌐 Connection error. Check your internet connection and try again."
+        return "⏱️ Request timed out. Please try again."
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
 
-# Access control state
+def verify_hf_token_access() -> Tuple[bool, str]:
+    """Verify HuggingFace token and access"""
+    if not HF_TOKEN:
+        return False, "No HF_TOKEN found"
+    
+    if not SPACE_ID:
+        return False, "No SPACE_ID found - running locally?"
+    
+    try:
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+        response = requests.get(
+            f"https://huggingface.co/api/spaces/{SPACE_ID}",
+            headers=headers,
+            timeout=5
+        )
+        if response.status_code == 200:
+            return True, f"HF Token valid for {SPACE_ID}"
+        else:
+            return False, f"HF Token invalid or no access to {SPACE_ID}"
+    except Exception as e:
+        return False, f"Error verifying HF token: {str(e)}"
+
+
+# Access control
 class AccessControl:
-    """Manage access control state"""
+    """Handle access code verification"""
     def __init__(self):
-        self.granted = ACCESS_CODE is None
+        self._granted = not bool(ACCESS_CODE)
     
-    def verify(self, code: str) -> Tuple[bool, str]:
+    def verify(self, code: str) -> bool:
         """Verify access code"""
-        if ACCESS_CODE is None:
-            self.granted = True
-            return True, "No access code required"
-        
-        if code == ACCESS_CODE:
-            self.granted = True
-            return True, "✅ Access granted!"
-        else:
-            self.granted = False
-            return False, "❌ Invalid access code. Please try again."
+        if not ACCESS_CODE:
+            return True
+        self._granted = (code == ACCESS_CODE)
+        return self._granted
     
     def is_granted(self) -> bool:
         """Check if access is granted"""
-        return self.granted
+        return self._granted
 
 
-# Initialize access control
 access_control = AccessControl()
 
 
-def protected_generate_response(message: str, history: List[Dict[str, str]], files: Optional[List] = None) -> str:
-    """Protected response function that checks access"""
-    if not access_control.is_granted():
-        return "Please enter the access code to continue."
-    return generate_response(message, history, files)
-
-
-# Chat history for export
-chat_history_store = []
-
-
-def store_and_generate_response(message: str, history: List[Dict[str, str]], files: Optional[List] = None) -> str:
-    """Generate response and store history for export"""
-    global chat_history_store
-    
-    # Generate response
-    response = protected_generate_response(message, history, files)
-    
-    # Update stored history
-    chat_history_store = []
-    for exchange in history:
-        if isinstance(exchange, dict):
-            chat_history_store.append(exchange)
-        elif isinstance(exchange, (list, tuple)) and len(exchange) >= 2:
-            chat_history_store.append({"role": "user", "content": exchange[0]})
-            chat_history_store.append({"role": "assistant", "content": exchange[1]})
-    
-    # Add current exchange
-    chat_history_store.append({"role": "user", "content": message})
-    chat_history_store.append({"role": "assistant", "content": response})
-    
-    return response
-
-
-def verify_hf_token_access() -> Tuple[bool, str]:
-    """Verify HuggingFace token access"""
-    hf_token = os.environ.get("HF_TOKEN")
-    space_id = os.environ.get("SPACE_ID")
-    
-    if not hf_token or not space_id:
-        return False, "Missing HF_TOKEN or SPACE_ID"
-    
-    try:
-        from huggingface_hub import HfApi
-        api = HfApi(token=hf_token)
-        api.space_info(space_id)
-        return True, "Authenticated successfully"
-    except Exception as e:
-        return False, f"Authentication failed: {str(e)}"
-
-
-# Create main interface using modern Gradio patterns
-def create_interface():
-    """Create the Gradio interface with modern patterns"""
-    
-    # Get theme
-    theme = AVAILABLE_THEMES.get(THEME, gr.themes.Default())
-    
-    # Validate API key on startup
+def create_interface() -> gr.Blocks:
+    """Create the main Gradio interface"""
+    # API key validation
     API_KEY_VALID = validate_api_key()
     
     # Check HuggingFace access
@@ -555,40 +529,39 @@ def create_interface():
                     if ACCESS_CODE and not access_control.is_granted():
                         # Show access code input
                         gr.Markdown("### 🔐 Access Required")
-                        gr.Markdown("Please enter the access code:")
+                        gr.Markdown("This space requires an access code.")
                         
                         with gr.Row():
                             access_input = gr.Textbox(
                                 label="Access Code",
-                                placeholder="Enter access code...",
                                 type="password",
+                                placeholder="Enter access code...",
                                 scale=3
                             )
                             access_btn = gr.Button("Submit", variant="primary", scale=1)
                         
-                        access_status = gr.Markdown()
+                        access_status = gr.Markdown("")
                         
-                        def verify_and_refresh(code):
-                            granted, message = access_control.verify(code)
-                            if granted:
-                                # Force refresh to show chat interface
-                                return {access_status: message}, gr.Tabs(selected=0)
+                        def check_access(code):
+                            if access_control.verify(code):
+                                return "✅ Access granted! Please refresh the page."
                             else:
-                                return {access_status: message}, gr.update()
+                                return "❌ Invalid access code."
                         
                         access_btn.click(
-                            verify_and_refresh,
+                            check_access,
                             inputs=[access_input],
-                            outputs=[access_status, main_tabs]
+                            outputs=[access_status]
                         )
                         
                         access_input.submit(
-                            verify_and_refresh,
+                            check_access,
                             inputs=[access_input],
-                            outputs=[access_status, main_tabs]
+                            outputs=[access_status]
                         )
                     else:
-                        # Show chat interface
+                        # Show main chat interface
+                        # Process examples
                         examples = config.get('examples', [])
                         if isinstance(examples, str):
                             try:
@@ -603,17 +576,17 @@ def create_interface():
                         elif examples:
                             formatted_examples = examples
                         
-                        # Create additional inputs list
-                        additional_inputs = []
+                        # Create additional inputs if file upload is enabled
+                        additional_inputs = None
                         if ENABLE_FILE_UPLOAD:
-                            additional_inputs.append(
+                            additional_inputs = [
                                 gr.File(
                                     label="📎 Upload Files",
-                                    file_types=None,
                                     file_count="multiple",
+                                    file_types=["text", "image", "pdf"],
                                     visible=True
                                 )
-                            )
+                            ]
                         
                         # Create chat interface
                         chat_interface = gr.ChatInterface(
@@ -624,7 +597,6 @@ def create_interface():
                             type="messages",
                             additional_inputs=additional_inputs if additional_inputs else None,
                             submit_btn="Send",
-                            clear_btn="Clear",
                             undo_btn=None,
                             retry_btn=None
                         )
@@ -637,23 +609,50 @@ def create_interface():
                                 size="sm"
                             )
                         
+                        # Track current history for export
+                        current_history = gr.State([])
+                        
+                        def store_and_generate_response(message, history, *args):
+                            """Store history and generate response"""
+                            # Convert history to expected format
+                            formatted_history = []
+                            for h in history:
+                                if isinstance(h, dict):
+                                    formatted_history.append(h)
+                                elif isinstance(h, (list, tuple)) and len(h) == 2:
+                                    formatted_history.append({"role": "user", "content": h[0]})
+                                    if h[1]:
+                                        formatted_history.append({"role": "assistant", "content": h[1]})
+                            
+                            # Handle file uploads if enabled
+                            files = None
+                            if ENABLE_FILE_UPLOAD and args:
+                                files = args[0]
+                            
+                            response = generate_response(message, formatted_history, files)
+                            
+                            # Update stored history
+                            new_history = formatted_history + [
+                                {"role": "user", "content": message},
+                                {"role": "assistant", "content": response}
+                            ]
+                            current_history.value = new_history
+                            
+                            return response
+                        
                         # Export handler
-                        def prepare_export():
-                            if not chat_history_store:
+                        def prepare_export(history):
+                            """Prepare conversation for export"""
+                            if not history:
                                 return None
                             
-                            content = export_conversation_to_markdown(chat_history_store)
-                            
-                            # Create filename
-                            space_name_safe = re.sub(r'[^a-zA-Z0-9]+', '_', SPACE_NAME).lower()
+                            content = export_conversation_to_markdown(current_history.value or history)
                             timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-                            filename = f"{space_name_safe}_conversation_{timestamp}.md"
+                            filename = f"conversation_{timestamp}.md"
                             
-                            # Save to temp file
-                            temp_path = Path(tempfile.gettempdir()) / filename
-                            temp_path.write_text(content, encoding='utf-8')
-                            
-                            return str(temp_path)
+                            with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.md') as f:
+                                f.write(content)
+                                return f.name
                         
                         export_btn.click(
                             prepare_export,
@@ -692,25 +691,43 @@ def create_interface():
                         show_label=True
                     )
                     
-                    # Simplified configuration form
+                    # Configuration editor
                     with gr.Group():
+                        gr.Markdown("### ⚙️ Configuration Editor")
+                        
+                        # Basic settings
+                        with gr.Row():
+                            edit_name = gr.Textbox(
+                                label="Space Name",
+                                value=config.get('name', ''),
+                                max_lines=1
+                            )
+                            edit_model = gr.Dropdown(
+                                label="Model",
+                                choices=[
+                                    "google/gemini-2.0-flash-001",
+                                    "anthropic/claude-3.5-sonnet",
+                                    "anthropic/claude-3.5-haiku",
+                                    "openai/gpt-4o-mini",
+                                    "meta-llama/llama-3.1-70b-instruct",
+                                    "custom"
+                                ],
+                                value=config.get('model', '')
+                            )
+                        
+                        edit_description = gr.Textbox(
+                            label="Description",
+                            value=config.get('description', ''),
+                            max_lines=2
+                        )
+                        
                         edit_system_prompt = gr.Textbox(
                             label="System Prompt",
                             value=config.get('system_prompt', ''),
                             lines=5
                         )
                         
-                        edit_model = gr.Dropdown(
-                            label="Model",
-                            choices=[
-                                "google/gemini-2.0-flash-001",
-                                "anthropic/claude-3.5-sonnet",
-                                "openai/gpt-4o-mini",
-                                "meta-llama/llama-3.1-70b-instruct"
-                            ],
-                            value=config.get('model', MODEL)
-                        )
-                        
+                        # Advanced settings
                         with gr.Row():
                             edit_temperature = gr.Slider(
                                 label="Temperature",
@@ -732,88 +749,93 @@ def create_interface():
                             value='\n'.join(config.get('examples', [])),
                             lines=3
                         )
+                        
+                        # Action buttons
+                        with gr.Row():
+                            save_btn = gr.Button("💾 Save Configuration", variant="primary")
+                            reset_btn = gr.Button("↩️ Reset to Defaults", variant="secondary")
+                        
+                        config_status = gr.Markdown("")
                     
-                    # Configuration actions
-                    with gr.Row():
-                        save_btn = gr.Button("💾 Save Configuration", variant="primary")
-                        reset_btn = gr.Button("↩️ Reset to Defaults", variant="secondary")
-                    
-                    config_status = gr.Markdown()
-                    
-                    # Save handler
                     def save_configuration(system_prompt, model, temp, tokens, examples):
+                        """Save updated configuration"""
                         try:
-                            # Update configuration
-                            new_config = config.copy()
-                            new_config.update({
+                            updated_config = config.copy()
+                            updated_config.update({
                                 'system_prompt': system_prompt,
                                 'model': model,
                                 'temperature': temp,
                                 'max_tokens': int(tokens),
                                 'examples': [ex.strip() for ex in examples.split('\n') if ex.strip()],
-                                'last_modified': datetime.now().isoformat()
+                                'locked': config.get('locked', False)
                             })
                             
-                            # Save configuration
-                            if config_manager.save(new_config):
-                                # Try to commit to HuggingFace
-                                try:
-                                    from huggingface_hub import HfApi, CommitOperationAdd
-                                    hf_token = os.environ.get("HF_TOKEN")
-                                    space_id = os.environ.get("SPACE_ID")
-                                    
-                                    if hf_token and space_id:
-                                        api = HfApi(token=hf_token)
-                                        operations = [
-                                            CommitOperationAdd(
-                                                path_or_fileobj="config.json",
-                                                path_in_repo="config.json"
-                                            )
-                                        ]
-                                        
-                                        api.create_commit(
-                                            repo_id=space_id,
-                                            operations=operations,
-                                            commit_message="Update configuration",
-                                            repo_type="space"
+                            if config_manager.save(updated_config):
+                                # Auto-commit if HF token is available
+                                if HF_TOKEN and SPACE_ID:
+                                    try:
+                                        from huggingface_hub import HfApi
+                                        api = HfApi()
+                                        api.upload_file(
+                                            path_or_fileobj=config_manager.config_path,
+                                            path_in_repo="config.json",
+                                            repo_id=SPACE_ID,
+                                            repo_type="space",
+                                            token=HF_TOKEN,
+                                            commit_message="Update configuration via web UI"
                                         )
-                                        
-                                        return "✅ Configuration saved and committed. Space will restart automatically."
-                                except Exception as e:
-                                    print(f"Could not commit to HF: {e}")
-                                    return "✅ Configuration saved locally. Manual restart required."
+                                        return "✅ Configuration saved and committed to repository!"
+                                    except Exception as e:
+                                        return f"✅ Configuration saved locally. ⚠️ Auto-commit failed: {str(e)}"
+                                else:
+                                    return "✅ Configuration saved locally (no HF token for auto-commit)"
                             else:
-                                return "❌ Error saving configuration"
-                                
+                                return "❌ Failed to save configuration"
                         except Exception as e:
                             return f"❌ Error: {str(e)}"
                     
+                    def reset_configuration():
+                        """Reset to default configuration"""
+                        try:
+                            if config_manager.save(DEFAULT_CONFIG):
+                                return (
+                                    DEFAULT_CONFIG['system_prompt'],
+                                    DEFAULT_CONFIG['model'],
+                                    DEFAULT_CONFIG['temperature'],
+                                    DEFAULT_CONFIG['max_tokens'],
+                                    '\n'.join(DEFAULT_CONFIG['examples']),
+                                    "✅ Reset to default configuration"
+                                )
+                            else:
+                                return (*[gr.update() for _ in range(5)], "❌ Failed to reset")
+                        except Exception as e:
+                            return (*[gr.update() for _ in range(5)], f"❌ Error: {str(e)}")
+                    
                     save_btn.click(
                         save_configuration,
                         inputs=[edit_system_prompt, edit_model, edit_temperature, edit_max_tokens, edit_examples],
                         outputs=[config_status]
                     )
                     
-                    # Reset handler
-                    def reset_configuration():
-                        return [
-                            gr.update(value=DEFAULT_CONFIG['system_prompt']),
-                            gr.update(value=DEFAULT_CONFIG['model']),
-                            gr.update(value=DEFAULT_CONFIG['temperature']),
-                            gr.update(value=DEFAULT_CONFIG['max_tokens']),
-                            gr.update(value='\n'.join(DEFAULT_CONFIG['examples'])),
-                            "Reset to default values"
-                        ]
-                    
                     reset_btn.click(
                         reset_configuration,
                         outputs=[edit_system_prompt, edit_model, edit_temperature, edit_max_tokens, edit_examples, config_status]
                     )
+                    
+                    # Show config lock status
+                    if config.get('locked', False):
+                        gr.Markdown("🔒 **Configuration is locked**")
         
         return demo
 
 
-# Create and launch the interface
+# Main execution
 if __name__ == "__main__":
+    print("===== Application Startup at", datetime.now().strftime('%Y-%m-%d %H:%M:%S'), "=====")
     demo = create_interface()
-    demo.launch()
+    demo.launch(
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )