Update app.py

app.py

@@ -33,21 +33,21 @@ def validate_api_key():
     """Validate API key configuration with detailed logging"""
     if not API_KEY:
         print(f"⚠️  API KEY CONFIGURATION ERROR:")
-        print(f"   Variable name: {api_key_var}")
+        print(f"   Variable name: OPENROUTER_API_KEY")
         print(f"   Status: Not set or empty")
-        print(f"   Action needed: Set '{api_key_var}' in HuggingFace Space secrets")
+        print(f"   Action needed: Set 'OPENROUTER_API_KEY' in HuggingFace Space secrets")
         print(f"   Expected format: sk-or-xxxxxxxxxx")
         return False
     elif not API_KEY.startswith('sk-or-'):
         print(f"⚠️  API KEY FORMAT WARNING:")
-        print(f"   Variable name: {api_key_var}")
+        print(f"   Variable name: OPENROUTER_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
     else:
         print(f"✅ API Key configured successfully")
-        print(f"   Variable: {api_key_var}")
+        print(f"   Variable: OPENROUTER_API_KEY")
         print(f"   Format: Valid OpenRouter key")
         return True
 
@@ -63,79 +63,63 @@ def validate_url_domain(url):
     try:
         from urllib.parse import urlparse
         parsed = urlparse(url)
-        # Check for valid domain structure
-        if parsed.netloc and '.' in parsed.netloc:
-            return True
+        # Allow common domains and exclude potentially dangerous ones
+        allowed_patterns = [
+            'wikipedia.org', 'britannica.com', 'edu', 'gov', 'arxiv.org',
+            'pubmed.ncbi.nlm.nih.gov', 'scholar.google.com', 'researchgate.net'
+        ]
+        return any(pattern in parsed.netloc.lower() for pattern in allowed_patterns)
     except:
-        pass
-    return False
+        return False
 
 def fetch_url_content(url):
-    """Enhanced URL content fetching with improved compatibility and error handling"""
+    """Fetch content from URL with enhanced error handling"""
     if not validate_url_domain(url):
-        return f"Invalid URL format: {url}"
+        return f"URL domain not in allowed list for security: {url}"
     
     try:
-        # Enhanced headers for better compatibility
         headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/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 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
         }
-        
-        response = requests.get(url, timeout=15, headers=headers)
+        response = requests.get(url, headers=headers, timeout=10)
         response.raise_for_status()
-        soup = BeautifulSoup(response.content, 'html.parser')
         
-        # Enhanced content cleaning
-        for element in soup(["script", "style", "nav", "header", "footer", "aside", "form", "button"]):
-            element.decompose()
+        # Parse HTML and extract text
+        soup = BeautifulSoup(response.text, 'html.parser')
         
-        # Extract main content preferentially
-        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()
+        # Remove script and style elements
+        for script in soup(["script", "style"]):
+            script.decompose()
         
-        # Enhanced text cleaning
+        # Get text and clean it up
+        text = soup.get_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)
+        text = ' '.join(chunk for chunk in chunks if chunk)
         
-        # Smart truncation - try to end at sentence boundaries
+        # Limit content length
         if len(text) > 4000:
-            truncated = text[:4000]
-            last_period = truncated.rfind('.')
-            if last_period > 3000:  # If we can find a reasonable sentence break
-                text = truncated[:last_period + 1]
-            else:
-                text = truncated + "..."
-        
-        return text if text.strip() else "No readable content found at this URL"
+            text = text[:4000] + "..."
         
-    except requests.exceptions.Timeout:
-        return f"Timeout error fetching {url} (15s limit exceeded)"
+        return text
     except requests.exceptions.RequestException as e:
         return f"Error fetching {url}: {str(e)}"
     except Exception as e:
-        return f"Error processing content from {url}: {str(e)}"
+        return f"Error processing {url}: {str(e)}"
 
 def extract_urls_from_text(text):
-    """Extract URLs from text using regex with enhanced validation"""
-    import re
-    url_pattern = r'https?://[^\s<>"{}|\\^`\[\]"]+'
+    """Extract URLs from text using regex"""
+    url_pattern = r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
     urls = re.findall(url_pattern, text)
     
-    # Basic URL validation and cleanup
-    validated_urls = []
+    # Filter out URLs that are clearly not useful
+    filtered_urls = []
     for url in urls:
-        # Remove trailing punctuation that might be captured
-        url = url.rstrip('.,!?;:')
-        # Basic domain validation
+        # Basic filtering - must contain a dot and be reasonably long
         if '.' in url and len(url) > 10:
-            validated_urls.append(url)
+            filtered_urls.append(url)
     
-    return validated_urls
+    return filtered_urls
 
 # Global cache for URL content to avoid re-crawling in generated spaces
 _url_content_cache = {}
@@ -174,62 +158,41 @@ def export_conversation_to_markdown(conversation_history):
     
     markdown_content = f"""# Conversation Export
 Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+Space: {SPACE_NAME}
 
 ---
 
 """
     
-    message_pair_count = 0
     for i, message in enumerate(conversation_history):
         if isinstance(message, dict):
-            role = message.get('role', 'unknown')
-            content = message.get('content', '')
+            # New format: {"role": "user", "content": "..."}
+            role = message.get("role", "unknown")
+            content = message.get("content", "")
             
-            if role == 'user':
-                message_pair_count += 1
-                markdown_content += f"## User Message {message_pair_count}\n\n{content}\n\n"
-            elif role == 'assistant':
-                markdown_content += f"## Assistant Response {message_pair_count}\n\n{content}\n\n---\n\n"
+            if role == "user":
+                markdown_content += f"## 👤 User\n\n{content}\n\n"
+            elif role == "assistant":
+                markdown_content += f"## 🤖 Assistant\n\n{content}\n\n"
         elif isinstance(message, (list, tuple)) and len(message) >= 2:
-            # Handle legacy tuple format: ["user msg", "assistant msg"]
-            message_pair_count += 1
+            # Legacy format: [user_msg, assistant_msg]
             user_msg, assistant_msg = message[0], message[1]
             if user_msg:
-                markdown_content += f"## User Message {message_pair_count}\n\n{user_msg}\n\n"
+                markdown_content += f"## 👤 User\n\n{user_msg}\n\n"
             if assistant_msg:
-                markdown_content += f"## Assistant Response {message_pair_count}\n\n{assistant_msg}\n\n---\n\n"
+                markdown_content += f"## 🤖 Assistant\n\n{assistant_msg}\n\n"
+    
+    markdown_content += f"""
+
+---
+
+*Exported from {SPACE_NAME} on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*
+"""
     
     return markdown_content
 
-# Initialize RAG context if enabled
-if ENABLE_VECTOR_RAG and RAG_DATA:
-    try:
-        import faiss
-        import numpy as np
-        import base64
-        
-        class SimpleRAGContext:
-            def __init__(self, rag_data):
-                # Deserialize FAISS index
-                index_bytes = base64.b64decode(rag_data['index_base64'])
-                self.index = faiss.deserialize_index(index_bytes)
-                
-                # Restore chunks and mappings
-                self.chunks = rag_data['chunks']
-                self.chunk_ids = rag_data['chunk_ids']
-            
-            def get_context(self, query, max_chunks=3):
-                """Get relevant context - simplified version"""
-                # In production, you'd compute query embedding here
-                # For now, return a simple message
-                return "\n\n[RAG context would be retrieved here based on similarity search]\n\n"
-        
-        rag_context_provider = SimpleRAGContext(RAG_DATA)
-    except Exception as e:
-        print(f"Failed to initialize RAG: {e}")
-        rag_context_provider = None
-else:
-    rag_context_provider = None
+# Global variable to store chat history for export
+chat_history_store = []
 
 def generate_response(message, history):
     """Generate response using OpenRouter API"""
@@ -240,10 +203,10 @@ def generate_response(message, history):
         error_msg += f"Please configure your OpenRouter API key:\n"
         error_msg += f"1. Go to Settings (⚙️) in your HuggingFace Space\n"
         error_msg += f"2. Click 'Variables and secrets'\n"
-        error_msg += f"3. Add secret: **{api_key_var}**\n"
+        error_msg += f"3. Add secret: **OPENROUTER_API_KEY**\n"
         error_msg += f"4. Value: Your OpenRouter API key (starts with `sk-or-`)\n\n"
         error_msg += f"Get your API key at: https://openrouter.ai/keys"
-        print(f"❌ API request failed: No API key configured for {api_key_var}")
+        print(f"❌ API request failed: No API key configured for OPENROUTER_API_KEY")
         return error_msg
     
     # Get grounding context
