Update research assistant prompt to be more realistic and accessible

app.py

@@ -145,6 +145,7 @@ GROUNDING_URLS = {grounding_urls}
 ACCESS_CODE = os.environ.get("SPACE_ACCESS_CODE", "{access_code}")
 ENABLE_DYNAMIC_URLS = {enable_dynamic_urls}
 ENABLE_VECTOR_RAG = {enable_vector_rag}
+ENABLE_WEB_SEARCH = {enable_web_search}
 RAG_DATA = {rag_data_json}
 
 # Get API key from environment - customizable variable name with validation
@@ -167,7 +168,7 @@ def validate_api_key():
     elif not API_KEY.startswith('sk-or-'):
         print(f"⚠️  API KEY FORMAT WARNING:")
         print(f"   Variable name: {api_key_var}")
-        print(f"   Current value: {API_KEY[:10]}..." if len(API_KEY) > 10 else API_KEY)
+        print(f"   Current value: {{{{API_KEY[:10]}}}}..." if len(API_KEY) > 10 else API_KEY)
         print(f"   Expected format: sk-or-xxxxxxxxxx")
         print(f"   Note: OpenRouter keys should start with 'sk-or-'")
         return True  # Still try to use it
@@ -207,6 +208,12 @@ def fetch_url_content(url):
     except Exception as e:
         return f"Error fetching {{url}}: {{str(e)}}"
 
+def extract_urls_from_text(text):
+    """Extract URLs from text using regex"""
+    import re
+    url_pattern = r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
+    return re.findall(url_pattern, text)
+
 # Global cache for URL content to avoid re-crawling in generated spaces
 _url_content_cache = {{}}
 
@@ -327,6 +334,128 @@ def generate_response(message, history):
             if dynamic_context_parts:
                 grounding_context += "\\n".join(dynamic_context_parts)
     
+    # If web search is enabled, use it for most queries (excluding code blocks and URLs)
+    if ENABLE_WEB_SEARCH:
+        should_search = True
+        
+        # Skip search for messages that are primarily code blocks
+        import re
+        if re.search(r'```[\\s\\S]*```', message):
+            should_search = False
+        
+        # Skip search for messages that are primarily URLs
+        urls_in_message = extract_urls_from_text(message)
+        if urls_in_message and len(' '.join(urls_in_message)) > len(message) * 0.5:
+            should_search = False
+        
+        # Skip search for very short messages (likely greetings)
+        if len(message.strip()) < 5:
+            should_search = False
+        
+        if should_search:
+            # Use the entire message as search query, cleaning it up
+            search_query = message.strip()
+            try:
+                # Perform web search using crawl4ai
+                import urllib.parse
+                import asyncio
+                
+                async def search_with_crawl4ai(search_query):
+                    try:
+                        from crawl4ai import WebCrawler
+                        
+                        # Create search URL for DuckDuckGo
+                        encoded_query = urllib.parse.quote_plus(search_query)
+                        search_url = f"https://duckduckgo.com/html/?q={{encoded_query}}"
+                        
+                        # Initialize crawler
+                        crawler = WebCrawler(verbose=False)
+                        
+                        try:
+                            # Start the crawler
+                            await crawler.astart()
+                            
+                            # Crawl the search results
+                            result = await crawler.arun(url=search_url)
+                            
+                            if result.success:
+                                # Extract text content from search results
+                                content = result.cleaned_html if result.cleaned_html else result.markdown
+                                
+                                # Clean and truncate the content
+                                if content:
+                                    # Remove excessive whitespace and limit length
+                                    lines = [line.strip() for line in content.split('\\n') if line.strip()]
+                                    cleaned_content = '\\n'.join(lines)
+                                    
+                                    # Truncate to reasonable length for context
+                                    if len(cleaned_content) > 2000:
+                                        cleaned_content = cleaned_content[:2000] + "..."
+                                    
+                                    return cleaned_content
+                                else:
+                                    return "No content extracted from search results"
+                            else:
+                                return f"Search failed: {{result.error_message if hasattr(result, 'error_message') else 'Unknown error'}}"
+                                
+                        finally:
+                            # Clean up the crawler
+                            await crawler.aclose()
+                            
+                    except ImportError:
+                        # Fallback to simple DuckDuckGo search without crawl4ai
+                        encoded_query = urllib.parse.quote_plus(search_query)
+                        search_url = f"https://duckduckgo.com/html/?q={{encoded_query}}"
+                        
+                        # Use basic fetch as fallback
+                        response = requests.get(search_url, headers={{'User-Agent': 'Mozilla/5.0'}}, timeout=10)
+                        if response.status_code == 200:
+                            from bs4 import BeautifulSoup
+                            soup = BeautifulSoup(response.content, 'html.parser')
+                            
+                            # Remove script and style elements
+                            for script in soup(["script", "style", "nav", "header", "footer"]):
+                                script.decompose()
+                            
+                            # Get text content
+                            text = soup.get_text()
+                            
+                            # Clean up whitespace
+                            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)
+                            
+                            # Truncate to ~2000 characters
+                            if len(text) > 2000:
+                                text = text[:2000] + "..."
+                            
+                            return text
+                        else:
+                            return f"Failed to fetch search results: {{response.status_code}}"
+                
+                # Run the async search
+                if hasattr(asyncio, 'run'):
+                    search_result = asyncio.run(search_with_crawl4ai(search_query))
+                else:
+                    # Fallback for older Python versions
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    try:
+                        search_result = loop.run_until_complete(search_with_crawl4ai(search_query))
+                    finally:
+                        loop.close()
+                
+                grounding_context += f"\\n\\nWeb search results for '{{search_query}}':\\n{{search_result}}"
+            except Exception as e:
+                # Fallback to URL extraction if web search fails
+                urls = extract_urls_from_text(search_query)
+                if urls:
+                    for url in urls[:2]:  # Limit to 2 URLs for fallback
+                        content = fetch_url_content(url)
+                        grounding_context += f"\\n\\nFallback content from {{url}}:\\n{{content[:500]}}..."
+                else:
+                    grounding_context += f"\\n\\nWeb search requested: {{search_query}} (external search not available)"
+    
     # Build enhanced system prompt with grounding context
     enhanced_system_prompt = SYSTEM_PROMPT + grounding_context
     
