Update app.py

app.py

@@ -2,6 +2,14 @@ import gradio as gr
 import os
 import json
 import logging
+import tempfile
+
+# Optional imports for audio processing
+try:
+    import scipy.io.wavfile
+    SCIPY_AVAILABLE = True
+except ImportError:
+    SCIPY_AVAILABLE = False
 
 # ══════════════════════════════════════════════════════════════════════════════
 # 🎓 MINIMAL AI RESEARCH DEMO - GRADIO 5.0.1 COMPATIBLE
@@ -25,26 +33,36 @@ def get_client():
     """Get HuggingFace client - exactly like your working example."""
     api_token = os.getenv("HF_API_TOKEN")
     
-    if not HF_AVAILABLE or not api_token:
+    if not HF_AVAILABLE:
+        logger.error("❌ HuggingFace Hub not available")
+        return None
+        
+    if not api_token:
+        logger.error("❌ HF_API_TOKEN not set")
         return None
     
     try:
+        logger.info("🔄 Initializing HuggingFace client...")
         client = InferenceClient(
             provider="hf-inference",
             api_key=api_token,
         )
+        
         # Test with exact same call as your working example
+        logger.info("🧪 Testing client with fill_mask...")
         test_result = client.fill_mask("The capital of France is [MASK].", model="google-bert/bert-base-uncased")
-        logger.info(f"✅ Client test successful: {type(test_result)}")
+        logger.info(f"✅ Client test successful: {type(test_result)}, got {len(test_result) if isinstance(test_result, list) else 'non-list'} results")
+        
         return client
+        
     except Exception as e:
-        logger.error(f"❌ Client failed: {e}")
+        logger.error(f"❌ Client initialization failed: {e}")
         return None
 
 CLIENT = get_client()
 
 # ══════════════════════════════════════════════════════════════════════════════
-# 🤖 MINIMAL FUNCTIONS - AVOIDING GRADIO SCHEMA BUGS
+# 🤖 COMPREHENSIVE AI FUNCTIONS - ALL HUGGINGFACE CAPABILITIES
 # ══════════════════════════════════════════════════════════════════════════════
 
 def run_chat(message):
@@ -52,26 +70,51 @@ def run_chat(message):
     if not CLIENT:
         return "❌ Client not available"
     
+    # Handle None/empty message from Gradio
+    if not message or str(message).strip() == "":
+        return "❌ Please enter a message"
+    
     try:
-        messages = [{"role": "user", "content": message}]
+        clean_message = str(message).strip()
+        messages = [{"role": "user", "content": clean_message}]
+        
+        logger.info(f"Chat call: message='{clean_message}'")
+        
         completion = CLIENT.chat.completions.create(
             model="Qwen/Qwen2.5-72B-Instruct",
             messages=messages,
         )
-        return completion.choices[0].message.content
+        
+        result = completion.choices[0].message.content
+        logger.info(f"Chat result: {type(result)}")
+        
+        return result
+        
     except Exception as e:
-        return f"❌ Error: {str(e)}"
+        logger.error(f"Chat error: {e}")
+        return f"❌ Error: {str(e)}\n\n**Debug:** Message: '{message}'"
 
 def run_fill_mask(text):
     """Fill mask - using your exact working approach."""
     if not CLIENT:
         return "❌ Client not available"
     
-    if "[MASK]" not in text:
-        return "❌ Text must contain [MASK]"
+    # Handle None/empty text from Gradio
+    if not text or str(text).strip() == "":
+        return "❌ Please enter text with [MASK]"
+    
+    clean_text = str(text).strip()
+    
+    if "[MASK]" not in clean_text:
+        return "❌ Text must contain [MASK] token"
     
     try:
-        result = CLIENT.fill_mask(text, model="google-bert/bert-base-uncased")
+        logger.info(f"Fill mask call: text='{clean_text}'")
+        
+        result = CLIENT.fill_mask(clean_text, model="google-bert/bert-base-uncased")
+        
+        logger.info(f"Fill mask result: {type(result)}")
+        
         if isinstance(result, list):
             output = "🎭 **Predictions:**\n"
             for i, pred in enumerate(result[:5], 1):
