Update app.py

app.py

@@ -39,90 +39,110 @@ Use this template to create individual glossary pages for specific terms. Fill i
    * List URLs, book titles, or other references.
 """
 
+    # ---- Token safety utilities ----
+    def _approx_tokens(self, text: str) -> int:
+        # Roughly 4 characters per token (very conservative heuristic)
+        return max(1, len(text) // 4)
+
+    def _safe_max_tokens(self, prompt: str, requested_max: int, model_context_limit: int = 128000) -> int:
+        """
+        Clamp max_tokens so (prompt_tokens + max_tokens) <= model_context_limit.
+        We include the system message length as well.
+        """
+        system_msg = "You are a professional content writer specializing in creating high-quality glossary entries. You follow templates precisely and create comprehensive, well-structured content."
+        est_prompt_tokens = self._approx_tokens(system_msg) + self._approx_tokens(prompt)
+        room = max(256, model_context_limit - est_prompt_tokens)  # leave a floor of 256
+        return max(1, min(requested_max, room))
+
     def _test_api_key(self, api_key: str) -> bool:
         """Test OpenAI API key with minimal request"""
         if not api_key or not api_key.strip():
             return False
-        
         try:
-            # Import here to avoid import-time issues
             from openai import OpenAI
-            
             client = OpenAI(api_key=api_key.strip())
-            
-            # Test with minimal request
             response = client.chat.completions.create(
-                model="gpt-3.5-turbo",
+                model="gpt-4-turbo",
                 messages=[{"role": "user", "content": "Hi"}],
                 max_tokens=1
             )
             return True
-            
         except Exception as e:
             print(f"API test error: {e}")
             return False
 
-    def _call_openai_raw(self, api_key: str, prompt: str, model: str = "gpt-4", max_tokens: int = 2000) -> str:
-        """Direct OpenAI API call using requests"""
+    def _call_openai_raw(self, api_key: str, prompt: str, model: str = "gpt-4-turbo", max_tokens: int = 1200) -> str:
+        """Direct OpenAI API call using requests with safe max_tokens handling"""
         import requests
         import json
-        
+
         if not api_key or not api_key.strip():
             return "🔑 Please enter your OpenAI API key above to generate content."
-        
+
         clean_key = api_key.strip()
-        
-        # Direct API call to avoid client issues
+
+        # Auto-clamp max_tokens based on estimated prompt size and 128k context
+        safe_max = self._safe_max_tokens(prompt, requested_max=max_tokens, model_context_limit=128000)
+
         url = "https://api.openai.com/v1/chat/completions"
         headers = {
             "Authorization": f"Bearer {clean_key}",
             "Content-Type": "application/json"
         }
-        
+
         data = {
             "model": model,
             "messages": [
                 {"role": "system", "content": "You are a professional content writer specializing in creating high-quality glossary entries. You follow templates precisely and create comprehensive, well-structured content."},
                 {"role": "user", "content": prompt}
             ],
-            "max_tokens": max_tokens,
+            "max_tokens": safe_max,
             "temperature": 0.7,
             "top_p": 1,
             "frequency_penalty": 0,
             "presence_penalty": 0
         }
-        
+
         try:
             print(f"🚀 Making direct API call to OpenAI...")
-            response = requests.post(url, headers=headers, json=data, timeout=60)
+            print(f"ℹ️ Model: {model} | requested_max: {max_tokens} | safe_max: {safe_max}")
+            response = requests.post(url, headers=headers, json=data, timeout=90)
             print(f"📊 Response status: {response.status_code}")
-            
+
             if response.status_code == 200:
                 result = response.json()
                 content = result['choices'][0]['message']['content'].strip()
                 print("✅ API call successful")
                 return content
-            
             else:
-                error_data = response.json() if response.content else {}
+                error_data = {}
+                try:
+                    error_data = response.json() if response.content else {}
+                except Exception:
+                    pass
+
                 error_msg = error_data.get('error', {}).get('message', 'Unknown error')
                 error_code = error_data.get('error', {}).get('code', 'unknown')
-                
+
                 print(f"❌ API call failed: {response.status_code} - {error_msg}")
-                
+
                 if response.status_code == 401:
                     return "❌ Invalid API key. Please check your OpenAI API key."
                 elif response.status_code == 429:
                     return "❌ Rate limit exceeded. Please wait a moment and try again."
-                elif response.status_code == 404 and model == "gpt-4":
+                elif response.status_code == 404 and model == "gpt-4-turbo":
                     # Try GPT-3.5 fallback
                     print("🔄 Trying GPT-3.5-turbo fallback...")
-                    return self._call_openai_raw(api_key, prompt, "gpt-3.5-turbo", max_tokens)
-                elif "insufficient_quota" in error_msg.lower():
+                    # Recompute safe max for same prompt
+                    fallback_safe_max = self._safe_max_tokens(prompt, requested_max=max_tokens, model_context_limit=16384)  # conservative for 3.5
+                    return self._call_openai_raw(api_key, prompt, "gpt-3.5-turbo", fallback_safe_max)
+                elif "insufficient_quota" in str(error_msg).lower():
                     return "❌ OpenAI API quota exceeded. Please check your billing at https://platform.openai.com/usage"
+                elif "maximum context length" in str(error_msg).lower() or "context length" in str(error_msg).lower():
+                    return "❌ Context length exceeded. Try shortening your input or lowering max output length."
                 else:
                     return f"❌ OpenAI API Error ({response.status_code}): {error_msg}"
-                    
+
         except requests.exceptions.Timeout:
             return "❌ Request timeout. Please try again."
         except requests.exceptions.RequestException as e:
@@ -131,11 +151,10 @@ Use this template to create individual glossary pages for specific terms. Fill i
             return f"❌ Unexpected error: {str(e)}"
 
     def generate_new_content(self, api_key: str, term: str, context: str = "", target_audience: str = "general") -> str:
-        """Generate new glossary content for a given term"""
-        
+        """Generate new glossary content for a given term (uses gpt-4-turbo)"""
         if not term.strip():
             return "Please enter a term to generate content for."
-        
+
         prompt = f"""
 Create a comprehensive glossary entry for the term "{term}" following this EXACT template structure:
 {self.template}
