feat(app): add Gradio AI chat and image generation app

- [add] Implement new Gradio web application (app.py)
- [feat] Add chat completion function with token management (app.py:chat_respond())
- [feat] Add image generation function with token management (app.py:generate_image())
- [feat] Implement image dimension validation utility (app.py:validate_dimensions())
- [feat] Set up Gradio UI with Chat Assistant and Image Generator tabs (app.py)
- [feat] Add handler for image generation button (app.py:on_generate_image())
- [add] Create new module for HF-Inferoxy proxy token utilities (hf_token_utils.py)
- [add] Define function to provision proxy tokens (hf_token_utils.py:get_proxy_token())
- [add] Define function to report token usage status (hf_token_utils.py:report_token_status())

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,272 @@
+---
+title: HF-Inferoxy AI Hub
+emoji: 🚀
+colorFrom: purple
+colorTo: blue
+sdk: gradio
+app_file: app.py
+pinned: false
+---
+
+# 🚀 HF-Inferoxy AI Hub
+
+A comprehensive AI platform that combines conversational AI and text-to-image generation capabilities with intelligent HuggingFace API token management through HF-Inferoxy.
+
+## ✨ Features
+
+### 💬 Chat Assistant
+- **🤖 Smart Conversations**: Advanced chat interface with streaming responses
+- **🎯 Model Flexibility**: Support for any HuggingFace chat model
+- **⚙️ Customizable Parameters**: Control temperature, top-p, max tokens, and system messages
+- **🌐 Multi-Provider Support**: Works with Cerebras, Cohere, Groq, Together, and more
+
+### 🎨 Image Generator
+- **🖼️ Text-to-Image Generation**: Create stunning images from text descriptions
+- **🎛️ Advanced Controls**: Fine-tune dimensions, inference steps, guidance scale, and seeds
+- **🎯 Multiple Providers**: HF Inference, Fal.ai, Nebius, NScale, Replicate, Together
+- **📱 Beautiful UI**: Modern interface with preset configurations and examples
+
+### 🔄 Smart Token Management
+- **🚀 Automatic Token Provisioning**: No manual token management required
+- **⚡ Intelligent Rotation**: Automatic switching when tokens fail or reach limits
+- **🛡️ Error Resilience**: Failed tokens are quarantined and replaced seamlessly
+- **📊 Usage Tracking**: Comprehensive monitoring of token usage and errors
+
+## 🛠️ Setup
+
+### 1. HuggingFace Space Secrets
+
+Add the following secret to your HuggingFace Space:
+
+- **Key**: `PROXY_KEY`
+- **Value**: Your HF-Inferoxy proxy API key
+
+### 2. HF-Inferoxy Server
+
+The app is configured to use the HF-Inferoxy server at: `http://scw.nazdev.tech:11155`
+
+### 3. Dependencies
+
+The app requires:
+- `gradio` - Modern web interface framework
+- `huggingface-hub` - HuggingFace API integration
+- `requests` - HTTP communication with the proxy
+- `Pillow` - Image processing capabilities
+- `torch` & `transformers` - Model support
+
+## 🎯 How It Works
+
+### Token Management Flow
+1. **Token Provisioning**: The app requests a valid token from the HF-Inferoxy server
+2. **API Calls**: Uses the provisioned token for HuggingFace API requests
+3. **Status Reporting**: Reports token usage success/failure back to the proxy
+4. **Automatic Rotation**: HF-Inferoxy handles token rotation and error management
+
+### Chat Assistant
+1. **Model Selection**: Choose any HuggingFace model with optional provider specification
+2. **Conversation**: Engage in natural conversations with streaming responses
+3. **Customization**: Adjust the AI's personality with system messages and parameters
+
+### Image Generation
+1. **Prompt Creation**: Write detailed descriptions of desired images
+2. **Model & Provider**: Select from preset combinations or specify custom ones
+3. **Parameter Tuning**: Fine-tune generation settings for optimal results
+4. **Image Creation**: Generate high-quality images with automatic token management
+
+## 🌟 Supported Models & Providers
+
+### Chat Models
+
+| Model | Provider | Description |
+|-------|----------|-------------|
+| `openai/gpt-oss-20b` | Fireworks AI, Cerebras, Groq | Fast general purpose model |
+| `meta-llama/Llama-2-7b-chat-hf` | HF Inference | Chat-optimized model |
+| `mistralai/Mistral-7B-Instruct-v0.2` | Featherless AI | Instruction following |
+| `CohereLabs/c4ai-command-r-plus` | Cohere | Advanced language model |
+
+### Image Models
+
+| Model | Provider | Description |
+|-------|----------|-------------|
+| `stabilityai/stable-diffusion-xl-base-1.0` | HF Inference, NScale | High-quality SDXL model |
+| `black-forest-labs/FLUX.1-dev` | Nebius, Together | State-of-the-art image model |
+| `Qwen/Qwen-Image` | Fal.ai, Replicate | Advanced image generation |
+
+## 🎨 Usage Examples
+
+### Chat Assistant
+
+#### Basic Conversation
+1. Go to the "💬 Chat Assistant" tab
+2. Type your message in the chat input
+3. Adjust parameters if needed (temperature, model, etc.)
+4. Watch the AI respond with streaming text
+
+#### Custom Model with Provider
+```
+Model Name: openai/gpt-oss-20b:fireworks-ai
+System Message: You are a helpful coding assistant specializing in Python.
+```
+
+### Image Generation
+
+#### Basic Image Creation
+1. Go to the "🎨 Image Generator" tab
+2. Enter your prompt: "A serene mountain lake at sunset, photorealistic, 8k"
+3. Choose a model and provider
+4. Click "🎨 Generate Image"
+
+#### Advanced Settings
+- **Dimensions**: 1024x1024 (must be divisible by 8)
+- **Inference Steps**: 20-50 for good quality
+- **Guidance Scale**: 7-10 for following prompts closely
+- **Negative Prompt**: "blurry, low quality, distorted"
+
+## ⚙️ Configuration Options
+
+### Chat Parameters
+- **System Message**: Define the AI's personality and behavior
+- **Max New Tokens**: Control response length (1-4096)
+- **Temperature**: Creativity level (0.1-2.0)
+- **Top-p**: Response diversity (0.1-1.0)
+
+### Image Parameters
+- **Prompt**: Detailed description of desired image
+- **Negative Prompt**: What to avoid in the image
+- **Dimensions**: Width and height (256-2048, divisible by 8)
+- **Inference Steps**: Quality vs speed trade-off (10-100)
+- **Guidance Scale**: Prompt adherence (1.0-20.0)
+- **Seed**: Reproducibility (-1 for random)
+
+## 🎯 Provider-Specific Features
+
+### Chat Providers
+- **Fireworks AI**: Fast and reliable inference service
+- **Cerebras**: High-performance inference with low latency
+- **Cohere**: Advanced language models with multilingual support
+- **Groq**: Ultra-fast inference, optimized for speed
+- **Together**: Collaborative AI hosting, wide model support
+- **Featherless AI**: Specialized fine-tuned models
+
+### Image Providers
+- **HF Inference**: Core API with comprehensive model support
+- **Fal.ai**: High-quality image generation with fast processing
+- **Nebius**: Cloud-native services with enterprise features
+- **NScale**: Optimized inference performance
+- **Replicate**: Collaborative AI hosting with version control
+- **Together**: Fast inference service with wide model support
+
+## 💡 Tips for Better Results
+
+### Chat Tips
+- **Clear Instructions**: Be specific about what you want
+- **System Messages**: Set context and personality upfront
+- **Model Selection**: Choose appropriate models for your task
+- **Parameter Tuning**: Lower temperature for factual responses, higher for creativity
+
+### Image Tips
+- **Detailed Prompts**: Use specific, descriptive language
+- **Style Keywords**: Include art style, lighting, and quality descriptors
+- **Negative Prompts**: Specify what you don't want to avoid common issues
+- **Aspect Ratios**: Consider the subject when choosing dimensions
+- **Provider Testing**: Try different providers for varied artistic styles
+
+### Example Prompts
+
+#### Chat Examples
+```
+"Explain quantum computing in simple terms"
+"Help me debug this Python code: [paste code]"
+"Write a creative story about a time-traveling cat"
+"What are the pros and cons of renewable energy?"
+```
+
+#### Image Examples
+```
+"A majestic dragon flying over a medieval castle, epic fantasy art, detailed, 8k"
+"A serene Japanese garden with cherry blossoms, zen atmosphere, peaceful, high quality"
+"A futuristic cityscape with flying cars and neon lights, cyberpunk style, cinematic"
+"Portrait of a wise old wizard with flowing robes, magical aura, fantasy character art"
+```
+
+## 🔒 Security & Authentication
+
+### RBAC System
+- All operations require authentication with the HF-Inferoxy proxy server
+- API keys are managed securely through HuggingFace Space secrets
+- No sensitive information is logged or exposed
+
+### Token Security
+- Tokens are automatically rotated when they fail or reach limits
+- Failed tokens are quarantined to prevent repeated failures
+- Usage is tracked comprehensively for monitoring and optimization
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+#### Setup Issues
+1. **PROXY_KEY Missing**: Ensure the secret is set in your HuggingFace Space settings
+2. **Connection Errors**: Verify the HF-Inferoxy server is accessible
+3. **Import Errors**: Check that all dependencies are properly installed
+
+#### Chat Issues
+1. **No Response**: Check model name format and provider availability
+2. **Slow Responses**: Try different providers or smaller models
+3. **Poor Quality**: Adjust temperature and top-p parameters
+
+#### Image Issues
+1. **Generation Fails**: Verify model supports text-to-image generation
+2. **Dimension Errors**: Ensure width and height are divisible by 8
+3. **Poor Quality**: Increase inference steps or adjust guidance scale
+
+### Error Types
+- **401 Errors**: Authentication issues (handled automatically by token rotation)
+- **402 Errors**: Credit limit exceeded (reported to proxy for token management)
+- **Network Errors**: Connection issues (reported to proxy for monitoring)
+- **Model Errors**: Invalid model or provider combinations
+
+## 📚 Additional Resources
+
+- **[HF-Inferoxy Documentation](https://nazdridoy.github.io/hf-inferoxy/)**: Complete platform documentation
+- **[HuggingFace Hub Integration Guide](https://nazdridoy.github.io/hf-inferoxy/huggingface-hub-integration/)**: Detailed integration instructions
+- **[Provider Examples](https://nazdridoy.github.io/hf-inferoxy/examples/)**: Code examples for different providers
+- **[Gradio Documentation](https://gradio.app/docs/)**: Interface framework documentation
+
+## 🤝 Contributing
+
+This application is part of the HF-Inferoxy ecosystem. For contributions or issues:
+
+1. Review the [HF-Inferoxy documentation](https://nazdridoy.github.io/hf-inferoxy/)
+2. Test with different models and providers
+3. Report any issues or suggest improvements
+4. Contribute examples and use cases
+
+## 🚀 Advanced Usage
+
+### Environment Variables
+
+You can customize the proxy URL using environment variables:
+
+```python
+import os
+os.environ["HF_PROXY_URL"] = "http://your-proxy-server:8000"
+```
+
+### Custom Providers
+
+The app supports any provider that works with HF-Inferoxy. Simply specify the provider name when entering model information.
+
+### Batch Operations
+
+For multiple operations, consider the token reuse patterns documented in the HF-Inferoxy integration guide.
+
+## 📄 License
+
+This project is part of the HF-Inferoxy ecosystem. Please refer to the main project for licensing information.
+
+---
+
+**Built with ❤️ using [HF-Inferoxy](https://nazdridoy.github.io/hf-inferoxy/) for intelligent token management**
+
+**Ready to explore AI? Start chatting or generating images above! 🚀**

app.py

@@ -0,0 +1,432 @@
+import gradio as gr
+import os
+from huggingface_hub import InferenceClient
+from huggingface_hub.errors import HfHubHTTPError
+from hf_token_utils import get_proxy_token, report_token_status
+import PIL.Image
+import io
+
+
+def chat_respond(
+    message,
+    history: list[dict[str, str]],
+    system_message,
+    model_name,
+    max_tokens,
+    temperature,
+    top_p,
+):
+    """
+    Chat completion function using HF-Inferoxy token management.
+    """
+    # Get proxy API key from environment variable (set in HuggingFace Space secrets)
+    proxy_api_key = os.getenv("PROXY_KEY")
+    if not proxy_api_key:
+        yield "❌ Error: PROXY_KEY not found in environment variables. Please set it in your HuggingFace Space secrets."
+        return
+    
+    try:
+        # Get token from HF-Inferoxy proxy server
+        print(f"🔑 Chat: Requesting token from proxy...")
+        token, token_id = get_proxy_token(api_key=proxy_api_key)
+        print(f"✅ Chat: Got token: {token_id}")
+        
+        # Parse model name and provider if specified
+        if ":" in model_name:
+            model, provider = model_name.split(":", 1)
+        else:
+            model = model_name
+            provider = None
+        
+        print(f"🤖 Chat: Using model='{model}', provider='{provider if provider else 'auto'}'")
+        
+        # Prepare messages first
+        messages = [{"role": "system", "content": system_message}]
+        messages.extend(history)
+        messages.append({"role": "user", "content": message})
+
+        print(f"💬 Chat: Prepared {len(messages)} messages, creating client...")
+        
+        # Create client with provider (auto if none specified) and always pass model
+        client = InferenceClient(
+            provider=provider if provider else "auto", 
+            api_key=token
+        )
+        
+        print(f"🚀 Chat: Client created, starting inference...")
+        
+        chat_completion_kwargs = {
+            "model": model,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "stream": True,
+            "temperature": temperature,
+            "top_p": top_p,
+        }
+
+        response = ""
+        
+        print(f"📡 Chat: Making streaming request...")
+        stream = client.chat_completion(**chat_completion_kwargs)
+        print(f"🔄 Chat: Got stream, starting to iterate...")
+
+        for message in stream:
+            choices = message.choices
+            token_content = ""
+            if len(choices) and choices[0].delta.content:
+                token_content = choices[0].delta.content
+
+            response += token_content
+            yield response
+        
+        # Report successful token usage
+        report_token_status(token_id, "success", api_key=proxy_api_key)
+        
+    except HfHubHTTPError as e:
+        # Report HF Hub errors
+        if 'token_id' in locals():
+            report_token_status(token_id, "error", str(e), api_key=proxy_api_key)
+        yield f"❌ HuggingFace API Error: {str(e)}"
+        
+    except Exception as e:
+        # Report other errors
+        if 'token_id' in locals():
+            report_token_status(token_id, "error", str(e), api_key=proxy_api_key)
+        yield f"❌ Unexpected Error: {str(e)}"
+
+
+def generate_image(
+    prompt: str,
+    model_name: str,
+    provider: str,
+    negative_prompt: str = "",
+    width: int = 1024,
+    height: int = 1024,
+    num_inference_steps: int = 20,
+    guidance_scale: float = 7.5,
+    seed: int = -1,
+):
+    """
+    Generate an image using the specified model and provider through HF-Inferoxy.
+    """
+    # Get proxy API key from environment variable (set in HuggingFace Space secrets)
+    proxy_api_key = os.getenv("PROXY_KEY")
+    if not proxy_api_key:
+        return None, "❌ Error: PROXY_KEY not found in environment variables. Please set it in your HuggingFace Space secrets."
+    
+    try:
+        # Get token from HF-Inferoxy proxy server
+        token, token_id = get_proxy_token(api_key=proxy_api_key)
+        
+        # Create client with specified provider
+        client = InferenceClient(
+            provider=provider,
+            api_key=token
+        )
+        
+        # Prepare generation parameters
+        generation_params = {
+            "model": model_name,
+            "prompt": prompt,
+            "width": width,
+            "height": height,
+            "num_inference_steps": num_inference_steps,
+            "guidance_scale": guidance_scale,
+        }
+        
+        # Add optional parameters if provided
+        if negative_prompt:
+            generation_params["negative_prompt"] = negative_prompt
+        if seed != -1:
+            generation_params["seed"] = seed
+        
+        # Generate image
+        image = client.text_to_image(**generation_params)
+        
+        # Report successful token usage
+        report_token_status(token_id, "success", api_key=proxy_api_key)
+        
+        return image, f"✅ Image generated successfully using {model_name} on {provider}!"
+        
+    except HfHubHTTPError as e:
+        # Report HF Hub errors
+        if 'token_id' in locals():
+            report_token_status(token_id, "error", str(e), api_key=proxy_api_key)
+        return None, f"❌ HuggingFace API Error: {str(e)}"
+        
+    except Exception as e:
+        # Report other errors
+        if 'token_id' in locals():
+            report_token_status(token_id, "error", str(e), api_key=proxy_api_key)
+        return None, f"❌ Unexpected Error: {str(e)}"
+
+
+def validate_dimensions(width, height):
+    """Validate that dimensions are divisible by 8 (required by most diffusion models)"""
+    if width % 8 != 0 or height % 8 != 0:
+        return False, "Width and height must be divisible by 8"
+    return True, ""
+
+
+# Create the main Gradio interface with tabs
+with gr.Blocks(title="HF-Inferoxy AI Hub", theme=gr.themes.Soft()) as demo:
+    
+    # Main header
+    gr.Markdown("""
+    # 🚀 HF-Inferoxy AI Hub
+    
+    A comprehensive AI platform combining chat and image generation capabilities with intelligent token management through HF-Inferoxy.
+    
+    **Features:**
+    - 💬 **Smart Chat**: Conversational AI with streaming responses
+    - 🎨 **Image Generation**: Text-to-image creation with multiple providers  
+    - 🔄 **Intelligent Token Management**: Automatic token rotation and error handling
+    - 🌐 **Multi-Provider Support**: Works with HF Inference, Cerebras, Cohere, Groq, Together, Fal.ai, and more
+    """)
+    
+    with gr.Tabs() as tabs:
+        
+        # ==================== CHAT TAB ====================
+        with gr.Tab("💬 Chat Assistant", id="chat"):
+            with gr.Row():
+                with gr.Column(scale=3):
+                    # Create chat interface
+                    chatbot = gr.ChatInterface(
+                        chat_respond,
+                        type="messages",
+                        title="",
+                        description="",
+                        additional_inputs=[
+                            gr.Textbox(
+                                value="You are a helpful and friendly AI assistant. Provide clear, accurate, and helpful responses.",
+                                label="System Message",
+                                lines=2,
+                                placeholder="Define the assistant's personality and behavior..."
+                            ),
+                            gr.Textbox(
+                                value="openai/gpt-oss-20b:fireworks-ai",
+                                label="Model Name",
+                                placeholder="e.g., openai/gpt-oss-20b:fireworks-ai or mistralai/Mistral-7B-Instruct-v0.2:groq"
+                            ),
+                            gr.Slider(
+                                minimum=1, maximum=4096, value=1024, step=1,
+                                label="Max New Tokens"
+                            ),
+                            gr.Slider(
+                                minimum=0.1, maximum=2.0, value=0.7, step=0.1,
+                                label="Temperature"
+                            ),
+                            gr.Slider(
+                                minimum=0.1, maximum=1.0, value=0.95, step=0.05,
+                                label="Top-p (nucleus sampling)"
+                            ),
+                        ],
+                    )
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("""
+                    ### 💡 Chat Tips
+                    
+                    **Model Format:**
+                    - Single model: `openai/gpt-oss-20b`
+                    - With provider: `model:provider`
+                    
+                    **Popular Models:**
+                    - `openai/gpt-oss-20b` - Fast general purpose
+                    - `meta-llama/Llama-2-7b-chat-hf` - Chat optimized
+                    - `microsoft/DialoGPT-medium` - Conversation
+                    - `google/flan-t5-base` - Instruction following
+                    
+                    **Popular Providers:**
+                    - `fireworks-ai` - Fast and reliable
+                    - `cerebras` - High performance
+                    - `groq` - Ultra-fast inference  
+                    - `together` - Wide model support
+                    - `cohere` - Advanced language models
+                    
+                    **Example:**
+                    `openai/gpt-oss-20b:fireworks-ai`
+                    """)
+        
+        # ==================== IMAGE GENERATION TAB ====================
+        with gr.Tab("🎨 Image Generator", id="image"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    # Image output
+                    output_image = gr.Image(
+                        label="Generated Image", 
+                        type="pil",
+                        height=600,
+                        show_download_button=True
+                    )
+                    status_text = gr.Textbox(
+                        label="Generation Status", 
+                        interactive=False,
+                        lines=2
+                    )
+                
+                with gr.Column(scale=1):
+                    # Model and provider inputs
+                    with gr.Group():
+                        gr.Markdown("**🤖 Model & Provider**")
+                        img_model_name = gr.Textbox(
+                            value="stabilityai/stable-diffusion-xl-base-1.0",
+                            label="Model Name",
+                            placeholder="e.g., stabilityai/stable-diffusion-xl-base-1.0"
+                        )
+                        img_provider = gr.Dropdown(
+                            choices=["hf-inference", "fal-ai", "nebius", "nscale", "replicate", "together"],
+                            value="hf-inference",
+                            label="Provider",
+                            interactive=True
+                        )
+                    
+                    # Generation parameters
+                    with gr.Group():
+                        gr.Markdown("**📝 Prompts**")
+                        img_prompt = gr.Textbox(
+                            value="A beautiful landscape with mountains and a lake at sunset, photorealistic, 8k, highly detailed",
+                            label="Prompt",
+                            lines=3,
+                            placeholder="Describe the image you want to generate..."
+                        )
+                        img_negative_prompt = gr.Textbox(
+                            value="blurry, low quality, distorted, deformed, ugly, bad anatomy",
+                            label="Negative Prompt",
+                            lines=2,
+                            placeholder="Describe what you DON'T want in the image..."
+                        )
+                    
+                    with gr.Group():
+                        gr.Markdown("**⚙️ Generation Settings**")
+                        with gr.Row():
+                            img_width = gr.Slider(
+                                minimum=256, maximum=2048, value=1024, step=64,
+                                label="Width", info="Must be divisible by 8"
+                            )
+                            img_height = gr.Slider(
+                                minimum=256, maximum=2048, value=1024, step=64,
+                                label="Height", info="Must be divisible by 8"
+                            )
+                        
+                        with gr.Row():
+                            img_steps = gr.Slider(
+                                minimum=10, maximum=100, value=20, step=1,
+                                label="Inference Steps", info="More steps = better quality"
+                            )
+                            img_guidance = gr.Slider(
+                                minimum=1.0, maximum=20.0, value=7.5, step=0.5,
+                                label="Guidance Scale", info="How closely to follow prompt"
+                            )
+                        
+                        img_seed = gr.Slider(
+                            minimum=-1, maximum=999999, value=-1, step=1,
+                            label="Seed", info="-1 for random"
+                        )
+                    
+                    # Generate button
+                    generate_btn = gr.Button(
+                        "🎨 Generate Image", 
+                        variant="primary", 
+                        size="lg",
+                        scale=2
+                    )
+                    
+                    # Quick model presets
+                    with gr.Group():
+                        gr.Markdown("**🎯 Popular Presets**")
+                        preset_buttons = []
+                        presets = [
+                            ("SDXL (HF)", "stabilityai/stable-diffusion-xl-base-1.0", "hf-inference"),
+                            ("FLUX.1 (Nebius)", "black-forest-labs/FLUX.1-dev", "nebius"), 
+                            ("Qwen (Fal.ai)", "Qwen/Qwen-Image", "fal-ai"),
+                            ("SDXL (NScale)", "stabilityai/stable-diffusion-xl-base-1.0", "nscale"),
+                        ]
+                        
+                        for name, model, provider in presets:
+                            btn = gr.Button(name, size="sm")
+                            btn.click(
+                                lambda m=model, p=provider: (m, p),
+                                outputs=[img_model_name, img_provider]
+                            )
+            
+            # Examples for image generation
+            with gr.Group():
+                gr.Markdown("**🌟 Example Prompts**")
+                img_examples = gr.Examples(
+                    examples=[
+                        ["A majestic dragon flying over a medieval castle, epic fantasy art, detailed, 8k"],
+                        ["A serene Japanese garden with cherry blossoms, zen atmosphere, peaceful, high quality"],
+                        ["A futuristic cityscape with flying cars and neon lights, cyberpunk style, cinematic"],
+                        ["A cute robot cat playing with yarn, adorable, cartoon style, vibrant colors"],
+                        ["A magical forest with glowing mushrooms and fairy lights, fantasy, ethereal beauty"],
+                        ["Portrait of a wise old wizard with flowing robes, magical aura, fantasy character art"],
+                        ["A cozy coffee shop on a rainy day, warm lighting, peaceful atmosphere, detailed"],
+                        ["An astronaut floating in space with Earth in background, photorealistic, stunning"]
+                    ],
+                    inputs=img_prompt
+                )
+    
+    # Event handlers for image generation
+    def on_generate_image(prompt_val, model_val, provider_val, negative_prompt_val, width_val, height_val, steps_val, guidance_val, seed_val):
+        # Validate dimensions
+        is_valid, error_msg = validate_dimensions(width_val, height_val)
+        if not is_valid:
+            return None, f"❌ Validation Error: {error_msg}"
+        
+        # Generate image
+        return generate_image(
+            prompt=prompt_val,
+            model_name=model_val,
+            provider=provider_val,
+            negative_prompt=negative_prompt_val,
+            width=width_val,
+            height=height_val,
+            num_inference_steps=steps_val,
+            guidance_scale=guidance_val,
+            seed=seed_val
+        )
+    
+    # Connect image generation events
+    generate_btn.click(
+        fn=on_generate_image,
+        inputs=[
+            img_prompt, img_model_name, img_provider, img_negative_prompt,
+            img_width, img_height, img_steps, img_guidance, img_seed
+        ],
+        outputs=[output_image, status_text]
+    )
+    
+    # Footer with helpful information
+    gr.Markdown("""
+    ---
+    ### 📚 How to Use
+    
+    **Chat Tab:**
+    - Enter your message and customize the AI's behavior with system messages
+    - Choose models and providers using the format `model:provider` 
+    - Adjust temperature for creativity and top-p for response diversity
+    
+    **Image Tab:**
+    - Write detailed prompts describing your desired image
+    - Use negative prompts to avoid unwanted elements  
+    - Experiment with different models and providers for varied styles
+    - Higher inference steps = better quality but slower generation
+    
+    **Supported Providers:**
+    - **hf-inference**: Core API with comprehensive model support
+    - **cerebras**: High-performance inference 
+    - **cohere**: Advanced language models with multilingual support
+    - **groq**: Ultra-fast inference, optimized for speed
+    - **together**: Collaborative AI hosting, wide model support
+    - **fal-ai**: High-quality image generation
+    - **nebius**: Cloud-native services with enterprise features
+    - **nscale**: Optimized inference performance 
+    - **replicate**: Collaborative AI hosting
+    
+    **Built with ❤️ using [HF-Inferoxy](https://nazdridoy.github.io/hf-inferoxy/) for intelligent token management**
+    """)
+
+
+if __name__ == "__main__":
+    demo.launch()

hf_token_utils.py

@@ -0,0 +1,83 @@
+# hf_token_utils.py
+import os
+import requests
+import json
+from typing import Dict, Optional, Any, Tuple
+
+def get_proxy_token(proxy_url: str = "http://scw.nazdev.tech:11155", api_key: str = None) -> Tuple[str, str]:
+    """
+    Get a valid token from the proxy server.
+    
+    Args:
+        proxy_url: URL of the HF-Inferoxy server
+        api_key: Your API key for authenticating with the proxy server
+        
+    Returns:
+        Tuple of (token, token_id)
+        
+    Raises:
+        Exception: If token provisioning fails
+    """
+    headers = {}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    
+    response = requests.get(f"{proxy_url}/keys/provision", headers=headers)
+    if response.status_code != 200:
+        raise Exception(f"Failed to provision token: {response.text}")
+    
+    data = response.json()
+    token = data["token"]
+    token_id = data["token_id"]
+    
+    # For convenience, also set environment variable
+    os.environ["HF_TOKEN"] = token
+    
+    return token, token_id
+
+def report_token_status(
+    token_id: str, 
+    status: str = "success", 
+    error: Optional[str] = None,
+    proxy_url: str = "http://scw.nazdev.tech:11155",
+    api_key: str = None
+) -> bool:
+    """
+    Report token usage status back to the proxy server.
+    
+    Args:
+        token_id: ID of the token to report (from get_proxy_token)
+        status: Status to report ('success' or 'error')
+        error: Error message if status is 'error'
+        proxy_url: URL of the HF-Inferoxy server
+        api_key: Your API key for authenticating with the proxy server
+        
+    Returns:
+        True if report was accepted, False otherwise
+    """
+    payload = {"token_id": token_id, "status": status}
+    
+    if error:
+        payload["error"] = error
+        
+        # Extract error classification based on actual HF error patterns
+        error_type = None
+        if "401 Client Error" in error:
+            error_type = "invalid_credentials"
+        elif "402 Client Error" in error and "exceeded your monthly included credits" in error:
+            error_type = "credits_exceeded"
+            
+        if error_type:
+            payload["error_type"] = error_type
+    
+    headers = {"Content-Type": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+        
+    try:
+        response = requests.post(f"{proxy_url}/keys/report", json=payload, headers=headers)
+        return response.status_code == 200
+    except Exception as e:
+        # Silently fail to avoid breaking the client application
+        # In production, consider logging this error
+        return False

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+huggingface-hub
+requests
+Pillow