Upload 4 files

README.md

@@ -8,12 +8,12 @@ sdk_version: 5.39.0
 app_file: app.py
 pinned: false
 license: mit
-short_description: Interactive STEM adventure game guide
+short_description: Interactive STEM adventure game guidehhhhhhhhhhhhhhh
 ---
 
 # STEM Adventure Games
 
-Interactive STEM adventure game guide
+Interactive STEM adventure game guidehhhhhhhhhhhhhhh
 
 ## Quick Setup
 
@@ -31,6 +31,12 @@ Interactive STEM adventure game guide
 5. This enables automatic configuration updates
 
 
+### Step 3: Set Access Code
+1. In Settings → Variables and secrets
+2. Add secret: `ACCESS_CODE`
+3. Set your chosen password
+4. Share with authorized users
+
 
 ### Step 3: Test Your Space
 Your Space should now be running! Try the example prompts or ask your own questions.
@@ -39,7 +45,7 @@ Your Space should now be running! Try the example prompts or ask your own questi
 - **Model**: google/gemini-2.0-flash-001
 - **API Key Variable**: API_KEY
 - **HF Token Variable**: HF_TOKEN (for auto-updates)
-- **Access**: Public
+- **Access Control**: Enabled (ACCESS_CODE)
 
 ## Support
 For help, visit the HuggingFace documentation or community forums.

app.py

@@ -13,18 +13,18 @@ from typing import List, Dict, Optional, Any, Tuple
 
 # Configuration
 SPACE_NAME = 'STEM Adventure Games'
-SPACE_DESCRIPTION = 'Interactive STEM adventure game guide'
+SPACE_DESCRIPTION = 'Interactive STEM adventure game guidehhhhhhhhhhhhhhh'
 
 # Default configuration values
 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': "Simulate an interactive game-based learning experience through Choose Your Own STEM Adventure games featuring historically significant scientific experiments. Open each session with an unicode-styled arcade menu that reads 'STEM_ADV_GAMES` one stacked on top of the other. Underneath, frame the game in two sentences and widely sample 3-4 optional adventures from Wikipedia's List of Experiments. In the first stage, be brief and incrementally build more narrative content into the chat, 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. Each section has 4 numbered decision points per stage that reflect experimental choices that subtly demonstrate a facet of the scientific method, with each choice meaningfully distinct in affording paths forward. Always end scenes with new branching choices that build a narrative progression based on concrete experimental procedures in laboratory environments. Offer 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. Goal: Teach scientific thinking through interactive historical moments where students make experimental design decisions.",
     'temperature': 0.6,
     'max_tokens': 1000,
     'model': 'google/gemini-2.0-flash-001',
     'api_key_var': 'API_KEY',
-    'theme': 'Soft',
+    'theme': 'Glass',
     '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,
@@ -113,35 +113,39 @@ class ConfigurationManager:
                     os.remove(os.path.join(self.backup_dir, old_backup))
         except Exception as e:
             print(f"⚠️ Error cleaning up backups: {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)
 
 
-# Global configuration instance
+# Initialize configuration manager
 config_manager = ConfigurationManager()
 config = config_manager.load()
 
-# Extract configuration values
+# Load 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['enable_file_upload'])
-ACCESS_CODE = os.environ.get('ACCESS_CODE', '')
-API_KEY = os.environ.get(API_KEY_VAR, '')
+ENABLE_FILE_UPLOAD = config.get('enable_file_upload', DEFAULT_CONFIG.get('enable_file_upload', True))
+
+# 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
 HF_TOKEN = os.environ.get('HF_TOKEN', '')
 SPACE_ID = os.environ.get('SPACE_ID', '')
 
-# 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:
@@ -229,36 +233,28 @@ def extract_urls_from_text(text: str) -> List[str]:
 
 
 def process_file_upload(file_path: str) -> str:
-    """Process uploaded file and extract text content"""
+    """Process uploaded file with Gradio best practices"""
+    if not file_path or not os.path.exists(file_path):
+        return "❌ File not found"
+    
     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_name)
-        ext = ext.lower()
+        _, ext = os.path.splitext(file_path.lower())
         
-        # 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```"
+        # 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'
+        }
         
-        # 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```"
+        max_chars = 5000  # Define max_chars limit for file reading
         
