Update app.py

app.py

@@ -16,7 +16,6 @@ try:
     TRANSFORMERS_AVAILABLE = True
 except ImportError:
     TRANSFORMERS_AVAILABLE = False
-    st.error("Transformers not available")
 
 try:
     import google.generativeai as genai
@@ -29,14 +28,13 @@ try:
     AUDIO_REC_AVAILABLE = True
 except ImportError:
     AUDIO_REC_AVAILABLE = False
-    st.warning("Audio recording not available")
 
 # Configure page
 st.set_page_config(
     page_title="VoiceCanvas - AI Content Studio",
     page_icon="🎨",
     layout="wide",
-    initial_sidebar_state="collapsed"
+    initial_sidebar_state="expanded"
 )
 
 # Initialize session state
@@ -46,46 +44,59 @@ if 'transcription' not in st.session_state:
     st.session_state.transcription = ""
 if 'processing' not in st.session_state:
     st.session_state.processing = False
+if 'current_task' not in st.session_state:
+    st.session_state.current_task = ""
+if 'models_loaded' not in st.session_state:
+    st.session_state.models_loaded = False
 
 # Global variables for models
 whisper_model = None
 text_generator = None
 
 def load_models():
-    """Load models efficiently"""
+    """Load models efficiently with progress tracking"""
     global whisper_model, text_generator
     
+    if st.session_state.models_loaded:
+        return True
+    
     if not TRANSFORMERS_AVAILABLE:
         st.error("AI models not available")
-        return
+        return False
     
-    if whisper_model is None:
-        try:
-            # Use the smallest Whisper model for speed
-            whisper_model = pipeline(
-                "automatic-speech-recognition",
-                model="openai/whisper-tiny",
-                device=-1,  # Force CPU
-                torch_dtype=torch.float32
-            )
-        except Exception as e:
-            st.error(f"Error loading Whisper: {e}")
-            whisper_model = "error"
+    progress_bar = st.progress(0)
+    status_text = st.empty()
     
-    if text_generator is None:
-        try:
-            # Use a lightweight text generation model
-            text_generator = pipeline(
-                "text-generation",
-                model="microsoft/DialoGPT-small",
-                device=-1,  # Force CPU
-                max_length=150,
-                do_sample=True,
-                temperature=0.7
-            )
-        except Exception as e:
-            st.warning(f"Text generator not available: {e}")
-            text_generator = "error"
+    try:
+        # Load Whisper model
+        status_text.text("Loading speech recognition model...")
+        progress_bar.progress(25)
+        
+        whisper_model = pipeline(
+            "automatic-speech-recognition",
+            model="openai/whisper-tiny",
+            device=-1,
+            torch_dtype=torch.float32
+        )
+        
+        progress_bar.progress(75)
+        status_text.text("Models loaded successfully!")
+        progress_bar.progress(100)
+        
+        st.session_state.models_loaded = True
+        
+        # Clear progress indicators after a moment
+        time.sleep(1)
+        progress_bar.empty()
+        status_text.empty()
+        
+        return True
+        
+    except Exception as e:
+        st.error(f"Error loading models: {e}")
+        progress_bar.empty()
+        status_text.empty()
+        return False
 
 def setup_gemini():
     """Setup Gemini API if available"""
@@ -105,16 +116,21 @@ def setup_gemini():
         return False
 
 def transcribe_audio_simple(audio_file):
-    """Simple audio transcription"""
+    """Simple audio transcription with progress tracking"""
     try:
-        if whisper_model is None or whisper_model == "error":
+        if whisper_model is None:
             return "Error: Speech recognition not available"
         
+        st.session_state.current_task = "Converting speech to text..."
+        
         # Transcribe using pipeline
         result = whisper_model(audio_file)
+        
+        st.session_state.current_task = ""
         return result["text"].strip()
         
     except Exception as e:
+        st.session_state.current_task = ""
         return f"Error: {str(e)}"
 
 def generate_content_with_gemini(prompt):
@@ -123,25 +139,44 @@ def generate_content_with_gemini(prompt):
         return generate_content_offline(prompt)
         
     try:
+        st.session_state.current_task = "Generating enhanced content with Gemini AI..."
+        
         model = genai.GenerativeModel('gemini-pro')
         response = model.generate_content(f"""
         Based on this input: "{prompt}"
         
-        Create marketing content with:
-        1. 3 catchy taglines (max 10 words each)
-        2. 3 social media posts (max 280 chars each)
-        3. 1 product description (max 100 words)
-        4. 3 image generation prompts
+        Create comprehensive marketing content with:
+        
+        ## Marketing Taglines
+        Generate 3 catchy, memorable taglines (max 12 words each)
+        
+        ## Social Media Posts  
+        Create 3 engaging social media posts (max 280 characters each)
         
-        Format your response clearly with headers.
+        ## Product Description
+        Write 1 compelling product description (100-150 words)
+        
+        ## Image Generation Prompts
+        Provide 3 detailed prompts for AI image generation
+        
+        ## Call-to-Action Ideas
+        Suggest 3 effective call-to-action phrases
+        
+        Format with clear markdown headers and numbered lists.
         """)
+        
+        st.session_state.current_task = ""
         return response.text
+        
     except Exception as e:
         st.warning(f"Gemini error: {e}. Using offline generation.")
+        st.session_state.current_task = ""
         return generate_content_offline(prompt)
 
 def generate_content_offline(prompt):
     """Generate content using offline methods"""