@@ -158,16 +177,14 @@ Create a comprehensive glossary entry for the term "{term}" following this EXACT
 - Ensure professional, authoritative tone
 Generate the complete glossary entry now:
 """
-        
-        return self._call_openai_raw(api_key, prompt, max_tokens=2500)
+        # Default requested max_tokens for generation; will be auto-clamped
+        return self._call_openai_raw(api_key, prompt, model="gpt-4-turbo", max_tokens=1200)
 
     def update_existing_content(self, api_key: str, term: str, existing_content: str, update_instructions: str = "") -> Tuple[str, str]:
-        """Analyze existing content and provide update recommendations"""
-        
+        """Analyze existing content and provide update recommendations, then produce updated content"""
         if not term.strip() or not existing_content.strip():
             return "Please provide both term and existing content.", ""
-        
-        # First, analyze the content
+
         analysis_prompt = f"""
 Analyze this existing glossary content for "{term}" against the template standard and provide specific improvement recommendations.
 **EXISTING CONTENT:**
@@ -200,10 +217,8 @@ Analyze this existing glossary content for "{term}" against the template standar
    - Fact-checking requirements
 Format as a professional content analysis report.
 """
-        
-        recommendations = self._call_openai_raw(api_key, analysis_prompt, max_tokens=1500)
-        
-        # Then generate updated content
+        recommendations = self._call_openai_raw(api_key, analysis_prompt, model="gpt-4-turbo", max_tokens=1000)
+
         update_prompt = f"""
 Create an improved version of the glossary entry for "{term}" based on the analysis and recommendations.
 **ORIGINAL CONTENT:**
@@ -223,17 +238,14 @@ Create an improved version of the glossary entry for "{term}" based on the analy
 7. Enhances SEO and user experience
 Generate the complete, improved glossary entry:
 """
-        
-        updated_content = self._call_openai_raw(api_key, update_prompt, max_tokens=2500)
-        
+        updated_content = self._call_openai_raw(api_key, update_prompt, model="gpt-4-turbo", max_tokens=1200)
         return recommendations, updated_content
 
     def create_outline_brief(self, api_key: str, topic: str, scope: str = "comprehensive") -> str:
-        """Create an outline or brief for new glossary content"""
-        
+        """Create a strategic brief (uses gpt-4-turbo)"""
         if not topic.strip():
             return "Please enter a topic for the outline."
-        
+
         prompt = f"""
 Create a comprehensive content brief for developing a glossary focused on "{topic}".
 **Scope:** {scope}