@@ -259,9 +222,8 @@ def generate_response(message, history):
     if ENABLE_DYNAMIC_URLS:
         urls_in_message = extract_urls_from_text(message)
         if urls_in_message:
-            # Fetch content from URLs mentioned in the message
             dynamic_context_parts = []
-            for url in urls_in_message[:3]:  # Limit to 3 URLs per message
+            for url in urls_in_message[:2]:  # Limit to 2 URLs to avoid overwhelming context
                 content = fetch_url_content(url)
                 dynamic_context_parts.append(f"\n\nDynamic context from {url}:\n{content}")
             if dynamic_context_parts:
@@ -270,16 +232,19 @@ def generate_response(message, history):
     # Build enhanced system prompt with grounding context
     enhanced_system_prompt = SYSTEM_PROMPT + grounding_context
     
-    # Build messages array for the API
-    messages = [{"role": "system", "content": enhanced_system_prompt}]
+    # Build conversation history for API
+    messages = [{
+        "role": "system", 
+        "content": enhanced_system_prompt
+    }]
     
-    # Add conversation history - handle both modern messages format and legacy tuples
+    # Add conversation history - Support both new messages format and legacy tuple format
     for chat in history:
         if isinstance(chat, dict):
-            # Modern format: {"role": "user", "content": "..."} or {"role": "assistant", "content": "..."}
+            # New format: {"role": "user", "content": "..."}
             messages.append(chat)
         elif isinstance(chat, (list, tuple)) and len(chat) >= 2:
-            # Legacy format: ["user msg", "assistant msg"] or ("user msg", "assistant msg")
+            # Legacy format: ("user msg", "bot msg")
             user_msg, assistant_msg = chat[0], chat[1]
             if user_msg:
                 messages.append({"role": "user", "content": user_msg})
@@ -289,12 +254,8 @@ def generate_response(message, history):
     # Add current message
     messages.append({"role": "user", "content": message})
     
-    # Make API request with enhanced error handling
     try:
-        print(f"🔄 Making API request to OpenRouter...")
-        print(f"   Model: {MODEL}")
-        print(f"   Messages: {len(messages)} in conversation")
-        
+        # Make API request to OpenRouter
         response = requests.post(
             url="https://openrouter.ai/api/v1/chat/completions",
             headers={
@@ -307,38 +268,18 @@ def generate_response(message, history):
                 "model": MODEL,
                 "messages": messages,
                 "temperature": 0.7,
-                "max_tokens": 1500
+                "max_tokens": 1500,
+                "stream": False
             },
             timeout=30
         )
         
-        print(f"📡 API Response: {response.status_code}")
-        
         if response.status_code == 200:
             try:
-                result = response.json()
-                
-                # Enhanced validation of API response structure
-                if 'choices' not in result or not result['choices']:
-                    print(f"⚠️  API response missing choices: {result}")
-                    return "API Error: No response choices available"
-                elif 'message' not in result['choices'][0]:
-                    print(f"⚠️  API response missing message: {result}")
-                    return "API Error: No message in response"
-                elif 'content' not in result['choices'][0]['message']:
-                    print(f"⚠️  API response missing content: {result}")
-                    return "API Error: No content in message"
-                else:
-                    content = result['choices'][0]['message']['content']
-                    
-                    # Check for empty content
-                    if not content or content.strip() == "":
-                        print(f"⚠️  API returned empty content")
-                        return "API Error: Empty response content"
-                    
-                    print(f"✅ API request successful")
-                    return content
-                    
+                response_data = response.json()
+                assistant_response = response_data['choices'][0]['message']['content']
+                print(f"✅ API request successful")
+                return assistant_response
             except (KeyError, IndexError, json.JSONDecodeError) as e:
                 print(f"❌ Failed to parse API response: {str(e)}")
                 return f"API Error: Failed to parse response - {str(e)}"
@@ -346,7 +287,7 @@ def generate_response(message, history):
             error_msg = f"🔐 **Authentication Error**\n\n"
             error_msg += f"Your API key appears to be invalid or expired.\n\n"
             error_msg += f"**Troubleshooting:**\n"
-            error_msg += f"1. Check that your **{OPENROUTER_API_KEY}** is set correctly\n"
+            error_msg += f"1. Check that your **OPENROUTER_API_KEY** secret is set correctly\n"
             error_msg += f"2. Verify your API key at: https://openrouter.ai/keys\n"
             error_msg += f"3. Ensure your key starts with `sk-or-`\n"
             error_msg += f"4. Check that you have credits on your OpenRouter account"