@@ -507,6 +636,9 @@ def get_configuration_status():
     if ENABLE_DYNAMIC_URLS:
         status_parts.append("🔄 **Dynamic URLs:** Enabled")
     
+    if ENABLE_WEB_SEARCH:
+        status_parts.append("🔍 **Web Search:** Enabled")
+    
     if ENABLE_VECTOR_RAG:
         status_parts.append("📚 **Document RAG:** Enabled")
     
@@ -722,19 +854,19 @@ Generated on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} with Chat U/I Helper
     
     return readme_content
 
-def create_requirements(enable_vector_rag=False, enable_code_execution=False):
+def create_requirements(enable_vector_rag=False, enable_web_search=False):
     """Generate requirements.txt"""
     base_requirements = "gradio>=5.35.0\nrequests>=2.32.3\nbeautifulsoup4>=4.12.3"
     
     if enable_vector_rag:
         base_requirements += "\nfaiss-cpu==1.7.4\nnumpy==1.24.3"
     
-    if enable_code_execution:
-        base_requirements += "\ngradio_client>=0.15.0"
+    if enable_web_search:
+        base_requirements += "\ncrawl4ai>=0.2.0\naiohttp>=3.8.0"
     
     return base_requirements
 
-def generate_zip(name, description, system_prompt, model, api_key_var, temperature, max_tokens, examples_text, access_code="", enable_dynamic_urls=False, url1="", url2="", url3="", url4="", enable_vector_rag=False, rag_data=None, enable_code_execution=False):
+def generate_zip(name, description, system_prompt, model, api_key_var, temperature, max_tokens, examples_text, access_code="", enable_dynamic_urls=False, url1="", url2="", url3="", url4="", enable_vector_rag=False, rag_data=None, enable_web_search=False):
     """Generate deployable zip file"""
     
     # Process examples
@@ -770,6 +902,7 @@ def generate_zip(name, description, system_prompt, model, api_key_var, temperatu
         'access_code': "",  # Access code stored in environment variable for security
         'enable_dynamic_urls': enable_dynamic_urls,
         'enable_vector_rag': enable_vector_rag,
+        'enable_web_search': enable_web_search,
         'rag_data_json': json.dumps(rag_data) if rag_data else 'None'
     }
     