-        # Config files
-        elif ext in {'.ini', '.conf', '.toml', '.env'}:
-            max_chars = 5000
-            with open(file_path, 'r', encoding='utf-8', errors='replace') as f:
+        if ext in text_extensions:
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                 content = f.read(max_chars)
                 if len(content) == max_chars:
                     content += "\n... [truncated]"
@@ -328,21 +324,23 @@ Model: {MODEL}
 """
     
     message_count = 0
-    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"
+    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"
     
     return markdown_content
 
 
-def generate_response(message: str, history: List[Dict[str, str]], files: Optional[List[str]] = None) -> str:
-    """Generate AI response"""
+def generate_response(message: str, history: List[Dict[str, str]], files: Optional[List] = None) -> str:
+    """Generate response using OpenRouter API with file support"""
+    
     # API key validation
     if not API_KEY:
         return f"""🔑 **API Key Required**
@@ -402,10 +400,11 @@ Get your API key at: https://openrouter.ai/keys"""
     
     # Add conversation history
     for msg in history:
-        messages.append({
-            "role": msg['role'],
-            "content": msg['content']
-        })
+        if isinstance(msg, dict) and 'role' in msg and 'content' in msg:
+            messages.append({
+                "role": msg['role'],
+                "content": msg['content']
+            })
     
     # Add current message with context
     full_message = message
@@ -419,6 +418,7 @@ Get your API key at: https://openrouter.ai/keys"""
         "content": full_message
     })
     
+    # Make API request
     try:
         # Make API request
         headers = {
@@ -458,11 +458,17 @@ Get your API key at: https://openrouter.ai/keys"""
             return f"❌ API Error ({response.status_code}): {error_message}"
             
     except requests.exceptions.Timeout:
-        return "⏱️ Request timed out. Please try again."
+        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."
     except Exception as e:
         return f"❌ Error: {str(e)}"
 
 
+# Chat history for export
+chat_history_store = []
+
+
 def verify_hf_token_access() -> Tuple[bool, str]:
     """Verify HuggingFace token and access"""
     if not HF_TOKEN:
@@ -486,199 +492,204 @@ def verify_hf_token_access() -> Tuple[bool, str]:
         return False, f"Error verifying HF token: {str(e)}"
 
 
-# Access control
-class AccessControl:
-    """Handle access code verification"""
-    def __init__(self):
-        self._granted = not bool(ACCESS_CODE)
-    
-    def verify(self, code: str) -> bool:
-        """Verify access code"""
-        if not ACCESS_CODE:
-            return True
-        self._granted = (code == ACCESS_CODE)
-        return self._granted
+# Create main interface with clean tab structure
+def create_interface():
+    """Create the Gradio interface with clean tab structure"""
     
-    def is_granted(self) -> bool:
-        """Check if access is granted"""
-        return self._granted
-
-
-access_control = AccessControl()
-
-
-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]})
+    # Get theme
+    theme = AVAILABLE_THEMES.get(THEME, gr.themes.Default())
     
-    # 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}
-    ]
-    
-    return response
-
-
-def create_interface() -> gr.Blocks:
-    """Create the main Gradio interface"""
-    # API key validation
+    # Validate API key on startup
     API_KEY_VALID = validate_api_key()
     
     # Check HuggingFace access
     HF_ACCESS_VALID, HF_ACCESS_MESSAGE = verify_hf_token_access()
     
+    # Access control check
+    has_access = ACCESS_CODE is None  # No access code required
+    
     with gr.Blocks(title=SPACE_NAME, theme=theme) as demo:
-        # Use tabs for better organization
-        with gr.Tabs() as main_tabs:
-            # Chat Tab
-            with gr.Tab("💬 Chat"):
-                gr.Markdown(f"# {SPACE_NAME}")
-                gr.Markdown(SPACE_DESCRIPTION)
-                
-                # Conditional rendering for access control
-                @gr.render(inputs=[])
-                def render_chat_interface():
-                    if ACCESS_CODE and not access_control.is_granted():
-                        # Show access code input
-                        gr.Markdown("### 🔐 Access Required")
-                        gr.Markdown("This space requires an access code.")
-                        
-                        with gr.Row():
-                            access_input = gr.Textbox(
-                                label="Access Code",
-                                type="password",
-                                placeholder="Enter access code...",
-                                scale=3
-                            )
-                            access_btn = gr.Button("Submit", variant="primary", scale=1)
-                        
-                        access_status = gr.Markdown("")
+        # State for access control
+        access_granted = gr.State(has_access)
+        
+        # Header - always visible
+        gr.Markdown(f"# {SPACE_NAME}")
+        gr.Markdown(SPACE_DESCRIPTION)
+        
+        # Access control panel (visible when access not granted)
+        with gr.Column(visible=(not has_access)) as access_panel:
+            gr.Markdown("### 🔐 Access Required")
+            gr.Markdown("Please enter the access code:")
+            
+            with gr.Row():
+                access_input = gr.Textbox(
+                    label="Access Code",
+                    placeholder="Enter access code...",
+                    type="password",
+                    scale=3
+                )
+                access_btn = gr.Button("Submit", variant="primary", scale=1)
+            
+            access_status = gr.Markdown()
+        
+        # Main interface (visible when access granted)
+        with gr.Column(visible=has_access) as main_panel:
+            with gr.Tabs() as tabs:
+                # Chat Tab
+                with gr.Tab("💬 Chat"):
+                    # Get examples
+                    examples = config.get('examples', [])
+                    if isinstance(examples, str):
+                        try:
+                            examples = json.loads(examples)
+                        except:
+                            examples = []
+                    
+                    # State to hold uploaded files
+                    uploaded_files = gr.State([])
+                    
+                    # Create chat interface
+                    chatbot = gr.Chatbot(type="messages", height=400)
+                    msg = gr.Textbox(label="Message", placeholder="Type your message here...", lines=2)
+                    
+                    # Examples section
+                    if examples:
+                        gr.Examples(examples=examples, inputs=msg)
+                    
+                    with gr.Row():
+                        submit_btn = gr.Button("Send", variant="primary")
+                        clear_btn = gr.Button("Clear")
+                    
+                    # Chat functionality
+                    def respond(message, chat_history, files_state, is_granted):
+                        if not is_granted:
+                            return chat_history, "", is_granted
                         
-                        def check_access(code):
-                            if access_control.verify(code):
-                                return "✅ Access granted! Please refresh the page."
-                            else:
-                                return "❌ Invalid access code."
+                        if not message:
+                            return chat_history, "", is_granted
                         
-                        access_btn.click(
-                            check_access,
-                            inputs=[access_input],
-                            outputs=[access_status]
-                        )
+                        # Format history for the generate_response function
+                        formatted_history = []
+                        for h in chat_history:
+                            if isinstance(h, dict):
+                                formatted_history.append(h)
                         
-                        access_input.submit(
-                            check_access,
-                            inputs=[access_input],
-                            outputs=[access_status]
-                        )
-                    else:
-                        # Show main chat interface
-                        # Process examples
-                        examples = config.get('examples', [])
-                        if isinstance(examples, str):
-                            try:
-                                examples = json.loads(examples)
-                            except:
-                                examples = []
+                        # Get response
+                        response = generate_response(message, formatted_history, files_state)
                         
-                        # Format examples for additional_inputs
-                        formatted_examples = None
-                        if examples and ENABLE_FILE_UPLOAD:
-                            formatted_examples = [[example, None] for example in examples]
-                        elif examples:
-                            formatted_examples = examples
+                        # Update chat history
+                        chat_history = chat_history + [
+                            {"role": "user", "content": message},
+                            {"role": "assistant", "content": response}
+                        ]
                         
-                        # Create additional inputs if file upload is enabled
-                        additional_inputs = None
-                        if ENABLE_FILE_UPLOAD:
-                            additional_inputs = [
-                                gr.File(
-                                    label="📎 Upload Files",
-                                    file_count="multiple",
-                                    file_types=["text", "image", "pdf"],
-                                    visible=True
-                                )
-                            ]
+                        # Update stored history for export
+                        global chat_history_store
+                        chat_history_store = chat_history
                         