@@ -80,52 +123,361 @@ def run_fill_mask(text):
                 output += f"{i}. **{token}** ({score:.3f})\n"
             return output
         return str(result)
+        
     except Exception as e:
-        return f"❌ Error: {str(e)}"
+        logger.error(f"Fill mask error: {e}")
+        return f"❌ Error: {str(e)}\n\n**Debug:** Text: '{text}'"
 
 def run_question_answering(question, context):
-    """Q&A function."""
-    if not CLIENT or not question or not context:
-        return "❌ Client not available or missing input"
+    """Q&A function - Fixed parameter handling."""
+    if not CLIENT:
+        return "❌ Client not available"
+    
+    # Handle None/empty values from Gradio
+    if not question or not context or question.strip() == "" or context.strip() == "":
+        return "❌ Please provide both question and context"
     
     try:
+        # Ensure we have clean string inputs
+        clean_question = str(question).strip()
+        clean_context = str(context).strip()
+        
+        logger.info(f"Q&A call: question='{clean_question}', context='{clean_context[:50]}...'")
+        
         answer = CLIENT.question_answering(
-            question=question,
-            context=context,
+            question=clean_question,
+            context=clean_context,
             model="deepset/roberta-base-squad2",
         )
-        return f"💡 **Answer:** {answer.get('answer', str(answer))}"
+        
+        logger.info(f"Q&A result: {type(answer)}, {answer}")
+        
+        if isinstance(answer, dict):
+            return f"💡 **Answer:** {answer.get('answer', 'No answer found')}\n📊 **Score:** {answer.get('score', 'N/A')}"
+        else:
+            return f"💡 **Answer:** {str(answer)}"
+            
     except Exception as e:
-        return f"❌ Error: {str(e)}"
+        logger.error(f"Q&A error: {e}")
+        return f"❌ Error: {str(e)}\n\n**Debug:** Question: '{question}', Context: '{context[:50] if context else 'None'}...'"
 
 def run_summarization(text):
-    """Summarization function."""
-    if not CLIENT or len(text.split()) < 10:
-        return "❌ Client not available or text too short"
+    """Summarization function - Fixed parameter handling."""
+    if not CLIENT:
+        return "❌ Client not available"
+    
+    # Handle None/empty text from Gradio
+    if not text or str(text).strip() == "":
+        return "❌ Please enter text to summarize"
+    
+    clean_text = str(text).strip()
+    
+    if len(clean_text.split()) < 10:
+        return "❌ Text must be at least 10 words long"
     
     try:
-        result = CLIENT.summarization(text, model="facebook/bart-large-cnn")
+        logger.info(f"Summarization call: text length={len(clean_text)}")
+        
+        result = CLIENT.summarization(clean_text, model="facebook/bart-large-cnn")
+        
+        logger.info(f"Summarization result: {type(result)}")
+        
         if isinstance(result, list) and result:
-            return f"📝 **Summary:** {result[0].get('summary_text', str(result))}"
-        return f"📝 **Summary:** {str(result)}"
+            summary = result[0].get('summary_text', str(result[0]))
+            return f"📝 **Summary:** {summary}"
+        elif isinstance(result, dict):
+            summary = result.get('summary_text', str(result))
+            return f"📝 **Summary:** {summary}"
+        else:
+            return f"📝 **Summary:** {str(result)}"
+            
+    except Exception as e:
+        logger.error(f"Summarization error: {e}")
+        return f"❌ Error: {str(e)}\n\n**Debug:** Text length: {len(text) if text else 0}"
+
+def run_text_classification(text):
+    """Text Classification function."""
+    if not CLIENT:
+        return "❌ Client not available"
+    
+    if not text or str(text).strip() == "":
+        return "❌ Please enter text to classify"
+    
+    clean_text = str(text).strip()
+    
+    try:
+        logger.info(f"Text classification call: text='{clean_text[:50]}...'")
+        
+        result = CLIENT.text_classification(clean_text, model="cardiffnlp/twitter-roberta-base-sentiment-latest")
+        
+        logger.info(f"Text classification result: {type(result)}")
+        
+        if isinstance(result, list):
+            output = "🏷️ **Classifications:**\n"
+            for i, pred in enumerate(result[:5], 1):
+                label = pred.get("label", "Unknown")
+                score = pred.get("score", 0)
+                output += f"{i}. **{label}** ({score:.3f})\n"
+            return output
+        return str(result)
+        
+    except Exception as e:
+        logger.error(f"Text classification error: {e}")
+        return f"❌ Error: {str(e)}"
+
+def run_token_classification(text):
+    """Token Classification (NER) function."""
+    if not CLIENT:
+        return "❌ Client not available"
+    
+    if not text or str(text).strip() == "":
+        return "❌ Please enter text for entity recognition"
+    
+    clean_text = str(text).strip()
+    
+    try:
+        logger.info(f"Token classification call: text='{clean_text}'")
+        
+        result = CLIENT.token_classification(clean_text, model="dslim/bert-base-NER")
+        
+        logger.info(f"Token classification result: {type(result)}")
+        
+        if isinstance(result, list):
+            output = "🏷️ **Named Entities:**\n"
+            for i, entity in enumerate(result[:10], 1):
+                word = entity.get("word", "Unknown")
+                label = entity.get("entity", "Unknown")
+                score = entity.get("score", 0)
+                output += f"{i}. **{word}** → {label} ({score:.3f})\n"
+            return output
+        return str(result)
+        
+    except Exception as e:
+        logger.error(f"Token classification error: {e}")
+        return f"❌ Error: {str(e)}"
+
+def run_translation(text):
+    """Translation function."""
+    if not CLIENT:
+        return "❌ Client not available"
+    
+    if not text or str(text).strip() == "":
+        return "❌ Please enter text to translate"
+    
+    clean_text = str(text).strip()
+    
+    try:
+        logger.info(f"Translation call: text='{clean_text[:50]}...'")
+        
+        result = CLIENT.translation(clean_text, model="Helsinki-NLP/opus-mt-en-fr")
+        
+        logger.info(f"Translation result: {type(result)}")
+        
+        if isinstance(result, list) and result:
+            translation = result[0].get('translation_text', str(result[0]))
+            return f"🌐 **Translation (EN→FR):** {translation}"
+        elif isinstance(result, dict):
+            translation = result.get('translation_text', str(result))
+            return f"🌐 **Translation (EN→FR):** {translation}"
+        else:
+            return f"🌐 **Translation:** {str(result)}"
+            
+    except Exception as e:
+        logger.error(f"Translation error: {e}")
+        return f"❌ Error: {str(e)}"
+
+def run_feature_extraction(text):
+    """Feature Extraction function."""
+    if not CLIENT:
+        return "❌ Client not available"
+    
+    if not text or str(text).strip() == "":
+        return "❌ Please enter text for feature extraction"
+    
+    clean_text = str(text).strip()
+    
+    try:
+        logger.info(f"Feature extraction call: text='{clean_text[:50]}...'")
+        
+        result = CLIENT.feature_extraction(clean_text, model="intfloat/multilingual-e5-large-instruct")
+        
+        logger.info(f"Feature extraction result: {type(result)}")
+        
+        if isinstance(result, list) and result:
+            dim = len(result[0]) if result[0] else 0
+            sample = result[0][:5] if dim >= 5 else result[0]
+            return f"🧮 **Feature Vector:** Dimension: {dim}\n**Sample values:** {sample}..."
+        else:
+            return f"🧮 **Features:** {str(result)[:200]}..."
+            
+    except Exception as e:
+        logger.error(f"Feature extraction error: {e}")
+        return f"❌ Error: {str(e)}"
+
+def run_zero_shot_classification(text, labels):
+    """Zero Shot Classification function."""
+    if not CLIENT:
+        return "❌ Client not available"
+    
+    if not text or str(text).strip() == "":
+        return "❌ Please enter text to classify"
+    
+    if not labels or str(labels).strip() == "":
+        return "❌ Please enter candidate labels (comma-separated)"
+    
+    clean_text = str(text).strip()
+    clean_labels = [label.strip() for label in str(labels).split(",") if label.strip()]
+    
+    if not clean_labels:
+        return "❌ Please provide valid labels separated by commas"
+    
+    try:
+        logger.info(f"Zero shot classification call: text='{clean_text[:50]}...', labels={clean_labels}")
+        
+        # Use text classification with BART MNLI model for zero-shot
+        result = CLIENT.text_classification(
+            clean_text, 
+            model="facebook/bart-large-mnli",
+            # Note: Some models support candidate_labels parameter
+        )
+        
+        logger.info(f"Zero shot classification result: {type(result)}")
+        
+        if isinstance(result, list):
+            output = "🎯 **Zero-Shot Classification:**\n"
+            for i, pred in enumerate(result[:5], 1):
+                label = pred.get("label", "Unknown")
+                score = pred.get("score", 0)
+                output += f"{i}. **{label}** ({score:.3f})\n"
+            return output
+        elif isinstance(result, dict):
+            labels_result = result.get('labels', [])
+            scores = result.get('scores', [])
+            output = "🎯 **Zero-Shot Classification:**\n"
+            for i, (label, score) in enumerate(zip(labels_result[:5], scores[:5]), 1):
+                output += f"{i}. **{label}** ({score:.3f})\n"
+            return output
+        else:
+            return f"🎯 **Result:** {str(result)}"
+        
+    except Exception as e:
+        logger.error(f"Zero shot classification error: {e}")
+        # Fallback to regular text classification
+        try:
+            result = CLIENT.text_classification(clean_text, model="cardiffnlp/twitter-roberta-base-sentiment-latest")
+            return f"🎯 **Classification (fallback):** {str(result)}\n\n⚠️ Note: Zero-shot with custom labels not available, showing sentiment analysis instead."
+        except:
+            return f"❌ Error: {str(e)}"
+
+def run_image_classification(image):
+    """Image Classification function."""
+    if not CLIENT:
+        return "❌ Client not available"
+    
+    if image is None:
+        return "❌ Please upload an image"
+    
+    try:
+        logger.info(f"Image classification call: image type={type(image)}")
+        
+        result = CLIENT.image_classification(image, model="google/vit-base-patch16-224")
+        
+        logger.info(f"Image classification result: {type(result)}")
+        
+        if isinstance(result, list):
+            output = "🖼️ **Image Classification:**\n"
+            for i, pred in enumerate(result[:5], 1):
+                label = pred.get("label", "Unknown")
+                score = pred.get("score", 0)
+                output += f"{i}. **{label}** ({score:.1%})\n"
+            return output
+        return str(result)
+        
+    except Exception as e:
+        logger.error(f"Image classification error: {e}")
+        return f"❌ Error: {str(e)}"
+
+def run_automatic_speech_recognition(audio):
+    """Automatic Speech Recognition function."""
+    if not CLIENT:
+        return "❌ Client not available"
+    
+    if audio is None:
+        return "❌ Please upload an audio file or record audio"
+    
+    try:
+        logger.info(f"ASR call: audio type={type(audio)}")
+        
+        # Handle different audio input types
+        if isinstance(audio, tuple):
+            # Convert numpy array to temporary file
+            if not SCIPY_AVAILABLE:
+                return "❌ scipy is required for audio processing. Install with: pip install scipy"
+            
+            import scipy.io.wavfile as wav
+            sample_rate, audio_array = audio
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
+                wav.write(tmp_file.name, sample_rate, audio_array)
+                audio_path = tmp_file.name
+        else:
+            audio_path = audio
+        
+        result = CLIENT.automatic_speech_recognition(audio_path, model="openai/whisper-large-v3")
+        
+        logger.info(f"ASR result: {type(result)}")
+        
+        if isinstance(result, dict):
+            text = result.get('text', str(result))
+            return f"🎤 **Transcription:** {text}"
+        else:
+            return f"🎤 **Transcription:** {str(result)}"
+            
+    except Exception as e:
+        logger.error(f"ASR error: {e}")
+        return f"❌ Error: {str(e)}"
+
+def run_text_to_image(prompt):
+    """Text to Image function."""
+    if not CLIENT:
+        return "❌ Client not available"
+    
+    if not prompt or str(prompt).strip() == "":
+        return "❌ Please enter a text prompt for image generation"
+    
+    clean_prompt = str(prompt).strip()
+    
+    try:
+        logger.info(f"Text to image call: prompt='{clean_prompt}'")
+        
+        # Note: This returns a PIL Image object
+        image = CLIENT.text_to_image(clean_prompt, model="black-forest-labs/FLUX.1-schnell")
+        
+        logger.info(f"Text to image result: {type(image)}")
+        
+        return f"🎨 **Image Generated Successfully!** \n📝 Prompt: {clean_prompt}\n🖼️ Check the generated image above."
+        
     except Exception as e:
+        logger.error(f"Text to image error: {e}")
         return f"❌ Error: {str(e)}"
 
 # ══════════════════════════════════════════════════════════════════════════════
-# 🎨 MINIMAL GRADIO INTERFACE - SCHEMA-BUG PROOF
+# 🎨 COMPREHENSIVE GRADIO INTERFACE - ALL AI CAPABILITIES
 # ══════════════════════════════════════════════════════════════════════════════
 
-# Create interface with minimal components to avoid schema bugs
-with gr.Blocks(title="AI Research Demo") as demo:
+# Create interface with comprehensive AI capabilities
+with gr.Blocks(title="🚀 Complete AI Research Hub") as demo:
     
-    gr.Markdown("# 🎓 AI Research Demo\n### Working HuggingFace Inference API")
+    gr.Markdown("# 🚀 Complete AI Research Hub\n### **All HuggingFace Inference API Capabilities**")
     
     if CLIENT:
         gr.Markdown("✅ **Status:** Connected and tested successfully")
     else:
         gr.Markdown("❌ **Status:** Set HF_API_TOKEN environment variable")
     
-    # Chat Tab
+    # ═══════════════════════════════════════════════════════════════════════════
+    # 💬 CHAT & TEXT GENERATION
+    # ═══════════════════════════════════════════════════════════════════════════
+    
     gr.Markdown("## 💬 Chat with AI")
     chat_input = gr.Textbox(label="Your Message", placeholder="Ask anything...")
     chat_output = gr.Textbox(label="AI Response", lines=5)