@@ -779,7 +912,7 @@ def generate_zip(name, description, system_prompt, model, api_key_var, temperatu
     readme_config = config.copy()
     readme_config['access_code'] = access_code or ""
     readme_content = create_readme(readme_config)
-    requirements_content = create_requirements(enable_vector_rag, enable_code_execution)
+    requirements_content = create_requirements(enable_vector_rag, enable_web_search)
     
     # Create zip file with clean naming
     filename = f"{name.lower().replace(' ', '_').replace('-', '_')}.zip"
@@ -895,7 +1028,7 @@ def update_sandbox_preview(config_data):
     
     return preview_text, preview_html
 
-def on_preview_combined(name, description, system_prompt, enable_research_assistant, model, temperature, max_tokens, examples_text, enable_dynamic_urls, enable_vector_rag, enable_code_execution, enable_web_search):
+def on_preview_combined(name, description, system_prompt, enable_research_assistant, model, temperature, max_tokens, examples_text, enable_dynamic_urls, enable_vector_rag, enable_web_search):
     """Generate configuration and return preview updates"""
     if not name or not name.strip():
         return (
@@ -927,7 +1060,6 @@ def on_preview_combined(name, description, system_prompt, enable_research_assist
             'max_tokens': max_tokens,
             'enable_dynamic_urls': enable_dynamic_urls,
             'enable_vector_rag': enable_vector_rag,
-            'enable_code_execution': enable_code_execution,
             'enable_web_search': enable_web_search,
             'examples_text': examples_text,
             'preview_ready': True
@@ -944,6 +1076,7 @@ Your assistant "{name}" is now configured and ready to test in the Sandbox Previ
 - **Max Tokens:** {max_tokens}
 - **Dynamic URLs:** {'✅ Enabled' if enable_dynamic_urls else '❌ Disabled'}
 - **Vector RAG:** {'✅ Enabled' if enable_vector_rag else '❌ Disabled'}
+- **Web Search:** {'✅ Enabled' if enable_web_search else '❌ Disabled'}
 
 **System Prompt:** 
 {final_system_prompt[:200]}{'...' if len(final_system_prompt) > 200 else ''}
@@ -964,6 +1097,7 @@ Your assistant "{name}" is now configured and ready to test in the Sandbox Previ
 **Features:**
 - **Dynamic URL Fetching:** {'✅ Enabled' if enable_dynamic_urls else '❌ Disabled'}
 - **Document RAG:** {'✅ Enabled' if enable_vector_rag else '❌ Disabled'}
+- **Web Search:** {'✅ Enabled' if enable_web_search else '❌ Disabled'}
 
 **System Prompt:**
 ```
@@ -1053,8 +1187,26 @@ def preview_chat_response(message, history, config_data, url1="", url2="", url3=
     api_key = os.environ.get("OPENROUTER_API_KEY")
     
     if not api_key:
-        response = f"[Preview Mode - No API Key] I'm {config_data.get('name', 'your assistant')} running on {config_data.get('model', 'unknown model')}. To test with real API responses, set your OPENROUTER_API_KEY in the environment. This preview would use your system prompt: {config_data.get('system_prompt', '')[:100]}..."
-        history.append([message, response])
+        response = f"""🔑 **API Key Required for Preview**
+
+To test your assistant with real API responses, please:
+
+1. Get your OpenRouter API key from: https://openrouter.ai/keys
+2. Set it as an environment variable: `export OPENROUTER_API_KEY=your_key_here`
+3. Or add it to your `.env` file: `OPENROUTER_API_KEY=your_key_here`
+
+**Your Configuration:**
+- **Name:** {config_data.get('name', 'your assistant')}
+- **Model:** {config_data.get('model', 'unknown model')}
+- **Temperature:** {config_data.get('temperature', 0.7)}
+- **Max Tokens:** {config_data.get('max_tokens', 500)}
+
+**System Prompt Preview:**
+{config_data.get('system_prompt', '')[:200]}{'...' if len(config_data.get('system_prompt', '')) > 200 else ''}
+
+Once you set your API key, you'll be able to test real conversations in this preview."""
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": response})
         return "", history
     
     try:
@@ -1082,59 +1234,40 @@ def preview_chat_response(message, history, config_data, url1="", url2="", url3=
         # Check for web search request if enabled
         web_search_result = ""
         if config_data.get('enable_web_search'):
-            # Simple patterns to detect search requests
-            search_patterns = [
-                r'search for\s+(.+)',
-                r'find\s+(.+)',
-                r'look up\s+(.+)',
-                r'what is\s+(.+)',
-                r'who is\s+(.+)',
-                r'how to\s+(.+)',
-                r'latest\s+(.+)',
-                r'recent\s+(.+)'
-            ]
+            # If web search is enabled, use it for most queries (excluding code blocks and URLs)
+            should_search = True
             
-            for pattern in search_patterns:
-                match = re.search(pattern, message, re.IGNORECASE)
-                if match:
-                    search_query = match.group(1).strip()
-                    search_result = perform_web_search(search_query, "Web search requested")
-                    web_search_result = f"\n\n{search_result}\n\n"
-                    break
-        
-        # Check for code execution request if enabled
-        code_execution_result = ""
-        if config_data.get('enable_code_execution'):
-            # Simple pattern to detect code execution requests
-            code_patterns = [
-                r'```python\n(.*?)\n```',
-                r'```\n(.*?)\n```',
-                r'from\s+\w+\s+import|import\s+\w+',
-                r'def\s+\w+\s*\(',
-                r'print\s*\(',
-                r'for\s+\w+\s+in\s+',
-                r'if\s+.*:'
-            ]
+            # Skip search for messages that are primarily code blocks
+            if re.search(r'```[\s\S]*```', message):
+                should_search = False
+            
+            # Skip search for messages that are primarily URLs
+            urls_in_message = extract_urls_from_text(message)
+            if urls_in_message and len(' '.join(urls_in_message)) > len(message) * 0.5:
+                should_search = False
             
-            for pattern in code_patterns:
-                if re.search(pattern, message, re.DOTALL | re.IGNORECASE):
-                    # Extract code from code blocks
-                    code_match = re.search(r'```(?:python)?\n(.*?)\n```', message, re.DOTALL)
-                    if code_match:
-                        code_to_execute = code_match.group(1)
-                        execution_result = execute_python_code(code_to_execute, "Code execution requested")
-                        code_execution_result = f"\n\n{execution_result}\n\n"
-                    break
+            # Skip search for very short messages (likely greetings)
+            if len(message.strip()) < 5:
+                should_search = False
+            
+            if should_search:
+                # Use the entire message as search query, cleaning it up
+                search_query = message.strip()
+                search_result = perform_web_search(search_query, "Web search requested")
+                web_search_result = f"\n\n{search_result}\n\n"
         
         # Build enhanced system prompt with all contexts
-        enhanced_system_prompt = config_data.get('system_prompt', '') + grounding_context + rag_context + dynamic_context + web_search_result + code_execution_result
+        enhanced_system_prompt = config_data.get('system_prompt', '') + grounding_context + rag_context + dynamic_context + web_search_result
         
         # Build messages array for the API
         messages = [{"role": "system", "content": enhanced_system_prompt}]
         
-        # Add conversation history - handle both formats
+        # Add conversation history - handle both formats for backwards compatibility
         for chat in history:
-            if isinstance(chat, list) and len(chat) >= 2:
+            if isinstance(chat, dict):
+                # New format: {"role": "user", "content": "..."}
+                messages.append(chat)
+            elif isinstance(chat, list) and len(chat) >= 2:
                 # Legacy format: [user_msg, assistant_msg]
                 user_msg, assistant_msg = chat[0], chat[1]
                 if user_msg:
@@ -1183,8 +1316,8 @@ def preview_chat_response(message, history, config_data, url1="", url2="", url3=
                     if not assistant_content or assistant_content.strip() == "":
                         assistant_response = f"[Preview Debug] Empty content from API. Messages sent: {len(messages)} messages, last user message: '{message}', model: {request_payload['model']}"
                     else:
-                        # Add preview indicator
-                        assistant_response = f"[Preview Mode] {assistant_content}"
+                        # Use the content directly - no preview indicator needed
+                        assistant_response = assistant_content
                         
             except (KeyError, IndexError, json.JSONDecodeError) as e:
                 assistant_response = f"[Preview Error] Failed to parse API response: {str(e)}. Raw response: {response.text[:500]}"
@@ -1194,8 +1327,9 @@ def preview_chat_response(message, history, config_data, url1="", url2="", url3=
     except Exception as e:
         assistant_response = f"[Preview Error] {str(e)}"
     
-    # Return in the legacy tuple format that Gradio ChatInterface expects
-    history.append([message, assistant_response])
+    # Return in the new messages format for Gradio 5.x
+    history.append({"role": "user", "content": message})
+    history.append({"role": "assistant", "content": assistant_response})
     return "", history
 
 def clear_preview_chat():
@@ -1217,9 +1351,9 @@ def export_preview_conversation(history):
     
     return gr.update(value=temp_file, visible=True)
 
-def on_generate(name, description, system_prompt, enable_research_assistant, model, api_key_var, temperature, max_tokens, examples_text, access_code, enable_dynamic_urls, url1, url2, url3, url4, enable_vector_rag, rag_tool_state, enable_code_execution, enable_web_search):
+def on_generate(name, description, system_prompt, enable_research_assistant, model, api_key_var, temperature, max_tokens, examples_text, access_code, enable_dynamic_urls, url1, url2, url3, url4, enable_vector_rag, rag_tool_state, enable_web_search):
     if not name or not name.strip():
-        return gr.update(value="Error: Please provide a Space Title", visible=True), gr.update(visible=False)
+        return gr.update(value="Error: Please provide a Space Title", visible=True), gr.update(visible=False), {}
     
     
     try:
@@ -1230,11 +1364,11 @@ def on_generate(name, description, system_prompt, enable_research_assistant, mod
         
         # Use the system prompt directly (research assistant toggle already updates it)
         if not system_prompt or not system_prompt.strip():
-            return gr.update(value="Error: Please provide a System Prompt for the assistant", visible=True), gr.update(visible=False)
+            return gr.update(value="Error: Please provide a System Prompt for the assistant", visible=True), gr.update(visible=False), {}
         
         final_system_prompt = system_prompt.strip()
         
-        filename = generate_zip(name, description, final_system_prompt, model, api_key_var, temperature, max_tokens, examples_text, access_code, enable_dynamic_urls, url1, url2, url3, url4, enable_vector_rag, rag_data, enable_code_execution)
+        filename = generate_zip(name, description, final_system_prompt, model, api_key_var, temperature, max_tokens, examples_text, access_code, enable_dynamic_urls, url1, url2, url3, url4, enable_vector_rag, rag_data, enable_web_search)
         
         success_msg = f"""**Deployment package ready!**
 
@@ -1263,13 +1397,14 @@ def on_generate(name, description, system_prompt, enable_research_assistant, mod
             'max_tokens': max_tokens,
             'enable_dynamic_urls': enable_dynamic_urls,
             'enable_vector_rag': enable_vector_rag,
+            'enable_web_search': enable_web_search,
             'filename': filename
         }
         
         return gr.update(value=success_msg, visible=True), gr.update(value=filename, visible=True), config_data
         
     except Exception as e:
-        return gr.update(value=f"Error: {str(e)}", visible=True), gr.update(visible=False)
+        return gr.update(value=f"Error: {str(e)}", visible=True), gr.update(visible=False), {}
 
 # Global cache for URL content to avoid re-crawling
 url_content_cache = {}
@@ -1446,34 +1581,86 @@ def remove_chat_urls(count):
         return (gr.update(), gr.update(), gr.update(), gr.update(), count)
 
 
-def toggle_code_execution(enable_code):
-    """Toggle visibility of code execution space field"""
-    return gr.update(visible=enable_code)
+# Code execution toggle removed - functionality no longer supported
 
 def toggle_web_search(enable_search):
     """Toggle visibility of web search space field"""
     return gr.update(visible=enable_search)
 
 def perform_web_search(query, description="Web search"):
-    """Perform web search using HuggingFace Space"""
+    """Perform web search using crawl4ai with DuckDuckGo"""
     try:
-        from gradio_client import Client
-        
-        # Try to connect to a web search space (you can change this to any search space)
-        client = Client("huggingface-projects/web-search")
-        
-        # Submit the search query
-        result = client.predict(
-            query,
-            api_name="/predict"
-        )
-        
-        return f"**{description}**\n\nQuery: {query}\n\n**Search Results:**\n{result}"
-        
-    except ImportError:
-        return f"**Web Search Error:** gradio_client not installed. Install with: `pip install gradio_client`"
+        # Try to use crawl4ai for web search
+        try:
+            from crawl4ai import WebCrawler
+            import asyncio
+            
+            async def search_with_crawl4ai(search_query):
+                # Create search URL for DuckDuckGo
+                import urllib.parse
+                encoded_query = urllib.parse.quote_plus(search_query)
+                search_url = f"https://duckduckgo.com/html/?q={encoded_query}"
+                
+                # Initialize crawler
+                crawler = WebCrawler(verbose=False)
+                
+                try:
+                    # Start the crawler
+                    await crawler.astart()
+                    
+                    # Crawl the search results
+                    result = await crawler.arun(url=search_url)
+                    
+                    if result.success:
+                        # Extract text content from search results
+                        content = result.cleaned_html if result.cleaned_html else result.markdown
+                        
+                        # Clean and truncate the content
+                        if content:
+                            # Remove excessive whitespace and limit length
+                            lines = [line.strip() for line in content.split('\n') if line.strip()]
+                            cleaned_content = '\n'.join(lines)
+                            
+                            # Truncate to reasonable length for context
+                            if len(cleaned_content) > 3000:
+                                cleaned_content = cleaned_content[:3000] + "..."
+                            
+                            return cleaned_content
+                        else:
+                            return "No content extracted from search results"
+                    else:
+                        return f"Search failed: {result.error_message if hasattr(result, 'error_message') else 'Unknown error'}"
+                        
+                finally:
+                    # Clean up the crawler
+                    await crawler.aclose()
+            
+            # Run the async search
+            if hasattr(asyncio, 'run'):
+                search_result = asyncio.run(search_with_crawl4ai(query))
+            else:
+                # Fallback for older Python versions
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    search_result = loop.run_until_complete(search_with_crawl4ai(query))
+                finally:
+                    loop.close()
+            
+            return f"**{description}**\n\nQuery: {query}\n\n**Search Results:**\n{search_result}"
+            
+        except ImportError:
+            # Fallback to simple DuckDuckGo search without crawl4ai
+            import urllib.parse
+            encoded_query = urllib.parse.quote_plus(query)
+            search_url = f"https://duckduckgo.com/html/?q={encoded_query}"
+            
+            # Use enhanced_fetch_url_content as fallback
+            content = enhanced_fetch_url_content(search_url)
+            return f"**{description} (Simplified)**\n\nQuery: {query}\n\n**Search Results:**\n{content}"
+            
     except Exception as e:
-        # Fallback to simple URL extraction and fetching
+        # Final fallback to URL extraction if search fails
         urls = extract_urls_from_text(query)
         if urls:
             results = []
@@ -1483,31 +1670,12 @@ def perform_web_search(query, description="Web search"):
             return f"**Web Search Fallback:** {description}\n\n" + "\n\n".join(results)
         return f"**Web Search Error:** {str(e)}\n\nQuery: {query}"
 
-def execute_python_code(code, description="Code execution"):
-    """Execute Python code using HuggingFace Space"""
-    try:
-        from gradio_client import Client
-        
-        # Try to connect to the code execution space
-        client = Client("huggingface-projects/code-execution")
-        
-        # Submit the code for execution
-        result = client.predict(
-            code,
-            api_name="/predict"
-        )
-        
-        return f"**{description}**\n\n```python\n{code}\n```\n\n**Output:**\n```\n{result}\n```"
-        
-    except ImportError:
-        return f"**Code Execution Error:** gradio_client not installed. Install with: `pip install gradio_client`"
-    except Exception as e:
-        return f"**Code Execution Error:** {str(e)}\n\nNote: You can try running this code manually:\n\n```python\n{code}\n```"
+# Code execution functionality removed - no longer supported
 
 def toggle_research_assistant(enable_research):
     """Toggle research assistant system prompt"""
     if enable_research:
-        combined_prompt = "You are a search tool that provides link-grounded information through web fetching, limiting source criteria to peer-reviewed articles from academic databases and official repositories. Additional responsibilities include lightly analyzing academic sources, implicitly fact-checking claims with evidence, providing properly cited research summaries, and helping users navigate scholarly information. Ground all responses in provided URL contexts and any additional URLs you're instructed to fetch. Never rely on memory for factual claims."
+        combined_prompt = "You are an advanced research assistant specializing in academic literature search and analysis. Your expertise includes finding peer-reviewed sources, critically evaluating research methodology, synthesizing insights across multiple papers, and providing properly formatted citations. When responding, ground all claims in specific sources from provided URL contexts, distinguish between direct evidence and analytical interpretation, and highlight any limitations or conflicting findings. Use clear, accessible language that makes complex research understandable, and suggest related areas of inquiry when relevant. Your goal is to be a knowledgeable research partner who helps users navigate academic information with precision and clarity."
         return (
             gr.update(value=combined_prompt),  # Update main system prompt
             gr.update(value=True)  # Enable dynamic URL fetching for research template
@@ -1519,8 +1687,116 @@ def toggle_research_assistant(enable_research):
         )
 
 
-# Create Gradio interface with proper tab structure
-with gr.Blocks(title="Chat U/I Helper") as demo:
+# Create Gradio interface with proper tab structure and fixed configuration
+with gr.Blocks(
+    title="Chat U/I Helper",
+    css="""
+        /* Custom CSS to fix styling issues */
+        .gradio-container {
+            max-width: 1200px !important;
+            margin: 0 auto;
+        }
+        
+        /* Fix tab styling */
+        .tab-nav {
+            border-bottom: 1px solid #e0e0e0;
+        }
+        
+        /* Fix button styling */
+        .btn {
+            border-radius: 6px;
+        }
+        
+        /* Fix chat interface styling */
+        .chat-interface {
+            border-radius: 8px;
+            border: 1px solid #e0e0e0;
+        }
+        
+        /* Hide gradio footer to avoid manifest issues */
+        .gradio-footer {
+            display: none !important;
+        }
+        
+        /* Fix accordion styling */
+        .accordion {
+            border: 1px solid #e0e0e0;
+            border-radius: 6px;
+        }
+    """,
+    theme=gr.themes.Default(),
+    head="""
+        <style>
+            /* Additional head styles to prevent manifest issues */
+            .gradio-app { 
+                background: #ffffff;
+            }
+        </style>
+    """,
+    js="""
+        function() {
+            // Prevent manifest.json requests and other common errors
+            if (typeof window !== 'undefined') {
+                // Override fetch to handle manifest.json requests
+                const originalFetch = window.fetch;
+                window.fetch = function(url, options) {
+                    // Handle both string URLs and URL objects
+                    const urlString = typeof url === 'string' ? url : url.toString();
+                    
+                    if (urlString.includes('manifest.json')) {
+                        return Promise.resolve(new Response('{}', { 
+                            status: 200,
+                            headers: { 'Content-Type': 'application/json' }
+                        }));
+                    }
+                    
+                    // Handle favicon requests
+                    if (urlString.includes('favicon.ico')) {
+                        return Promise.resolve(new Response('', { status: 204 }));
+                    }
+                    
+                    return originalFetch.apply(this, arguments);
+                };
+                
+                // Prevent postMessage origin errors
+                window.addEventListener('message', function(event) {
+                    try {
+                        if (event.origin && event.origin !== window.location.origin) {
+                            event.stopImmediatePropagation();
+                            return false;
+                        }
+                    } catch (e) {
+                        // Silently ignore origin check errors
+                    }
+                }, true);
+                
+                // Prevent console errors from missing resources
+                window.addEventListener('error', function(e) {
+                    if (e.target && e.target.src) {
+                        const src = e.target.src;
+                        if (src.includes('manifest.json') || src.includes('favicon.ico')) {
+                            e.preventDefault();
+                            return false;
+                        }
+                    }
+                }, true);
+                
+                // Override console.error to filter out known harmless errors
+                const originalConsoleError = console.error;
+                console.error = function(...args) {
+                    const message = args.join(' ');
+                    if (message.includes('manifest.json') || 
+                        message.includes('favicon.ico') ||
+                        message.includes('postMessage') ||
+                        message.includes('target origin')) {
+                        return; // Suppress these specific errors
+                    }
+                    originalConsoleError.apply(console, arguments);
+                };
+            }
+        }
+    """
+) as demo:
     # Global state for cross-tab functionality
     sandbox_state = gr.State({})
     preview_config_state = gr.State({})
@@ -1597,18 +1873,6 @@ with gr.Blocks(title="Chat U/I Helper") as demo:
                     )
                 
                 with gr.Accordion("Tool Settings", open=True):
-                    enable_code_execution = gr.Checkbox(
-                        label="Enable Code Execution",
-                        value=False,
-                        info="Allow the assistant to execute Python code via external HuggingFace Space"
-                    )
-                    
-                    code_execution_space = gr.Textbox(
-                        label="Code Execution Space",
-                        value="huggingface-projects/code-execution",
-                        info="HuggingFace Space for Python code execution",
-                        visible=False
-                    )
 
                     enable_dynamic_urls = gr.Checkbox(
                         label="Enable Dynamic URL Fetching",
@@ -1620,14 +1884,15 @@ with gr.Blocks(title="Chat U/I Helper") as demo:
                     enable_web_search = gr.Checkbox(
                         label="Enable Web Search",
                         value=False,
-                        info="Allow the assistant to search the web using external HuggingFace Space"
+                        info="Allow the assistant to search the web using crawl4ai"
                     )
                     
                     web_search_space = gr.Textbox(
-                        label="Web Search Space",
-                        value="huggingface-projects/web-search",
-                        info="HuggingFace Space for web search functionality",
-                        visible=False
+                        label="Web Search Technology",
+                        value="crawl4ai",
+                        info="Uses crawl4ai library for web crawling",
+                        visible=False,
+                        interactive=False
                     )
                     
                     enable_vector_rag = gr.Checkbox(
@@ -1722,13 +1987,6 @@ with gr.Blocks(title="Chat U/I Helper") as demo:
                 outputs=[system_prompt, enable_dynamic_urls]
             )
             
-            # Connect the code execution checkbox
-            enable_code_execution.change(
-                toggle_code_execution,
-                inputs=[enable_code_execution],
-                outputs=[code_execution_space]
-            )
-            
             # Connect the web search checkbox
             enable_web_search.change(
                 toggle_web_search,
@@ -1768,7 +2026,7 @@ with gr.Blocks(title="Chat U/I Helper") as demo:
             # Connect the generate button
             generate_btn.click(
                 on_generate,
-                inputs=[name, description, system_prompt, enable_research_assistant, model, api_key_var, temperature, max_tokens, examples_text, access_code, enable_dynamic_urls, url1, url2, url3, url4, enable_vector_rag, rag_tool_state, enable_code_execution, enable_web_search],
+                inputs=[name, description, system_prompt, enable_research_assistant, model, api_key_var, temperature, max_tokens, examples_text, access_code, enable_dynamic_urls, url1, url2, url3, url4, enable_vector_rag, rag_tool_state, enable_web_search],
                 outputs=[status, download_file, sandbox_state]
             )
             
@@ -1786,7 +2044,8 @@ with gr.Blocks(title="Chat U/I Helper") as demo:
                     preview_chatbot = gr.Chatbot(
                         value=[],
                         label="Preview Chat Interface", 
-                        height=400
+                        height=400,
+                        type="messages"  # Use the new messages format
                     )
                     preview_msg = gr.Textbox(
                         label="Test your assistant",
@@ -1886,13 +2145,44 @@ with gr.Blocks(title="Chat U/I Helper") as demo:
     # Connect cross-tab functionality after all components are defined
     preview_btn.click(
         on_preview_combined,
-        inputs=[name, description, system_prompt, enable_research_assistant, model, temperature, max_tokens, examples_text, enable_dynamic_urls, enable_vector_rag, enable_code_execution, enable_web_search],
+        inputs=[name, description, system_prompt, enable_research_assistant, model, temperature, max_tokens, examples_text, enable_dynamic_urls, enable_vector_rag, enable_web_search],
         outputs=[preview_config_state, preview_status_comp, preview_chat_section_comp, config_display_comp]
     )
 
 if __name__ == "__main__":
-    # Check if running in local development with dev tunnels
-    if os.environ.get('CODESPACES') or 'devtunnels.ms' in os.environ.get('GRADIO_SERVER_NAME', ''):
-        demo.launch(share=True, allowed_paths=[], server_name="0.0.0.0")
-    else:
-        demo.launch(share=True)
+    # Configure launch parameters to avoid common development issues
+    launch_kwargs = {
+        "server_name": "127.0.0.1",  # Use localhost instead of 0.0.0.0
+        "server_port": 7860,
+        "share": False,  # Disable sharing to avoid origin issues
+        "debug": False,  # Disable debug mode to reduce console errors
+        "show_error": True,  # Show errors in interface
+        "quiet": False,  # Keep logging for debugging
+        "favicon_path": None,  # Disable favicon to avoid 404s
+        "ssl_verify": False,  # Disable SSL verification for local development
+        "allowed_paths": [],  # Empty allowed paths
+        "blocked_paths": [],  # Empty blocked paths
+        "root_path": None,  # No root path
+        "app_kwargs": {
+            "docs_url": None,  # Disable docs endpoint
+            "redoc_url": None,  # Disable redoc endpoint
+        }
+    }
+    
+    # Override settings for specific environments
+    if os.environ.get('CODESPACES'):
+        launch_kwargs.update({
+            "server_name": "0.0.0.0",
+            "share": True
+        })
+    elif 'devtunnels.ms' in os.environ.get('GRADIO_SERVER_NAME', ''):
+        launch_kwargs.update({
+            "server_name": "0.0.0.0",
+            "share": True
+        })
+    
+    print("🚀 Starting Chat UI Helper...")
+    print(f"📍 Server: {launch_kwargs['server_name']}:{launch_kwargs['server_port']}")
+    print(f"🔗 Share: {launch_kwargs['share']}")
+    
+    demo.launch(**launch_kwargs)