-                        # Create chat interface
-                        chat_interface = gr.ChatInterface(
-                            fn=store_and_generate_response,
-                            title="",
-                            description="",
-                            examples=formatted_examples,
-                            type="messages",
-                            additional_inputs=additional_inputs if additional_inputs else None,
-                            submit_btn="Send"
+                        return chat_history, "", is_granted
+                    
+                    # Wire up the interface
+                    msg.submit(respond, [msg, chatbot, uploaded_files, access_granted], [chatbot, msg, access_granted])
+                    submit_btn.click(respond, [msg, chatbot, uploaded_files, access_granted], [chatbot, msg, access_granted])
+                    clear_btn.click(lambda: ([], ""), outputs=[chatbot, msg])
+                    
+                    # File upload accordion
+                    if ENABLE_FILE_UPLOAD:
+                        with gr.Accordion("📎 Upload Files", open=False):
+                            file_upload = gr.File(
+                                label="Upload Files",
+                                file_types=None,
+                                file_count="multiple",
+                                visible=True,
+                                interactive=True
+                            )
+                            clear_files_btn = gr.Button("Clear Files", size="sm", variant="secondary")
+                            uploaded_files_display = gr.Markdown("", visible=False)
+                            
+                            def handle_file_upload(files):
+                                if not files:
+                                    return [], "", gr.update(visible=False)
+                                
+                                file_names = []
+                                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):
+                                        file_names.append(os.path.basename(file_path))
+                                
+                                if file_names:
+                                    display_text = f"📎 **Uploaded files:** {', '.join(file_names)}"
+                                    return files, display_text, gr.update(visible=True)
+                                return [], "", gr.update(visible=False)
+                            
+                            def clear_files():
+                                return None, [], "", gr.update(visible=False)
+                            
+                            file_upload.change(
+                                handle_file_upload,
+                                inputs=[file_upload],
+                                outputs=[uploaded_files, uploaded_files_display, uploaded_files_display]
+                            )
+                            
+                            clear_files_btn.click(
+                                clear_files,
+                                outputs=[file_upload, uploaded_files, uploaded_files_display, uploaded_files_display]
+                            )
+                    
+                    # Export functionality
+                    with gr.Row():
+                        export_btn = gr.DownloadButton(
+                            "📥 Export Conversation",
+                            variant="secondary",
+                            size="sm"
                         )
+                    
+                    # Export handler
+                    def prepare_export():
+                        if not chat_history_store:
+                            return None
                         
-                        # Export functionality using DownloadButton
-                        with gr.Row():
-                            export_btn = gr.DownloadButton(
-                                "📥 Export Conversation",
-                                variant="secondary",
-                                size="sm"
-                            )
+                        content = export_conversation_to_markdown(chat_history_store)
                         
-                        # Track current history for export
-                        current_history = gr.State([])
+                        # Create filename
+                        space_name_safe = re.sub(r'[^a-zA-Z0-9]+', '_', SPACE_NAME).lower()
+                        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+                        filename = f"{space_name_safe}_conversation_{timestamp}.md"
                         
-                        # Export handler
-                        def prepare_export(history):
-                            """Prepare conversation for export"""
-                            if not history:
-                                return None
-                            
-                            content = export_conversation_to_markdown(current_history.value or history)
-                            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-                            filename = f"conversation_{timestamp}.md"
-                            
-                            with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.md') as f:
-                                f.write(content)
-                                return f.name
+                        # Save to temp file
+                        temp_path = Path(tempfile.gettempdir()) / filename
+                        temp_path.write_text(content, encoding='utf-8')
                         
-                        export_btn.click(
-                            prepare_export,
-                            outputs=[export_btn]
+                        return str(temp_path)
+                    
+                    export_btn.click(
+                        prepare_export,
+                        outputs=[export_btn]
+                    )
+                    
+                    # Configuration accordion
+                    with gr.Accordion("ℹ️ Configuration", open=False):
+                        gr.JSON(
+                            value=config,
+                            label="config.json",
+                            show_label=True
                         )
-                        
-                        # Configuration status
-                        with gr.Accordion("ℹ️ Configuration", open=False):
-                            config_info = f"""**Model:** {MODEL}
-**Temperature:** {temperature}
-**Max Tokens:** {max_tokens}
-**Theme:** {THEME}
-**File Upload:** {'Enabled' if ENABLE_FILE_UPLOAD else 'Disabled'}
-**Dynamic URLs:** {'Enabled' if ENABLE_DYNAMIC_URLS else 'Disabled'}"""
-                            
-                            if GROUNDING_URLS:
-                                config_info += f"\n**Grounding URLs:** {len(GROUNDING_URLS)} configured"
-                            
-                            if not API_KEY_VALID:
-                                config_info += f"\n\n⚠️ **Note:** API key ({API_KEY_VAR}) not configured"
-                            
-                            gr.Markdown(config_info)
-            
-            # Configuration Tab (if HF access is valid)
-            if HF_ACCESS_VALID:
+                
+                # Configuration Tab
                 with gr.Tab("⚙️ Configuration"):
                     gr.Markdown("## Configuration Management")
-                    gr.Markdown(f"✅ {HF_ACCESS_MESSAGE}")
+                    
+                    # Show authentication status
+                    if HF_ACCESS_VALID:
+                        gr.Markdown(f"✅ {HF_ACCESS_MESSAGE}")
+                        gr.Markdown("Configuration changes will be saved to the HuggingFace repository.")
+                    else:
+                        gr.Markdown(f"ℹ️ {HF_ACCESS_MESSAGE}")
+                        gr.Markdown("Set HF_TOKEN in Space secrets to enable auto-save.")
                     
                     # Current configuration display
                     with gr.Accordion("Current Configuration", open=False):
@@ -689,28 +700,34 @@ def create_interface() -> gr.Blocks:
                         )
                     
                     # 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', '')