@@ -279,62 +291,56 @@ Create a comprehensive content brief for developing a glossary focused on "{topi
 - Conversion and utility measurements
 Create a comprehensive, actionable brief that will guide the entire glossary development process.
 """
-        
-        return self._call_openai_raw(api_key, prompt, max_tokens=3000)
+        # Slightly larger default for briefs; will still auto-clamp safely
+        return self._call_openai_raw(api_key, prompt, model="gpt-4-turbo", max_tokens=1500)
 
 def create_gradio_interface():
     """Create the Gradio interface for the glossary generator"""
-    
+
     generator = GlossaryGenerator()
-    
+
     def test_api_key(api_key):
         """Test if the API key is valid"""
         if not api_key or not api_key.strip():
             return "❌ Please enter your OpenAI API key"
-        
-        # Basic format check
+
         clean_key = api_key.strip()
         if not clean_key.startswith('sk-'):
             return "❌ Invalid format - OpenAI API keys should start with 'sk-'"
-        
         if len(clean_key) < 20:
             return "❌ API key too short - check if you copied the full key"
-        
-        # Test the key with direct API call
-        test_result = generator._call_openai_raw(clean_key, "Test", "gpt-3.5-turbo", 1)
-        
+
+        test_result = generator._call_openai_raw(clean_key, "Test", "gpt-4-turbo", 1)
         if "❌" in test_result:
             return test_result
         else:
             return "✅ API key is valid and connected!"
-    
+
     def generate_new_wrapper(api_key, term, context, audience):
         if not term.strip():
             return "Please enter a term to generate content for."
         return generator.generate_new_content(api_key, term, context, audience)
-    
+
     def update_existing_wrapper(api_key, term, existing_content, update_instructions):
         if not term.strip() or not existing_content.strip():
             return "Please provide both term and existing content.", ""
         recommendations, updated_content = generator.update_existing_content(api_key, term, existing_content, update_instructions)
         return recommendations, updated_content
-    
+
     def create_outline_wrapper(api_key, topic, scope):
         if not topic.strip():
             return "Please enter a topic for the outline."
         return generator.create_outline_brief(api_key, topic, scope)
-    
-    # Create the Gradio interface
+
     with gr.Blocks(title="Glossary Content Generator", theme=gr.themes.Soft()) as demo:
         gr.Markdown("""
         # 📚 Glossary Content Generator