@@ -134,8 +486,11 @@ with gr.Blocks(title="AI Research Demo") as demo:
     
     gr.Markdown("---")
     
-    # Fill Mask
-    gr.Markdown("## 🎭 Fill Mask")
+    # ═══════════════════════════════════════════════════════════════════════════
+    # 🎭 TEXT UNDERSTANDING & PREDICTION
+    # ═══════════════════════════════════════════════════════════════════════════
+    
+    gr.Markdown("## 🎭 Fill Mask Prediction")
     mask_input = gr.Textbox(
         label="Text with [MASK]", 
         value="The capital of France is [MASK].",
@@ -147,7 +502,6 @@ with gr.Blocks(title="AI Research Demo") as demo:
     
     gr.Markdown("---")
     
-    # Q&A
     gr.Markdown("## ❓ Question Answering")
     qa_question = gr.Textbox(label="Question", value="What is AI?")
     qa_context = gr.Textbox(
@@ -161,7 +515,10 @@ with gr.Blocks(title="AI Research Demo") as demo:
     
     gr.Markdown("---")
     
-    # Summarization
+    # ═══════════════════════════════════════════════════════════════════════════
+    # 📝 TEXT PROCESSING & ANALYSIS
+    # ═══════════════════════════════════════════════════════════════════════════
+    
     gr.Markdown("## 📝 Text Summarization")
     sum_input = gr.Textbox(
         label="Text to Summarize",
@@ -173,11 +530,178 @@ with gr.Blocks(title="AI Research Demo") as demo:
     sum_btn.click(run_summarization, inputs=sum_input, outputs=sum_output)
     
     gr.Markdown("---")
-    gr.Markdown("**🔧 Setup:** `export HF_API_TOKEN=your_token_here`")
+    
+    gr.Markdown("## 🏷️ Text Classification")
+    tc_input = gr.Textbox(
+        label="Text to Classify",
+        value="I love this new AI technology! It's amazing.",
+        placeholder="Enter text for sentiment/topic classification"
+    )
+    tc_output = gr.Textbox(label="Classification Results", lines=4)
+    tc_btn = gr.Button("Classify", variant="primary")
+    tc_btn.click(run_text_classification, inputs=tc_input, outputs=tc_output)
+    
+    gr.Markdown("---")
+    
+    gr.Markdown("## 🎯 Zero-Shot Classification")
+    zsc_text = gr.Textbox(
+        label="Text to Classify",
+        value="I need to return this broken phone and get my money back.",
+        placeholder="Enter text for classification"
+    )
+    zsc_labels = gr.Textbox(
+        label="Candidate Labels (comma-separated)",
+        value="refund, complaint, question, compliment",
+        placeholder="Enter possible labels separated by commas"
+    )
+    zsc_output = gr.Textbox(label="Classification Results", lines=4)
+    zsc_btn = gr.Button("Classify", variant="primary")
+    zsc_btn.click(run_zero_shot_classification, inputs=[zsc_text, zsc_labels], outputs=zsc_output)
+    
+    gr.Markdown("---")
+    
+    gr.Markdown("## 🏷️ Named Entity Recognition")
+    ner_input = gr.Textbox(
+        label="Text for Entity Recognition",
+        value="My name is John Smith and I work at Google in New York.",
+        placeholder="Enter text to extract named entities"
+    )
+    ner_output = gr.Textbox(label="Named Entities", lines=5)
+    ner_btn = gr.Button("Extract Entities", variant="primary")
+    ner_btn.click(run_token_classification, inputs=ner_input, outputs=ner_output)
+    
+    gr.Markdown("---")
+    
+    # ═══════════════════════════════════════════════════════════════════════════
+    # 🌐 LANGUAGE & TRANSLATION
+    # ═══════════════════════════════════════════════════════════════════════════
+    
+    gr.Markdown("## 🌐 Language Translation")
+    trans_input = gr.Textbox(
+        label="English Text to Translate",
+        value="Hello, how are you today? I hope you have a wonderful day.",
+        placeholder="Enter English text to translate to French"
+    )
+    trans_output = gr.Textbox(label="French Translation", lines=3)
+    trans_btn = gr.Button("Translate to French", variant="primary")
+    trans_btn.click(run_translation, inputs=trans_input, outputs=trans_output)
+    
+    gr.Markdown("---")
+    
+    # ═══════════════════════════════════════════════════════════════════════════
+    # 🧮 EMBEDDINGS & FEATURES
+    # ════════════════════════════════��══════════════════════════════════════════
+    
+    gr.Markdown("## 🧮 Feature Extraction (Embeddings)")
+    fe_input = gr.Textbox(
+        label="Text for Feature Extraction",
+        value="Machine learning is transforming the world.",
+        placeholder="Enter text to generate embeddings"
+    )
+    fe_output = gr.Textbox(label="Feature Vector Info", lines=4)
+    fe_btn = gr.Button("Extract Features", variant="primary")
+    fe_btn.click(run_feature_extraction, inputs=fe_input, outputs=fe_output)
+    
+    gr.Markdown("---")
+    
+    # ═══════════════════════════════════════════════════════════════════════════
+    # 🎤 AUDIO PROCESSING
+    # ═══════════════════════════════════════════════════════════════════════════
+    
+    gr.Markdown("## 🎤 Speech Recognition")
+    asr_input = gr.Audio(
+        sources=["upload", "microphone"],
+        type="numpy",
+        label="Upload Audio or Record"
+    )
+    asr_output = gr.Textbox(label="Transcription", lines=4)
+    asr_btn = gr.Button("Transcribe Audio", variant="primary")
+    asr_btn.click(run_automatic_speech_recognition, inputs=asr_input, outputs=asr_output)
+    
+    gr.Markdown("---")
+    
+    # ═══════════════════════════════════════════════════════════════════════════
+    # 🖼️ IMAGE PROCESSING
+    # ═══════════════════════════════════════════════════════════════════════════
+    
+    gr.Markdown("## 🖼️ Image Classification")
+    img_input = gr.Image(type="filepath", label="Upload Image")
+    img_output = gr.Textbox(label="Classification Results", lines=5)
+    img_btn = gr.Button("Classify Image", variant="primary")
+    img_btn.click(run_image_classification, inputs=img_input, outputs=img_output)
+    
+    gr.Markdown("---")
+    
+    gr.Markdown("## 🎨 Text to Image Generation")
+    tti_input = gr.Textbox(
+        label="Image Description",
+        value="A beautiful sunset over mountains with a lake in the foreground",
+        placeholder="Describe the image you want to generate"
+    )
+    tti_output_img = gr.Image(label="Generated Image")
+    tti_output_text = gr.Textbox(label="Generation Status", lines=2)
+    tti_btn = gr.Button("Generate Image", variant="primary")
+    
+    def run_text_to_image_with_display(prompt):
+        status = run_text_to_image(prompt)
+        try:
+            if CLIENT and prompt and str(prompt).strip():
+                image = CLIENT.text_to_image(str(prompt).strip(), model="black-forest-labs/FLUX.1-schnell")
+                return image, status
+            else:
+                return None, status
+        except Exception as e:
+            return None, f"❌ Error: {str(e)}"
+    
+    tti_btn.click(run_text_to_image_with_display, inputs=tti_input, outputs=[tti_output_img, tti_output_text])
+    
+    # ═══════════════════════════════════════════════════════════════════════════
+    # 📋 SETUP & INFO
+    # ═══════════════════════════════════════════════════════════════════════════
+    
+    gr.Markdown("---")
+    gr.Markdown("""
+    ## 🔧 Setup Instructions
+    
+    **For full functionality:**
+    ```bash
+    # Install dependencies
+    pip install gradio huggingface_hub scipy
+    
+    # Set API token
+    export HF_API_TOKEN="your_token_here"
+    ```
+    
+    **Get your token:** https://huggingface.co/settings/tokens
+    
+    **📋 Dependency Status:**
+    - 🤖 HuggingFace Hub: {}
+    - 🎵 Scipy (for audio): {}
+    
+    **🎯 Available Capabilities:**
+    - 💬 **Chat** - Conversational AI with Qwen-2.5-72B
+    - 🎭 **Fill Mask** - Text completion with BERT
+    - ❓ **Q&A** - Question answering with RoBERTa
+    - 📝 **Summarization** - Text summarization with BART
+    - 🏷️ **Text Classification** - Sentiment analysis
+    - 🎯 **Zero-Shot Classification** - Custom label classification
+    - 🏷️ **NER** - Named entity recognition with BERT
+    - 🌐 **Translation** - English to French with Helsinki-NLP
+    - 🧮 **Feature Extraction** - Text embeddings with E5
+    - 🎤 **Speech Recognition** - Audio transcription with Whisper
+    - 🖼️ **Image Classification** - Visual analysis with ViT
+    - 🎨 **Text to Image** - AI image generation with FLUX
+    
+    **🚀 Perfect for research, education, and development!**
+    """.format(
+        "✅ Available" if HF_AVAILABLE else "❌ Missing",
+        "✅ Available" if SCIPY_AVAILABLE else "⚠️ Optional (needed for audio)"
+    ))
 
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False
-    )
+    )
+