@@ -355,104 +296,64 @@ def generate_response(message, history):
         elif response.status_code == 429:
             error_msg = f"⏱️ **Rate Limit Exceeded**\n\n"
             error_msg += f"Too many requests. Please wait a moment and try again.\n\n"
-            error_msg += f"**Troubleshooting:**\n"
-            error_msg += f"1. Wait 30-60 seconds before trying again\n"
-            error_msg += f"2. Check your OpenRouter usage limits\n"
-            error_msg += f"3. Consider upgrading your OpenRouter plan"
+            error_msg += f"If this persists, check your OpenRouter plan limits."
             print(f"❌ Rate limit exceeded: {response.status_code}")
             return error_msg
-        elif response.status_code == 400:
-            try:
-                error_data = response.json()
-                error_message = error_data.get('error', {}).get('message', 'Unknown error')
-            except:
-                error_message = response.text
-            
-            error_msg = f"⚠️ **Request Error**\n\n"
-            error_msg += f"The API request was invalid:\n"
-            error_msg += f"`{error_message}`\n\n"
-            if "model" in error_message.lower():
-                error_msg += f"**Model Issue:** The model `{MODEL}` may not be available.\n"
-                error_msg += f"Try switching to a different model in your Space configuration."
-            print(f"❌ Bad request: {response.status_code} - {error_message}")
-            return error_msg
         else:
             error_msg = f"🚫 **API Error {response.status_code}**\n\n"
             error_msg += f"An unexpected error occurred. Please try again.\n\n"
-            error_msg += f"If this persists, check:\n"
-            error_msg += f"1. OpenRouter service status\n"
-            error_msg += f"2. Your API key and credits\n"
-            error_msg += f"3. The model availability"
+            error_msg += f"If this persists, the issue may be with the OpenRouter service."
             print(f"❌ API error: {response.status_code} - {response.text[:200]}")
             return error_msg
             
     except requests.exceptions.Timeout:
         error_msg = f"⏰ **Request Timeout**\n\n"
-        error_msg += f"The API request took too long (30s limit).\n\n"
-        error_msg += f"**Troubleshooting:**\n"
-        error_msg += f"1. Try again with a shorter message\n"
-        error_msg += f"2. Check your internet connection\n"
-        error_msg += f"3. Try a different model"
-        print(f"❌ Request timeout after 30 seconds")
+        error_msg += f"The request took too long to complete. Please try again with a shorter message."
+        print(f"❌ Request timeout")
         return error_msg
     except requests.exceptions.ConnectionError:
         error_msg = f"🌐 **Connection Error**\n\n"
-        error_msg += f"Could not connect to OpenRouter API.\n\n"
-        error_msg += f"**Troubleshooting:**\n"
-        error_msg += f"1. Check your internet connection\n"
-        error_msg += f"2. Check OpenRouter service status\n"
-        error_msg += f"3. Try again in a few moments"
-        print(f"❌ Connection error to OpenRouter API")
+        error_msg += f"Unable to connect to the AI service. Please check your internet connection and try again."
+        print(f"❌ Connection error")
         return error_msg
     except Exception as e:
-        error_msg = f"❌ **Unexpected Error**\n\n"
-        error_msg += f"An unexpected error occurred:\n"
-        error_msg += f"`{str(e)}`\n\n"
+        error_msg = f"💥 **Unexpected Error**\n\n"
+        error_msg += f"An unexpected error occurred: {str(e)}\n\n"
         error_msg += f"Please try again or contact support if this persists."
         print(f"❌ Unexpected error: {str(e)}")
         return error_msg
 
-# Access code verification
+# Global state for access control
 access_granted = gr.State(False)
-_access_granted_global = False  # Global fallback
 
 def verify_access_code(code):
     """Verify the access code"""
     global _access_granted_global
     if not ACCESS_CODE:
-        _access_granted_global = True
-        return gr.update(visible=False), gr.update(visible=True), gr.update(value=True)
+        return gr.update(visible=False), gr.update(visible=True), True
     
-    if code == ACCESS_CODE:
+    if code.strip() == ACCESS_CODE.strip():
         _access_granted_global = True