-        
-        **Powered by OpenAI GPT-4** - Professional glossary content creation and optimization tool.
-        
+
+        **Powered by OpenAI GPT-4 Turbo** - Professional glossary content creation and optimization tool.
+
         🔑 **Enter your OpenAI API key below to get started!**
         """)
-        
-        # API Key Section
+
         with gr.Row():
             with gr.Column(scale=2):
                 api_key_input = gr.Textbox(
@@ -345,7 +351,7 @@ def create_gradio_interface():
                 )
             with gr.Column(scale=1):
                 test_key_btn = gr.Button("Test Key", variant="secondary")
-                manual_test_btn = gr.Button("Skip Test & Try Anyway", variant="outline", size="sm")
+                manual_test_btn = gr.Button("Skip Test & Try Anyway", variant="outline")
             with gr.Column(scale=1):
                 key_status = gr.Textbox(
                     label="Status",
@@ -353,31 +359,30 @@ def create_gradio_interface():
                     interactive=False,
                     max_lines=2
                 )
-        
+
         def manual_override(api_key):
             if api_key and api_key.strip():
                 return "⚠️ Test skipped - trying anyway..."
             return "❌ Please enter an API key first"
-        
+
         test_key_btn.click(
             test_api_key,
             inputs=[api_key_input],
             outputs=[key_status]
         )
-        
+
         manual_test_btn.click(
             manual_override,
             inputs=[api_key_input],
             outputs=[key_status]
         )
-        
+
         gr.Markdown("---")
-        
+
         with gr.Tabs():
-            # Tab 1: Generate New Content
             with gr.TabItem("🆕 Generate New Content"):
-                gr.Markdown("### Create a new glossary entry from scratch using GPT-4")
-                
+                gr.Markdown("### Create a new glossary entry from scratch using GPT-4 Turbo")
+
                 with gr.Row():
                     with gr.Column(scale=1):
                         new_term = gr.Textbox(
@@ -395,8 +400,7 @@ def create_gradio_interface():
                             choices=["general", "technical", "business", "beginner", "expert"],
                             value="general"
                         )
-                        generate_btn = gr.Button("🚀 Generate Content", variant="primary", size="lg")
-                    
+                        generate_btn = gr.Button("🚀 Generate Content", variant="primary")
                     with gr.Column(scale=2):
                         new_output = gr.Textbox(
                             label="Generated Glossary Entry",
@@ -404,20 +408,18 @@ def create_gradio_interface():
                             max_lines=30,
                             show_copy_button=True
                         )
-                
+
                 generate_btn.click(
                     generate_new_wrapper,
                     inputs=[api_key_input, new_term, new_context, new_audience],
                     outputs=[new_output]
                 )
-                
-                # Add examples
+
                 gr.Markdown("**💡 Example Terms:** API, Machine Learning, Blockchain, SaaS, Customer Journey, A/B Testing")
-            
-            # Tab 2: Update Existing Content
+
             with gr.TabItem("🔄 Update Existing Content"):
                 gr.Markdown("### Analyze and improve existing glossary entries with AI-powered recommendations")
-                
+
                 with gr.Row():
                     with gr.Column(scale=1):
                         update_term = gr.Textbox(
@@ -435,8 +437,7 @@ def create_gradio_interface():
                             placeholder="e.g., 'Add more technical details', 'Include recent developments', 'Improve SEO focus'",
                             lines=3
                         )
-                        update_btn = gr.Button("🔍 Analyze & Update", variant="primary", size="lg")
-                    
+                        update_btn = gr.Button("🔍 Analyze & Update", variant="primary")
                     with gr.Column(scale=2):
                         with gr.Row():
                             recommendations_output = gr.Textbox(
@@ -452,17 +453,16 @@ def create_gradio_interface():
                                 max_lines=15,
                                 show_copy_button=True
                             )
-                
+
                 update_btn.click(
                     update_existing_wrapper,
                     inputs=[api_key_input, update_term, existing_content, update_instructions],
                     outputs=[recommendations_output, updated_content_output]
                 )
-            
-            # Tab 3: Create Outline/Brief
+
             with gr.TabItem("📋 Create Content Brief"):
                 gr.Markdown("### Generate a comprehensive strategy brief for glossary development")
-                
+
                 with gr.Row():
                     with gr.Column(scale=1):
                         outline_topic = gr.Textbox(
@@ -475,8 +475,7 @@ def create_gradio_interface():
                             choices=["comprehensive", "focused", "basic", "advanced", "specialized"],
                             value="comprehensive"
                         )
-                        outline_btn = gr.Button("📋 Create Strategic Brief", variant="primary", size="lg")
-                    
+                        outline_btn = gr.Button("📋 Create Strategic Brief", variant="primary")
                     with gr.Column(scale=2):
                         outline_output = gr.Textbox(
                             label="📈 Content Strategy Brief",
@@ -484,16 +483,15 @@ def create_gradio_interface():
                             max_lines=30,
                             show_copy_button=True
                         )
-                
+
                 outline_btn.click(
                     create_outline_wrapper,
                     inputs=[api_key_input, outline_topic, outline_scope],
                     outputs=[outline_output]
                 )
-                
+
                 gr.Markdown("**💡 Example Topics:** Digital Marketing, FinTech, SaaS Operations, Data Science, Cybersecurity")
-            
-            # Tab 4: Template Reference
+
             with gr.TabItem("📄 Template Reference"):
                 gr.Markdown("### Official Glossary Template Structure")
                 template_display = gr.Textbox(
@@ -504,33 +502,26 @@ def create_gradio_interface():
                     interactive=False,
                     show_copy_button=True
                 )
-        
+
         gr.Markdown("""
         ---
         ## 🔧 How to Get Your OpenAI API Key:
-        
+
         1. **Visit** [platform.openai.com/api-keys](https://platform.openai.com/api-keys)
         2. **Sign up** or log in to your OpenAI account
-        3. **Add billing information** (GPT-4 requires a paid account)
+        3. **Add billing information** (GPT-4 access requires a paid account)
         4. **Create a new secret key**
         5. **Copy and paste** it into the field above
-        
-        ## 💰 **Cost Information:**
-        - **GPT-4 pricing**: ~$0.03 per 1K input tokens, ~$0.06 per 1K output tokens
-        - **Per generation**: Approximately $0.02-0.10 depending on content length
-        - **Very cost-effective** for professional content creation
-        
-        ## ✨ **Features:**
-        - 🤖 **GPT-4 Powered**: High-quality, professional content generation
-        - 📝 **Template Consistency**: Follows your exact 6-section structure
-        - 🔍 **Content Analysis**: Detailed improvement recommendations
-        - 📊 **Strategic Planning**: Comprehensive content briefs and roadmaps
-        - 🎯 **SEO Optimized**: Includes PAA questions and keyword strategies
-        - 📋 **Copy-Friendly**: Easy copy buttons for all outputs
-        - 🔑 **No Setup Required**: Just enter your API key and start generating!
-        - 🛠️ **Direct API**: Uses raw HTTP requests to avoid library conflicts
+
+        ## ✨ Features:
+        - 🤖 **GPT-4 Turbo Powered**
+        - 📝 **Template Consistency**
+        - 🔍 **Content Analysis**
+        - 📊 **Strategic Briefs**
+        - 🎯 **SEO-Oriented Outputs**
+        - 🔑 **Direct API (raw HTTP)**
         """)
-    
+
     return demo
 
 # Launch the application