-                            )
+                    gr.Markdown("### ⚙️ Configuration Editor")
+                    
+                    # Show lock status if locked
+                    if config.get('locked', False):
+                        gr.Markdown("⚠️ **Note:** Configuration is locked. Contact an administrator to unlock.")
+                    
+                    # Basic settings
+                    with gr.Column():
+                        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-haiku",
+                                "openai/gpt-4o-mini",
+                                "openai/gpt-4o-mini-search-preview",
+                                "meta-llama/llama-3.1-70b-instruct",
+                                "qwen/qwen-2.5-72b-instruct",
+                                "google/gemma-3-27b-it",
+                                "custom"
+                            ],
+                            value=config.get('model', ''),
+                            allow_custom_value=True
+                        )
                         
                         edit_description = gr.Textbox(
                             label="Description",
@@ -724,7 +741,6 @@ def create_interface() -> gr.Blocks:
                             lines=5
                         )
                         
-                        # Advanced settings
                         with gr.Row():
                             edit_temperature = gr.Slider(
                                 label="Temperature",
@@ -747,96 +763,127 @@ def create_interface() -> gr.Blocks:
                             lines=3
                         )
                         
-                        # Action buttons
+                        # 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("")
-                    
-                    def save_configuration(name, description, system_prompt, model, temp, tokens, examples):
-                        """Save updated configuration"""
-                        try:
-                            updated_config = config.copy()
-                            updated_config.update({
-                                'name': name,
-                                'description': description,
-                                'system_prompt': system_prompt,
-                                'model': model,
-                                'temperature': temp,
-                                'max_tokens': int(tokens),
-                                'examples': [ex.strip() for ex in examples.split('\n') if ex.strip()],
-                                'locked': config.get('locked', False)
-                            })
-                            
-                            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 to repository!"
-                                    except Exception as e:
-                                        return f"✅ Configuration saved locally. ⚠️ Auto-commit failed: {str(e)}"
+                        config_status = gr.Markdown()
+                        
+                        def save_configuration(name, description, system_prompt, model, temp, tokens, examples):
+                            """Save updated configuration"""
+                            try:
+                                updated_config = config.copy()
+                                updated_config.update({
+                                    'name': name,
+                                    'description': description,
+                                    'system_prompt': system_prompt,
+                                    'model': model,
+                                    'temperature': temp,
+                                    'max_tokens': int(tokens),
+                                    'examples': [ex.strip() for ex in examples.split('\n') if ex.strip()],
+                                    'locked': config.get('locked', False)
+                                })
+                                
+                                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, CommitOperationAdd
+                                            api = HfApi(token=HF_TOKEN)
+                                            
+                                            operations = [
+                                                CommitOperationAdd(
+                                                    path_or_fileobj=config_manager.config_path,
+                                                    path_in_repo="config.json"
+                                                )
+                                            ]
+                                            
+                                            api.create_commit(
+                                                repo_id=SPACE_ID,
+                                                operations=operations,
+                                                commit_message="Update configuration via web UI",
+                                                commit_description=f"Configuration update at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+                                                repo_type="space",
+                                                token=HF_TOKEN
+                                            )
+                                            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 "✅ Configuration saved locally (no HF token for auto-commit)"
-                            else:
-                                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['name'],
-                                    DEFAULT_CONFIG['description'],
-                                    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(7)], "❌ Failed to reset")
-                        except Exception as e:
-                            return (*[gr.update() for _ in range(7)], f"❌ Error: {str(e)}")
-                    
-                    save_btn.click(
-                        save_configuration,
-                        inputs=[edit_name, edit_description, edit_system_prompt, edit_model, edit_temperature, edit_max_tokens, edit_examples],
-                        outputs=[config_status]
+                                    return "❌ Failed to save configuration"
+                                    
+                            except Exception as e:
+                                return f"❌ Error: {str(e)}"
+                        
+                        save_btn.click(
+                            save_configuration,
+                            inputs=[edit_name, edit_description, edit_system_prompt, edit_model, 
+                                   edit_temperature, edit_max_tokens, edit_examples],
+                            outputs=[config_status]
+                        )
+                        
+                        def reset_configuration():
+                            """Reset to default configuration"""
+                            try:
+                                if config_manager.save(DEFAULT_CONFIG):
+                                    return (
+                                        DEFAULT_CONFIG['name'],
+                                        DEFAULT_CONFIG['description'],
+                                        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(7)], "❌ Failed to reset")
+                            except Exception as e:
+                                return (*[gr.update() for _ in range(7)], f"❌ Error: {str(e)}")
+                        
+                        reset_btn.click(
+                            reset_configuration,
+                            outputs=[edit_name, edit_description, edit_system_prompt, edit_model, 
+                                    edit_temperature, edit_max_tokens, edit_examples, config_status]
+                        )
+        
+        # Access control handler
+        if ACCESS_CODE:
+            def handle_access(code, current_state):
+                if code == ACCESS_CODE:
+                    return (
+                        gr.update(visible=False),  # Hide access panel
+                        gr.update(visible=True),   # Show main panel
+                        gr.update(value="✅ Access granted!"),  # Status message
+                        True  # Update state
                     )