-        return gr.update(visible=False), gr.update(visible=True), gr.update(value=True)
+        return gr.update(visible=False), gr.update(visible=True), True
     else:
-        _access_granted_global = False
-        return gr.update(visible=True, value="❌ Incorrect access code. Please try again."), gr.update(visible=False), gr.update(value=False)
+        return gr.update(value="❌ Incorrect access code. Please try again.", visible=True), gr.update(visible=False), False
 
 def protected_generate_response(message, history):
-    """Protected response function that checks access"""
-    # Check if access is granted via the global variable
+    """Wrapper that checks access before generating response"""
+    global _access_granted_global
     if ACCESS_CODE and not _access_granted_global:
-        return "Please enter the access code to continue."
+        return "Access denied. Please enter the correct access code."
     return generate_response(message, history)
 
-# Global variable to store chat history for export
-chat_history_store = []
-
 def store_and_generate_response(message, history):
-    """Wrapper function that stores history and generates response"""
+    """Wrapper that stores conversation and generates response"""
     global chat_history_store
     
-    # Store the updated history
-    chat_history_store = history.copy() if history else []
-    
-    # Generate response using the protected function
+    # Generate response
     response = protected_generate_response(message, history)
     
-    # Update stored history with the new exchange
-    chat_history_store.append({"role": "user", "content": message})
-    chat_history_store.append({"role": "assistant", "content": response})
+    # Store in global history for export (using new format)
+    chat_history_store = history + [{"role": "user", "content": message}, {"role": "assistant", "content": response}]
     
     return response
 
@@ -464,35 +365,27 @@ def export_current_conversation():
     markdown_content = export_conversation_to_markdown(chat_history_store)
     
     # Save to temporary file
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False, encoding='utf-8') as f:
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False) as f:
         f.write(markdown_content)
         temp_file = f.name
     
     return gr.update(value=temp_file, visible=True)
 
 def export_conversation(history):
-    """Export conversation to markdown file"""
+    """Export conversation from gradio history"""
     if not history:
-        return gr.update(visible=False)
-    
-    markdown_content = export_conversation_to_markdown(history)
-    
-    # Save to temporary file
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False, encoding='utf-8') as f:
-        f.write(markdown_content)
-        temp_file = f.name
+        return "No conversation to export."
     
-    return gr.update(value=temp_file, visible=True)
+    return export_conversation_to_markdown(history)
 
-# Configuration status display
 def get_configuration_status():
-    """Generate a configuration status message for display"""
+    """Get current configuration status for display"""
     status_parts = []
     
     if API_KEY_VALID:
         status_parts.append("✅ **API Key:** Configured and valid")
     else:
-        status_parts.append("❌ **API Key:** Not configured - Set `{OPENROUTER_API_KEY}` in Space secrets")
+        status_parts.append("❌ **API Key:** Not configured - Set `OPENROUTER_API_KEY` in Space secrets")
     
     status_parts.append(f"🤖 **Model:** {MODEL}")
     status_parts.append(f"🌡️ **Temperature:** 0.7")
@@ -514,6 +407,9 @@ def get_configuration_status():
     
     return "\n".join(status_parts)
 
+# Global access tracking
+_access_granted_global = not bool(ACCESS_CODE)  # If no access code, grant access
+
 # Create interface with access code protection
 with gr.Blocks(title=SPACE_NAME) as demo:
     gr.Markdown(f"# {SPACE_NAME}")
@@ -523,10 +419,11 @@ with gr.Blocks(title=SPACE_NAME) as demo:
     with gr.Accordion("📊 Configuration Status", open=not API_KEY_VALID):
         gr.Markdown(get_configuration_status())
     
-    # Access code section (shown only if ACCESS_CODE is set)
-    with gr.Column(visible=bool(ACCESS_CODE)) as access_section:
-        gr.Markdown("### 🔐 Access Required")
-        gr.Markdown("Please enter the access code provided by your instructor:")
+    # Access code section (only visible if ACCESS_CODE is set)
+    if ACCESS_CODE:
+        with gr.Column(visible=True) as access_section:
+            gr.Markdown("🔐 **Access Required**")
+            gr.Markdown("Please enter the access code to use this space.")
         
         access_input = gr.Textbox(
             label="Access Code",
@@ -571,4 +468,4 @@ with gr.Blocks(title=SPACE_NAME) as demo:
         )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()