+    st.session_state.current_task = "Generating content with offline templates..."
+    
     # Create structured content
     content = {
         "taglines": [
@@ -167,29 +202,37 @@ def generate_content_offline(prompt):
     
     # Store both versions
     st.session_state.generated_content['structured'] = content
+    st.session_state.current_task = ""
+    
     return formatted
 
 def generate_image_with_api(prompt):
     """Generate image using free API"""
     try:
-        # Using free image generation API
+        st.session_state.current_task = "Creating image with AI..."
+        
         api_url = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-2-1"
         headers = {"Authorization": f"Bearer {os.getenv('HF_TOKEN', '')}"}
         
         if not os.getenv('HF_TOKEN'):
             st.warning("Add HF_TOKEN environment variable for image generation")
+            st.session_state.current_task = ""
             return None
         
-        response = requests.post(api_url, headers=headers, json={"inputs": prompt}, timeout=30)
+        response = requests.post(api_url, headers=headers, json={"inputs": prompt}, timeout=60)
         
         if response.status_code == 200:
             image = Image.open(io.BytesIO(response.content))
+            st.session_state.current_task = ""
             return image
         else:
             st.warning(f"Image API returned status {response.status_code}")
+            st.session_state.current_task = ""
             return None
+            
     except Exception as e:
         st.error(f"Image generation error: {e}")
+        st.session_state.current_task = ""
         return None
 
 def format_content_display(content):
@@ -222,235 +265,365 @@ def format_content_display(content):
     return str(content)
 
 def main():
+    # Sidebar with tips and status
+    with st.sidebar:
+        st.header("🎨 VoiceCanvas")
+        st.markdown("*AI Content Studio*")
+        
+        # Status section
+        st.subheader("📊 System Status")
+        
+        gemini_available = setup_gemini()
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            st.metric("Mode", "Enhanced" if gemini_available else "Basic")
+        with col2:
+            st.metric("Status", "Ready" if not st.session_state.processing else "Working")
+        
+        # Component status
+        st.write("🤖 **Components:**")
+        st.write(f"• Speech Recognition: {'✅' if TRANSFORMERS_AVAILABLE else '❌'}")
+        st.write(f"• Audio Recording: {'✅' if AUDIO_REC_AVAILABLE else '❌'}")
+        st.write(f"• Enhanced AI: {'✅' if gemini_available else '❌'}")
+        
+        # Current task indicator
+        if st.session_state.current_task:
+            st.info(f"🔄 {st.session_state.current_task}")
+        
+        st.markdown("---")
+        
+        # Tips and help
+        st.subheader("💡 How to Use")
+        
+        with st.expander("🚀 Quick Start", expanded=True):
+            st.markdown("""
+            1. **Input**: Use voice, upload audio, or type text
+            2. **Edit**: Review and refine your input
+            3. **Generate**: Create marketing content
+            4. **Export**: Download your materials
+            """)
+        
+        with st.expander("🎯 Best Practices"):
+            st.markdown("""
+            **For Voice/Audio:**
+            - Speak clearly at normal pace
+            - Use quiet environment
+            - Describe your product/service
+            - Mention target audience
+            
+            **For Text:**
+            - Be specific about features
+            - Include benefits and use cases
+            - Mention what makes it unique
+            - Use 50+ words for detail
+            """)
+        
+        with st.expander("⚙️ Setup (Optional)"):
+            st.markdown("""
+            **Enhanced Features:**
+            
+            Add environment variables:
+            - `GEMINI_API_KEY`: Advanced text generation
+            - `HF_TOKEN`: AI image generation
+            
+            **Get API Keys:**
+            - [Google AI Studio](https://makersuite.google.com/app/apikey) (Free)
+            - [Hugging Face](https://huggingface.co/settings/tokens) (Free)
+            """)
+        
+        with st.expander("🛠️ Troubleshooting"):
+            st.markdown("""
+            **Common Issues:**
+            - Audio not recording → Try different browser
+            - Slow processing → Models loading for first time
+            - No image generation → Add HF_TOKEN
+            - Basic content only → Add GEMINI_API_KEY
+            """)
+
+    # Main content
     st.title("🎨 VoiceCanvas - AI Content Studio")
-    st.markdown("*Transform your ideas into marketing content using AI*")
-    
-    # Quick setup
-    gemini_available = setup_gemini()
-    
-    # Status indicator
-    col1, col2, col3 = st.columns([2, 1, 1])
-    with col2:
-        if gemini_available:
-            st.success("✅ Enhanced AI")
-        else:
-            st.info("🔄 Basic Mode")
-    with col3:
-        st.metric("Status", "Ready" if not st.session_state.processing else "Processing")
+    st.markdown("*Transform your ideas into comprehensive marketing content*")
     
     # Main input area
-    st.header("🎤 Input Your Idea")
+    st.header("💡 Share Your Idea")
     
-    # Tabs for different input methods
+    # Dynamic tabs based on available features
+    available_tabs = []
     if AUDIO_REC_AVAILABLE:
-        tab1, tab2, tab3 = st.tabs(["🎙️ Voice", "📁 Upload", "✍️ Text"])
-    else:
-        tab2, tab3 = st.tabs(["📁 Upload", "✍️ Text"])
+        available_tabs.append("🎙️ Record")
+    available_tabs.extend(["📁 Upload", "✍️ Type"])
+    
+    tabs = st.tabs(available_tabs)
+    tab_index = 0
     
-    # Voice tab (only if available)
+    # Recording tab (if available)
     if AUDIO_REC_AVAILABLE:
-        with tab1:
-            st.info("Record your voice to generate content ideas")
+        with tabs[tab_index]:
+            st.info("🎤 Click the microphone button to start recording")
             
             # Audio recorder
             wav_audio_data = st_audiorec()
             
             if wav_audio_data is not None:
-                st.success("🎉 Audio recorded!")
+                st.success("🎉 Audio recorded successfully!")
                 st.audio(wav_audio_data, format='audio/wav')
                 
-                if st.button("🔄 Convert to Text", key="transcribe_btn"):
-                    st.session_state.processing = True
-                    st.rerun()
+                col1, col2 = st.columns([1, 2])
+                with col1:
+                    if st.button("🔄 Transcribe Audio", key="transcribe_btn", type="primary"):
+                        if not st.session_state.models_loaded:
+                            if load_models():
+                                st.session_state.processing = True
+                                st.rerun()
+                        else:
+                            st.session_state.processing = True
+                            st.rerun()
+                
+                with col2:
+                    if st.session_state.processing:
+                        st.info("🔄 Processing your audio...")
+        tab_index += 1
     
     # Upload tab
-    with tab2:
+    with tabs[tab_index]:
+        st.info("📁 Upload an audio file containing your idea")
+        
         uploaded_file = st.file_uploader(
-            "Upload audio file", 
+            "Choose audio file", 
             type=['wav', 'mp3', 'm4a'],
-            help="Max 5MB, 30 seconds recommended"
+            help="Supported: WAV, MP3, M4A • Max 10MB • Best: 30 seconds or less"
         )
         
         if uploaded_file:
+            st.success("📄 File uploaded successfully!")
             st.audio(uploaded_file)
-            if st.button("🔄 Convert to Text", key="upload_transcribe"):
-                st.session_state.processing = True
-                # Process uploaded file
-                with st.spinner("Converting speech to text..."):
-                    if TRANSFORMERS_AVAILABLE:
-                        load_models()
-                        transcription = transcribe_audio_simple(uploaded_file)
-                        st.session_state.transcription = transcription
+            
+            col1, col2 = st.columns([1, 2])
+            with col1:
+                if st.button("🔄 Process Audio", key="upload_transcribe", type="primary"):
+                    if not st.session_state.models_loaded:
+                        if load_models():
+                            st.session_state.processing = True
+                            st.rerun()
                     else:
-                        st.session_state.transcription = "Speech-to-text not available. Please use text input."
-                st.session_state.processing = False
-                st.rerun()
+                        st.session_state.processing = True
+                        st.rerun()
+            
+            with col2:
+                if st.session_state.processing:
+                    st.info("🔄 Converting speech to text...")
+    
+    tab_index += 1
     
     # Text tab
-    with tab3:
+    with tabs[tab_index]:
+        st.info("✍️ Type or paste your product/service description")
+        
         user_input = st.text_area(
-            "Type your idea or product description:",
-            placeholder="e.g., A smart fitness tracker that monitors sleep patterns and provides personalized recommendations",
-            height=120
+            "Describe your idea:",
+            placeholder="Example: A smart fitness tracker that monitors sleep patterns, heart rate, and stress levels. It provides personalized workout recommendations for busy professionals who want to maintain their health despite hectic schedules.",
+            height=150,
+            help="Be detailed! Include features, benefits, and target audience for best results."
         )
+        
         if user_input:
             st.session_state.transcription = user_input
+            word_count = len(user_input.split())
+            
+            if word_count < 10:
+                st.warning("💡 Add more details for better results (at least 10 words)")
+            elif word_count < 30:
+                st.info("📝 Good start! Add more features/benefits for richer content")
+            else:
+                st.success(f"✅ Great detail! ({word_count} words)")
     
-    # Process audio transcription if needed
-    if st.session_state.processing and AUDIO_REC_AVAILABLE:
-        # Check if wav_audio_data exists in the current scope
-        if 'wav_audio_data' in locals() and wav_audio_data is not None:
-            with st.spinner("🎯 Converting speech to text..."):
+    # Process audio transcription
+    if st.session_state.processing:
+        if AUDIO_REC_AVAILABLE and 'wav_audio_data' in locals() and wav_audio_data is not None:
+            # Process recorded audio
+            with st.spinner("🎯 Converting your speech to text..."):
+                with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
+                    tmp_file.write(wav_audio_data)
+                    transcription = transcribe_audio_simple(tmp_file.name)
+                    st.session_state.transcription = transcription
+                    os.unlink(tmp_file.name)
+            
+            st.session_state.processing = False
+            st.rerun()
+            
+        elif 'uploaded_file' in locals() and uploaded_file is not None:
+            # Process uploaded file
+            with st.spinner("🎯 Processing your audio file..."):
                 if TRANSFORMERS_AVAILABLE:
-                    load_models()
-                    
-                    # Save audio to temp file for processing
-                    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_file:
-                        tmp_file.write(wav_audio_data)
-                        transcription = transcribe_audio_simple(tmp_file.name)
-                        st.session_state.transcription = transcription
-                        os.unlink(tmp_file.name)
+                    transcription = transcribe_audio_simple(uploaded_file)
+                    st.session_state.transcription = transcription
                 else:
-                    st.session_state.transcription = "Speech recognition not available. Please use text input."
-        
-        st.session_state.processing = False
-        st.rerun()
+                    st.session_state.transcription = "Speech-to-text not available. Please use text input."
+            
+            st.session_state.processing = False
+            st.rerun()
     
-    # Show transcription
+    # Show transcription and editing
     if st.session_state.transcription:
-        st.subheader("📝 Your Input")
+        st.markdown("---")
+        st.header("📝 Review Your Input")
+        
         edited_text = st.text_area(
-            "Edit if needed:",
+            "Edit or refine your input:",
             value=st.session_state.transcription,
-            height=100,
-            key="edit_transcription"
+            height=120,
+            key="edit_transcription",
+            help="Make any corrections or add more details"
         )
         st.session_state.transcription = edited_text
         
-        # Generate content button
-        if st.button("🚀 Generate Marketing Content", type="primary", use_container_width=True):
-            with st.spinner("✨ Creating amazing content..."):
-                if gemini_available:
-                    content_text = generate_content_with_gemini(st.session_state.transcription)
-                    st.session_state.generated_content['text'] = content_text
-                else:
-                    content_text = generate_content_offline(st.session_state.transcription)
-                    st.session_state.generated_content['text'] = content_text
-            st.rerun()
+        # Generate content section
+        st.markdown("---")
+        col1, col2, col3 = st.columns([1, 2, 1])
+        
+        with col2:
+            if st.button("🚀 Generate Marketing Content", type="primary", use_container_width=True):
+                with st.spinner("✨ Creating comprehensive marketing content..."):
+                    if gemini_available:
+                        content_text = generate_content_with_gemini(st.session_state.transcription)
+                        st.session_state.generated_content['text'] = content_text
+                    else:
+                        content_text = generate_content_offline(st.session_state.transcription)
+                        st.session_state.generated_content['text'] = content_text
+                st.success("✅ Content generated successfully!")
+                st.rerun()
     
     # Display generated content
     if st.session_state.generated_content:
-        st.header("✨ Generated Content")
+        st.markdown("---")
+        st.header("✨ Your Marketing Content")
         
         # Text content
         if 'text' in st.session_state.generated_content:
             st.markdown(st.session_state.generated_content['text'])
         
         # Image generation section
-        st.subheader("🎨 Generate Images")
+        st.markdown("---")
+        st.subheader("🎨 Visual Content")
         
-        if 'structured' in st.session_state.generated_content:
-            # Show image prompts from structured content
-            prompts = st.session_state.generated_content['structured'].get('image_prompts', [])
-            if prompts:
-                selected_prompt = st.selectbox("Choose image style:", prompts)
-                
-                if st.button("🖼️ Generate Image"):
-                    with st.spinner("Creating image..."):
-                        img = generate_image_with_api(selected_prompt)
-                        if img:
-                            st.image(img, caption="Generated Image", use_column_width=True)
-                            
-                            # Store image for download
-                            st.session_state.generated_content['image'] = img
-                            
-                            # Download button
-                            img_buffer = io.BytesIO()
-                            img.save(img_buffer, format="PNG")
-                            st.download_button(
-                                "📥 Download Image",
-                                img_buffer.getvalue(),
-                                file_name=f"generated_image_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png",
-                                mime="image/png"
-                            )
-                        else:
-                            st.warning("Image generation not available. Check HF_TOKEN in settings.")
-        else:
-            # Simple prompt input for image generation
-            img_prompt = st.text_input("Enter image description:", 
-                                     placeholder="Professional product photo with clean background")
-            if img_prompt and st.button("🖼️ Generate Image"):
-                with st.spinner("Creating image..."):
-                    img = generate_image_with_api(img_prompt)
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            if 'structured' in st.session_state.generated_content:
+                # Show pre-made prompts
+                prompts = st.session_state.generated_content['structured'].get('image_prompts', [])
+                if prompts:
+                    selected_prompt = st.selectbox(
+                        "Choose image style:", 
+                        prompts,
+                        help="Select from AI-generated image prompts"
+                    )
+            else:
+                # Custom prompt input
+                selected_prompt = st.text_input(
+                    "Describe the image you want:",
+                    placeholder="Professional product photo with clean white background",
+                    help="Be specific about style, colors, composition"
+                )
+        
+        with col2:
+            st.write("")  # Spacing
+            st.write("")  # Spacing
+            
+            if st.button("🖼️ Generate Image", use_container_width=True):
+                if selected_prompt:
+                    img = generate_image_with_api(selected_prompt)
                     if img:
-                        st.image(img, caption="Generated Image", use_column_width=True)
                         st.session_state.generated_content['image'] = img
+                        st.success("🎨 Image created!")
+                        st.rerun()
+                    else:
+                        st.error("Image generation failed. Check HF_TOKEN.")
+                else:
+                    st.warning("Please enter/select an image description")
+        
+        # Display generated image
+        if 'image' in st.session_state.generated_content:
+            st.image(
+                st.session_state.generated_content['image'], 
+                caption="AI Generated Image", 
+                use_column_width=True
+            )
         
         # Export section
-        st.header("📥 Export Content")
+        st.markdown("---")
+        st.header("📥 Export Your Content")
         
-        col1, col2 = st.columns(2)
+        col1, col2, col3 = st.columns(3)
         
         with col1:
             # Text export
             if 'text' in st.session_state.generated_content:
-                content_export = f"""Marketing Content Generated on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-Input: {st.session_state.transcription}
+                content_export = f"""VOICECANVAS MARKETING CONTENT
+Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+Source: {st.session_state.transcription[:100]}...
 
 {st.session_state.generated_content['text']}
+
+---
+Created with VoiceCanvas AI Content Studio
 """
+                
                 st.download_button(
-                    "📄 Download Text Content",
+                    "📄 Download Text",
                     content_export,
                     file_name=f"marketing_content_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
                     mime="text/plain",
-                    use_container_width=True
+                    use_container_width=True,
+                    help="Download complete text content"
                 )
         
         with col2:
-            # JSON export for structured data
+            # JSON export
             if 'structured' in st.session_state.generated_content:
                 json_data = {
-                    "timestamp": datetime.now().isoformat(),
+                    "metadata": {
+                        "timestamp": datetime.now().isoformat(),
+                        "generator": "VoiceCanvas AI Studio",
+                        "mode": "Enhanced" if gemini_available else "Basic"
+                    },
                     "input": st.session_state.transcription,
                     "content": st.session_state.generated_content['structured']
                 }
                 
                 st.download_button(
-                    "📊 Download JSON Data",
+                    "📊 Download Data",
                     json.dumps(json_data, indent=2),
                     file_name=f"content_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
                     mime="application/json",
-                    use_container_width=True
+                    use_container_width=True,
+                    help="Download structured data (JSON)"
                 )
-    
-    # Help section
-    with st.expander("💡 Tips & Help"):
-        st.markdown("""
-        **How to use VoiceCanvas:**
-        1. 🎤 **Record/Upload**: Share your product idea via voice or upload audio
-        2. ✏️ **Edit**: Review and refine the transcribed text
-        3. 🚀 **Generate**: Create marketing content automatically
-        4. 📥 **Export**: Download your content in various formats
-        
-        **For best results:**
-        - Speak clearly and describe your product/service
-        - Include key features and benefits
-        - Mention your target audience
-        
-        **API Setup (Optional):**
-        - Add `GEMINI_API_KEY` for enhanced text generation
-        - Add `HF_TOKEN` for image generation
-        
-        **Current Status:**
-        - Transformers: {'✅ Available' if TRANSFORMERS_AVAILABLE else '❌ Not Available'}
-        - Audio Recording: {'✅ Available' if AUDIO_REC_AVAILABLE else '❌ Not Available'}
-        - Gemini AI: {'✅ Available' if gemini_available else '❌ Not Available'}
-        """)
+        
+        with col3:
+            # Image export
+            if 'image' in st.session_state.generated_content:
+                img_buffer = io.BytesIO()
+                st.session_state.generated_content['image'].save(img_buffer, format="PNG")
+                
+                st.download_button(
+                    "🖼️ Download Image",
+                    img_buffer.getvalue(),
+                    file_name=f"ai_image_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png",
+                    mime="image/png",
+                    use_container_width=True,
+                    help="Download generated image"
+                )
+            else:
+                st.info("Generate an image first", icon="ℹ️")
     
     # Footer
     st.markdown("---")
-    st.markdown("🎨 **VoiceCanvas** - Transform ideas into marketing content | Made with Streamlit")
+    col1, col2, col3 = st.columns([1, 2, 1])
+    with col2:
+        st.markdown("🎨 **VoiceCanvas AI Content Studio**")
+        st.caption("Transform ideas into marketing magic • Built with Streamlit")
 
 if __name__ == "__main__":
     main()