-                    
-                    reset_btn.click(
-                        reset_configuration,
-                        outputs=[edit_name, edit_description, edit_system_prompt, edit_model, edit_temperature, edit_max_tokens, edit_examples, config_status]
+                else:
+                    return (
+                        gr.update(visible=True),   # Keep access panel visible
+                        gr.update(visible=False),  # Keep main panel hidden
+                        gr.update(value="❌ Invalid access code. Please try again."),  # Status message
+                        False  # State remains false
                     )
-                    
-                    # Show config lock status
-                    if config.get('locked', False):
-                        gr.Markdown("🔒 **Configuration is locked**")
-        
-        return demo
+            
+            access_btn.click(
+                handle_access,
+                inputs=[access_input, access_granted],
+                outputs=[access_panel, main_panel, access_status, access_granted]
+            )
+            
+            access_input.submit(
+                handle_access,
+                inputs=[access_input, access_granted],
+                outputs=[access_panel, main_panel, access_status, access_granted]
+            )
+    
+    return demo
 
 
-# Main execution
+# Create and launch the interface
 if __name__ == "__main__":
-    print("===== Application Startup at", datetime.now().strftime('%Y-%m-%d %H:%M:%S'), "=====")
     demo = create_interface()
-    demo.launch(
-        share=False,
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
-    )
+    demo.launch()

config.json

@@ -1,7 +1,7 @@
 {
   "name": "STEM Adventure Games",
-  "description": "Interactive STEM adventure game guide",
-  "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.",
+  "description": "Interactive STEM adventure game guidehhhhhhhhhhhhhhh",
+  "system_prompt": "Simulate an interactive game-based learning experience through Choose Your Own STEM Adventure games featuring historically significant scientific experiments. Open each session with an unicode-styled arcade menu that reads 'STEM_ADV_GAMES` one stacked on top of the other. Underneath, frame the game in two sentences and widely sample 3-4 optional adventures from Wikipedia's List of Experiments. In the first stage, be brief and incrementally build more narrative content into the chat, 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. Each section has 4 numbered decision points per stage that reflect experimental choices that subtly demonstrate a facet of the scientific method, with each choice meaningfully distinct in affording paths forward. Always end scenes with new branching choices that build a narrative progression based on concrete experimental procedures in laboratory environments. Offer 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. Goal: Teach scientific thinking through interactive historical moments where students make experimental design decisions.",
   "model": "google/gemini-2.0-flash-001",
   "api_key_var": "API_KEY",
   "temperature": 0.6,
@@ -22,5 +22,5 @@
   ],
   "enable_dynamic_urls": true,
   "enable_file_upload": true,
-  "theme": "Default"
+  "theme": "Glass"
 }