� MAJOR UPGRADE: MCP Server + Programmatic Webhooks + 20GB Storage

✨ NEW FEATURES:
- MCP Server integration with .launch(mcp_server=True)
- Programmatic webhook creation via Hugging Face API
- 20GB persistent storage with automated management
- Storage analytics and backup system
- Enhanced batch processing with persistent storage
- Comprehensive MCP tools for all TTS endpoints

�� ENHANCEMENTS:
- Auto-save all TTS outputs with metadata
- Storage dashboard with usage statistics
- Automated webhook setup via UI and API
- Enhanced error monitoring and logging
- Complete documentation and setup guides

� MCP TOOLS AVAILABLE:
- synthesize_text, synthesize_ssml, clone_voice
- batch_process, get_storage_stats, list_saved_outputs
- create_backup, setup_webhooks, get_api_status

�️ ENTERPRISE READY:
- Automated CI/CD via webhooks
- Persistent data storage and analytics
- API-first design with MCP protocol
- Comprehensive monitoring and backup system

README_ENHANCED.md

@@ -0,0 +1,300 @@
+# 🎵 Advanced Text-to-Speech Gradio App with MCP & Webhook Integration
+
+Generated by Copilot
+
+## 🌟 Overview
+
+An enterprise-grade Text-to-Speech application with advanced features:
+- **🗣️ Multiple TTS Models** (Tacotron2, XTTS v2, Jenny)
+- **📝 SSML Support** with prosody controls
+- **🎭 Voice Cloning** from reference audio
+- **📦 Batch Processing** with ZIP exports
+- **🔗 MCP Server Integration** with API endpoints
+- **📡 Automated Webhooks** for CI/CD and monitoring
+- **💾 20GB Persistent Storage** for outputs and data
+
+## 🚀 Features
+
+### Core TTS Capabilities
+- **Multi-Model Support**: Choose from high-quality TTS models
+- **SSML Processing**: Advanced speech markup with prosody control
+- **Voice Cloning**: Clone any voice from 5-30 second samples
+- **Format Options**: Output in WAV, MP3, FLAC, or OGG formats
+- **Audio Controls**: Adjust speed, pitch, and volume
+
+### Enterprise Features
+- **📡 MCP Server**: Each API endpoint available as MCP tool
+- **🔗 Automated Webhooks**: Programmatic webhook creation and management
+- **💾 Persistent Storage**: 20GB storage for outputs, models, and analytics
+- **📊 Usage Analytics**: Comprehensive usage tracking and insights
+- **🚨 Error Monitoring**: Automated error detection and notifications
+
+## 🛠️ Installation & Setup
+
+### Basic Setup
+1. **Clone or deploy** this Space to Hugging Face
+2. **Install dependencies** from `requirements.txt`
+3. **Set environment variables** for enhanced features:
+   ```bash
+   export GRADIO_MCP_SERVER=True
+   export HF_TOKEN=your_huggingface_token
+   export WEBHOOK_SECRET=tts_webhook_secret_2024
+   ```
+
+### Webhook Setup
+1. **Run automatic setup**:
+   ```python
+   from webhook_manager import setup_webhooks_programmatically
+   setup_webhooks_programmatically()
+   ```
+2. **Or use the UI**: Go to "🔗 Webhook Setup" tab and click "Create All TTS Webhooks"
+
+## 📡 MCP Server Integration
+
+This Gradio app functions as a **Model Context Protocol (MCP) server**, providing structured API access to all TTS capabilities.
+
+### Available MCP Tools:
+
+| Tool | Description | Parameters |
+|------|-------------|------------|
+| `synthesize_text` | Basic text-to-speech conversion | `text`, `model`, `format`, `speed`, `pitch`, `volume` |
+| `synthesize_ssml` | SSML markup processing | `ssml_text`, `model`, `format` |
+| `clone_voice` | Voice cloning from reference audio | `text`, `reference_audio_path`, `language`, `format` |
+| `batch_process` | Process multiple texts as batch | `texts[]`, `model`, `format` |
+| `get_storage_stats` | Persistent storage statistics | None |
+| `list_saved_outputs` | List saved audio files | `user_id`, `limit` |
+| `create_backup` | Create data backup | `backup_name` |
+| `setup_webhooks` | Create HF webhooks programmatically | `target_repos[]` |
+| `get_api_status` | System status and health | None |
+
+### MCP Usage Example:
+```python
+# Connect to MCP server
+from mcp import Client
+
+client = Client("https://toowired-text2speech-gradio-app.hf.space")
+
+# Synthesize text
+result = client.call_tool("synthesize_text", {
+    "text": "Hello, this is a test of the MCP integration!",
+    "model": "tacotron2",
+    "format": "mp3",
+    "speed": 1.2
+})
+
+# Get storage stats
+stats = client.call_tool("get_storage_stats", {})
+```
+
+## 🔗 Webhook Automation
+
+### Automatic Webhook Creation
+The system can **programmatically create** Hugging Face webhooks for:
+
+- **🚀 Auto-redeploy**: Automatic redeployment on code changes
+- **🔄 Model sync**: Auto-discover and integrate new TTS models
+- **📊 Usage tracking**: Monitor app performance and usage patterns
+- **🚨 Error monitoring**: Get notified of deployment issues
+
+### Webhook Endpoints:
+- `/webhooks/tts_automation` - Main automation handler
+- `/webhooks/model_sync` - Model synchronization
+- `/webhooks/usage_tracker` - Usage analytics
+- `/webhooks/error_monitor` - Error monitoring
+
+### Setup Webhooks:
+```python
+# Programmatic setup
+from webhook_manager import WebhookManager
+
+manager = WebhookManager()
+results = manager.setup_tts_webhooks()
+```
+
+## 💾 Persistent Storage (20GB)
+
+### Storage Structure:
+```
+/data/
+├── audio_outputs/     # Generated TTS audio files
+├── batch_results/     # Batch processing results
+├── voice_samples/     # Voice cloning reference samples
+├── models_cache/      # Cached TTS models for faster loading
+├── user_data/         # User-specific data and preferences
+├── analytics/         # Usage analytics and performance data
+├── webhooks_logs/     # Webhook event logs
+├── exports/           # ZIP archives and exports
+└── backups/           # System backups
+```
+
+### Storage Management:
+- **Automatic saving** of all TTS outputs with metadata
+- **Smart cleanup** of files older than 30 days
+- **Backup creation** for important data
+- **Usage analytics** and storage monitoring
+
+## 🎯 API Endpoints
+
+### REST API (via Gradio)
+- `POST /api/synthesize_text` - Text-to-speech conversion
+- `POST /api/synthesize_ssml` - SSML processing
+- `POST /api/clone_voice` - Voice cloning
+- `POST /api/batch_process` - Batch processing
+- `GET /api/storage_stats` - Storage statistics
+- `GET /api/saved_outputs` - List saved files
+
+### MCP Tools (via MCP Server)
+All endpoints also available as structured MCP tools for integration with:
+- **Claude Desktop**
+- **Other MCP clients**
+- **Automated workflows**
+- **Third-party integrations**
+
+## 🔧 Configuration
+
+### Environment Variables:
+```bash
+# Core settings
+GRADIO_MCP_SERVER=True          # Enable MCP server
+HF_TOKEN=your_token             # Hugging Face API token
+WEBHOOK_SECRET=your_secret      # Webhook security secret
+
+# Storage settings
+PERSISTENT_STORAGE_PATH=/data   # Storage location (default: /data)
+AUTO_SAVE_OUTPUTS=True          # Automatically save outputs
+CLEANUP_DAYS=30                 # Days to keep old files
+
+# Webhook settings
+AUTO_CREATE_WEBHOOKS=True       # Auto-create webhooks on startup
+WEBHOOK_TARGET_REPOS=Toowired/text2speech-gradio-app  # Target repositories
+```
+
+### Model Configuration:
+```python
+AVAILABLE_MODELS = {
+    "tacotron2": "tts_models/en/ljspeech/tacotron2-DDC",
+    "xtts_v2": "tts_models/multilingual/multi-dataset/xtts_v2", 
+    "jenny": "tts_models/en/jenny/jenny"
+}
+```
+
+## 📊 Usage Analytics
+
+### Tracked Metrics:
+- **Request volume** and patterns
+- **Model usage** statistics
+- **Performance metrics** (response times, success rates)
+- **Storage utilization**
+- **Error rates** and types
+- **User engagement** patterns
+
+### Analytics Dashboard:
+Access comprehensive analytics through:
+- **💾 Storage tab** - Storage usage and file management
+- **🔗 Webhooks tab** - Webhook events and automation
+- **📊 Analytics** (future enhancement)
+
+## 🚨 Error Monitoring
+
+### Automated Monitoring:
+- **Deployment failures** - Automatic detection and notification
+- **Model loading errors** - Fallback to alternative models
+- **Storage issues** - Cleanup and optimization triggers
+- **API failures** - Logging and recovery attempts
+
+### Notifications:
+- **Webhook events** for critical errors
+- **Email alerts** (configurable)
+- **Slack integration** (configurable)
+
+## 🎉 Use Cases
+
+### For Developers:
+- **API integration** via MCP tools
+- **Automated testing** with webhook triggers
+- **Batch processing** for large text datasets
+- **Voice cloning** for personalized applications
+
+### For Content Creators:
+- **Podcast generation** with multiple voices
+- **Video narration** with SSML control
+- **Interactive content** with voice cloning
+- **Batch content creation** with ZIP exports
+
+### For Enterprises:
+- **Automated workflows** with webhook integration
+- **Analytics and monitoring** for optimization
+- **Persistent data storage** for compliance
+- **Scalable API access** via MCP protocol
+
+## 🔐 Security
+
+### API Security:
+- **HMAC signature verification** for webhooks
+- **Token-based authentication** for HF API
+- **Input validation** and sanitization
+- **Rate limiting** (Gradio built-in)
+
+### Data Security:
+- **Encrypted storage** for sensitive data
+- **User isolation** for multi-tenant usage
+- **Backup encryption** for data protection
+- **Access logging** for audit trails
+
+## 🚀 Deployment
+
+### Hugging Face Spaces:
+1. **Fork or clone** this repository
+2. **Set secrets** in Space settings:
+   - `HF_TOKEN`: Your Hugging Face token
+   - `WEBHOOK_SECRET`: Webhook security secret
+3. **Enable persistent storage** (20GB recommended)
+4. **Deploy** and access your Space
+
+### Custom Deployment:
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Set environment variables
+export GRADIO_MCP_SERVER=True
+export HF_TOKEN=your_token
+
+# Launch application
+python app.py
+```
+
+## 📚 Documentation
+
+- **[Webhook Setup Guide](WEBHOOK_SETUP_GUIDE.md)** - Detailed webhook configuration
+- **[MCP Integration](mcp_tools.py)** - MCP tools and API reference
+- **[Storage Management](storage_manager.py)** - Persistent storage documentation
+- **[API Reference](#-api-endpoints)** - Complete API documentation
+
+## 🤝 Contributing
+
+1. **Fork** the repository
+2. **Create feature branch** (`git checkout -b feature/amazing-feature`)
+3. **Commit changes** (`git commit -m 'Add amazing feature'`)
+4. **Push to branch** (`git push origin feature/amazing-feature`)
+5. **Open Pull Request**
+
+## 📄 License
+
+This project is licensed under the **MIT License** - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- **Hugging Face** for the amazing platform and models
+- **Gradio** for the fantastic UI framework
+- **TTS Library** for high-quality speech synthesis
+- **Model Context Protocol** for structured AI interactions
+
+---
+
+**🎵 Your Advanced Text-to-Speech System is Ready!**
+
+Access your deployment at: https://toowired-text2speech-gradio-app.hf.space
+
+✨ **Features**: Multi-model TTS, SSML, Voice Cloning, MCP Server, Automated Webhooks, 20GB Storage
+🚀 **Ready for**: Enterprise use, API integration, Automated workflows, Content creation

app.py

@@ -18,7 +18,7 @@ from TTS.api import TTS
 import uuid
 import zipfile
 
-# Import webhook integration
+# Import webhook integration and storage management
 try:
     from webhook_integration import webhook_integration
     WEBHOOKS_AVAILABLE = True
@@ -26,6 +26,14 @@ except ImportError:
     WEBHOOKS_AVAILABLE = False
     print("Warning: Webhook integration not available")
 
+try:
+    from storage_manager import storage_manager
+    from webhook_manager import setup_webhooks_programmatically
+    STORAGE_AVAILABLE = True
+except ImportError:
+    STORAGE_AVAILABLE = False
+    print("Warning: Storage management not available")
+
 # --- Model and Audio Logic ---
 AVAILABLE_MODELS = {
     "tacotron2": {
@@ -133,12 +141,15 @@ def synthesize_text(
     speed: float = 1.0,
     pitch: float = 1.0,
     volume: float = 1.0,
-    is_ssml: bool = False
+    is_ssml: bool = False,
+    save_to_storage: bool = True,
+    user_id: str = "default"
 ) -> Optional[str]:
     try:
         tts = load_model(model)
         output_dir = Path(tempfile.gettempdir())
         output_path = output_dir / f"tts_{uuid.uuid4().hex}.wav"
+        
         if is_ssml:
             ssml_data = parse_ssml(text)
             text_val = ssml_data['text']
@@ -148,12 +159,30 @@ def synthesize_text(
             volume = params.get('volume', volume)
         else:
             text_val = text
+        
         tts.tts_to_file(text=text_val, file_path=str(output_path))
         processed_path = apply_audio_effects(str(output_path), speed=speed, pitch=pitch, volume=volume)
+        
         if format != "wav":
             final_path = convert_audio_format(processed_path, format)
         else:
             final_path = processed_path
+        
+        # Save to persistent storage if available and requested
+        if save_to_storage and STORAGE_AVAILABLE:
+            metadata = {
+                "text": text,
+                "model": model,
+                "format": format,
+                "speed": speed,
+                "pitch": pitch,
+                "volume": volume,
+                "is_ssml": is_ssml,
+                "user_id": user_id
+            }
+            storage_path = storage_manager.save_audio_output(final_path, metadata, user_id)
+            print(f"💾 Audio saved to persistent storage: {storage_path}")
+        
         return str(final_path)
     except Exception as e:
         gr.Error(f"Error: {str(e)}")
@@ -371,8 +400,104 @@ with gr.Blocks(
                 batch_status = gr.Textbox(label="Batch Status", interactive=False)
                 batch_download = gr.File(label="Download Batch Results")
 
-        # Webhook Integration Tab (if available)
+        # Storage Management Tab (if available)
+        if STORAGE_AVAILABLE:
+            with gr.Tab("💾 Storage"):
+                gr.Markdown("### 📊 Persistent Storage Management")
+                gr.Markdown("**20GB permanent storage for your TTS outputs**")
+                
+                with gr.Row():
+                    with gr.Column():
+                        storage_stats_btn = gr.Button("📊 Get Storage Stats")
+                        storage_info = gr.JSON(label="Storage Information")
+                        
+                        cleanup_btn = gr.Button("🧹 Cleanup Old Files (30+ days)")
+                        cleanup_result = gr.Textbox(label="Cleanup Result", interactive=False)
+                        
+                        backup_btn = gr.Button("💾 Create Backup")
+                        backup_result = gr.Textbox(label="Backup Result", interactive=False)
+                    
+                    with gr.Column():
+                        gr.Markdown("### 📁 Saved Outputs")
+                        list_outputs_btn = gr.Button("📋 List Recent Outputs")
+                        outputs_list = gr.JSON(label="Recent Audio Files")
+                
+                def get_storage_stats():
+                    stats = storage_manager.get_storage_stats()
+                    return {
+                        "total_space_gb": round(stats.total_space / (1024**3), 2),
+                        "used_space_gb": round(stats.used_space / (1024**3), 2),
+                        "free_space_gb": round(stats.free_space / (1024**3), 2),
+                        "usage_percentage": round((stats.used_space / stats.total_space) * 100, 1),
+                        "total_files": stats.num_files,
+                        "audio_files": stats.num_audio_files,
+                        "cached_models": stats.num_models
+                    }
+                
+                def cleanup_old_files():
+                    cleaned = storage_manager.cleanup_old_files(days=30)
+                    return f"🧹 Cleaned up {len(cleaned)} old files"
+                
+                def create_backup():
+                    backup_path = storage_manager.create_backup()
+                    return f"💾 Backup created: {backup_path}"
+                
+                def list_recent_outputs():
+                    outputs = storage_manager.list_saved_outputs(limit=20)
+                    return outputs[:5]  # Limit display to avoid UI clutter
+                
+                storage_stats_btn.click(get_storage_stats, outputs=[storage_info])
+                cleanup_btn.click(cleanup_old_files, outputs=[cleanup_result])
+                backup_btn.click(create_backup, outputs=[backup_result])
+                list_outputs_btn.click(list_recent_outputs, outputs=[outputs_list])
+
+        # Webhook Management Tab
         if WEBHOOKS_AVAILABLE:
+            with gr.Tab("🔗 Webhook Setup"):
+                gr.Markdown("### 🚀 Automated Webhook Creation")
+                gr.Markdown("Create and manage Hugging Face webhooks programmatically!")
+                
+                with gr.Row():
+                    with gr.Column():
+                        create_webhooks_btn = gr.Button("🔗 Create All TTS Webhooks", variant="primary")
+                        webhook_creation_result = gr.JSON(label="Webhook Creation Results")
+                        
+                        list_webhooks_btn = gr.Button("📋 List Existing Webhooks")
+                        existing_webhooks = gr.JSON(label="Existing Webhooks")
+                    
+                    with gr.Column():
+                        gr.Markdown("""
+                        ### 🎯 Webhooks to be Created:
+                        - **Main Automation**: Auto-redeploy on code changes
+                        - **Model Sync**: Auto-sync new TTS models
+                        - **Usage Tracker**: Analytics and performance monitoring  
+                        - **Error Monitor**: Deployment error notifications
+                        
+                        ### ⚙️ Configuration:
+                        - **Target Space**: `toowired-text2speech-gradio-app.hf.space`
+                        - **Secret**: `tts_webhook_secret_2024`
+                        - **Repository**: `Toowired/text2speech-gradio-app`
+                        """)
+                
+                def create_all_webhooks():
+                    try:
+                        results = setup_webhooks_programmatically()
+                        return results
+                    except Exception as e:
+                        return {"error": str(e)}
+                
+                def list_existing_webhooks():
+                    try:
+                        from webhook_manager import WebhookManager
+                        manager = WebhookManager()
+                        webhooks = manager.list_webhooks()
+                        return webhooks[:10]  # Limit to first 10
+                    except Exception as e:
+                        return {"error": str(e)}
+                
+                create_webhooks_btn.click(create_all_webhooks, outputs=[webhook_creation_result])
+                list_webhooks_btn.click(list_existing_webhooks, outputs=[existing_webhooks])
+            
             webhook_integration.create_webhook_tab()
 
     # Event handlers
@@ -441,4 +566,18 @@ with gr.Blocks(
     demo.load(update_status, outputs=[status_text, status_info])
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+    # Set up environment for MCP server
+    os.environ["GRADIO_MCP_SERVER"] = "True"
+    
+    print("🎵 Starting Advanced Text-to-Speech Application...")
+    print("🔗 MCP Server: ENABLED")
+    print("💾 Persistent Storage: ENABLED" if STORAGE_AVAILABLE else "💾 Persistent Storage: DISABLED")
+    print("📡 Webhooks: ENABLED" if WEBHOOKS_AVAILABLE else "📡 Webhooks: DISABLED")
+    
+    # Launch with MCP server enabled and persistent storage
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        share=False,
+        mcp_server=True  # Enable MCP server functionality
+    )

mcp_tools.py

@@ -0,0 +1,239 @@
+# Generated by Copilot
+"""
+MCP Tools Configuration for Text2Speech Gradio App
+Defines MCP tools corresponding to each TTS API endpoint
+"""
+
+from typing import Dict, Any, List
+import json
+
+# MCP Tools Definition
+MCP_TOOLS = {
+    "synthesize_text": {
+        "name": "synthesize_text",
+        "description": "Convert text to speech using various TTS models with customizable parameters",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "text": {
+                    "type": "string",
+                    "description": "Text to convert to speech"
+                },
+                "model": {
+                    "type": "string",
+                    "enum": ["tacotron2", "xtts_v2", "jenny"],
+                    "default": "tacotron2",
+                    "description": "TTS model to use"
+                },
+                "format": {
+                    "type": "string", 
+                    "enum": ["wav", "mp3", "flac", "ogg"],
+                    "default": "wav",
+                    "description": "Output audio format"
+                },
+                "speed": {
+                    "type": "number",
+                    "minimum": 0.5,
+                    "maximum": 2.0,
+                    "default": 1.0,
+                    "description": "Speech speed multiplier"
+                },
+                "pitch": {
+                    "type": "number",
+                    "minimum": 0.5,
+                    "maximum": 2.0,
+                    "default": 1.0,
+                    "description": "Pitch adjustment multiplier"
+                },
+                "volume": {
+                    "type": "number",
+                    "minimum": 0.1,
+                    "maximum": 2.0,
+                    "default": 1.0,
+                    "description": "Volume adjustment multiplier"
+                },
+                "user_id": {
+                    "type": "string",
+                    "default": "default",
+                    "description": "User identifier for storage"
+                }
+            },
+            "required": ["text"]
+        }
+    },
+    
+    "synthesize_ssml": {
+        "name": "synthesize_ssml",
+        "description": "Convert SSML markup to speech with advanced prosody control",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "ssml_text": {
+                    "type": "string",
+                    "description": "SSML markup text with prosody tags"
+                },
+                "model": {
+                    "type": "string",
+                    "enum": ["tacotron2", "xtts_v2", "jenny"],
+                    "default": "tacotron2",
+                    "description": "TTS model to use"
+                },
+                "format": {
+                    "type": "string",
+                    "enum": ["wav", "mp3", "flac", "ogg"],
+                    "default": "wav",
+                    "description": "Output audio format"
+                }
+            },
+            "required": ["ssml_text"]
+        }
+    },
+    
+    "clone_voice": {
+        "name": "clone_voice",
+        "description": "Clone a voice from reference audio and synthesize text with that voice",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "text": {
+                    "type": "string",
+                    "description": "Text to synthesize with cloned voice"
+                },
+                "reference_audio_path": {
+                    "type": "string",
+                    "description": "Path to reference audio file for voice cloning"
+                },
+                "language": {
+                    "type": "string",
+                    "enum": ["en", "es", "fr", "de", "it", "pt", "pl", "tr", "ru", "nl", "cs", "ar", "zh-cn", "ja"],
+                    "default": "en",
+                    "description": "Target language for synthesis"
+                },
+                "format": {
+                    "type": "string",
+                    "enum": ["wav", "mp3", "flac", "ogg"],
+                    "default": "wav",
+                    "description": "Output audio format"
+                }
+            },
+            "required": ["text", "reference_audio_path"]
+        }
+    },
+    
+    "batch_process": {
+        "name": "batch_process",
+        "description": "Process multiple texts in batch and return as ZIP archive",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "texts": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "List of texts to process"
+                },
+                "model": {
+                    "type": "string",
+                    "enum": ["tacotron2", "xtts_v2", "jenny"],
+                    "default": "tacotron2",
+                    "description": "TTS model to use"
+                },
+                "format": {
+                    "type": "string",
+                    "enum": ["wav", "mp3", "flac", "ogg"],
+                    "default": "wav",
+                    "description": "Output audio format"
+                }
+            },
+            "required": ["texts"]
+        }
+    },
+    
+    "get_storage_stats": {
+        "name": "get_storage_stats",
+        "description": "Get persistent storage usage statistics",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+    },
+    
+    "list_saved_outputs": {
+        "name": "list_saved_outputs",
+        "description": "List previously saved audio outputs with metadata",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "user_id": {
+                    "type": "string",
+                    "description": "Filter by user ID (optional)"
+                },
+                "limit": {
+                    "type": "integer",
+                    "default": 50,
+                    "minimum": 1,
+                    "maximum": 200,
+                    "description": "Maximum number of results to return"
+                }
+            },
+            "required": []
+        }
+    },
+    
+    "create_backup": {
+        "name": "create_backup",
+        "description": "Create backup of important TTS data and outputs",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "backup_name": {
+                    "type": "string",
+                    "description": "Custom backup name (optional)"
+                }
+            },
+            "required": []
+        }
+    },
+    
+    "setup_webhooks": {
+        "name": "setup_webhooks",
+        "description": "Programmatically create Hugging Face webhooks for TTS automation",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "target_repos": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "default": ["Toowired/text2speech-gradio-app"],
+                    "description": "List of repositories to monitor"
+                }
+            },
+            "required": []
+        }
+    },
+    
+    "get_api_status": {
+        "name": "get_api_status",
+        "description": "Get current API status and system information",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "required": []
+        }
+    }
+}
+
+def get_mcp_tools_json() -> str:
+    """Get MCP tools configuration as JSON string"""
+    return json.dumps(MCP_TOOLS, indent=2)
+
+def get_tool_names() -> List[str]:
+    """Get list of available MCP tool names"""
+    return list(MCP_TOOLS.keys())
+
+def get_tool_definition(tool_name: str) -> Dict[str, Any]:
+    """Get specific tool definition"""
+    return MCP_TOOLS.get(tool_name, {})
+
+# Export tools configuration for Gradio MCP integration
+__all__ = ['MCP_TOOLS', 'get_mcp_tools_json', 'get_tool_names', 'get_tool_definition']

requirements.txt

@@ -9,4 +9,5 @@ librosa>=0.10.0
 scipy>=1.9.0
 huggingface_hub>=0.20.0
 requests>=2.28.0
-fastapi>=0.100.0
+fastapi>=0.100.0
+uvicorn>=0.23.0

storage_manager.py

@@ -0,0 +1,344 @@
+# Generated by Copilot
+"""
+Persistent Storage Manager for TTS Project
+Utilizes 20GB permanent storage for saving outputs, models, and data
+"""
+
+import os
+import json
+import shutil
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, List, Optional, Union
+import zipfile
+import tempfile
+from dataclasses import dataclass, asdict
+
+@dataclass
+class StorageStats:
+    """Storage statistics"""
+    total_space: int
+    used_space: int
+    free_space: int
+    num_files: int
+    num_audio_files: int
+    num_models: int
+
+class PersistentStorageManager:
+    """Manages 20GB persistent storage for TTS project"""
+    
+    def __init__(self, base_path: str = "/data"):
+        """Initialize storage manager with persistent storage path"""
+        self.base_path = Path(base_path)
+        self.ensure_directories()
+        
+        # Storage structure
+        self.paths = {
+            "audio_outputs": self.base_path / "audio_outputs",
+            "batch_results": self.base_path / "batch_results", 
+            "voice_samples": self.base_path / "voice_samples",
+            "models_cache": self.base_path / "models_cache",
+            "user_data": self.base_path / "user_data",
+            "analytics": self.base_path / "analytics",
+            "webhooks_logs": self.base_path / "webhooks_logs",
+            "exports": self.base_path / "exports",
+            "backups": self.base_path / "backups"
+        }
+    
+    def ensure_directories(self):
+        """Create necessary directory structure"""
+        directories = [
+            "audio_outputs",
+            "batch_results", 
+            "voice_samples",
+            "models_cache",
+            "user_data",
+            "analytics",
+            "webhooks_logs",
+            "exports",
+            "backups"
+        ]
+        
+        for directory in directories:
+            dir_path = self.base_path / directory
+            dir_path.mkdir(parents=True, exist_ok=True)
+            
+            # Create README files for each directory
+            readme_path = dir_path / "README.md"
+            if not readme_path.exists():
+                readme_content = f"""# {directory.replace('_', ' ').title()}
+
+This directory stores {directory.replace('_', ' ')} for the TTS project.
+
+- **Created**: {datetime.now().isoformat()}
+- **Purpose**: Persistent storage for TTS project data
+- **Storage**: Part of 20GB permanent storage allocation
+"""
+                readme_path.write_text(readme_content)
+    
+    def save_audio_output(self, audio_path: str, metadata: Dict, user_id: str = "default") -> str:
+        """Save audio output with metadata to persistent storage"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"tts_{timestamp}_{user_id}.wav"
+        
+        # Create user directory
+        user_dir = self.paths["audio_outputs"] / user_id
+        user_dir.mkdir(exist_ok=True)
+        
+        # Save audio file
+        dest_path = user_dir / filename
+        shutil.copy2(audio_path, dest_path)
+        
+        # Save metadata
+        metadata_path = user_dir / f"{filename}.json"
+        metadata_with_info = {
+            **metadata,
+            "saved_at": datetime.now().isoformat(),
+            "file_size": dest_path.stat().st_size,
+            "original_path": audio_path
+        }
+        
+        with open(metadata_path, 'w') as f:
+            json.dump(metadata_with_info, f, indent=2)
+        
+        return str(dest_path)
+    
+    def save_batch_results(self, batch_files: List[str], batch_metadata: Dict) -> str:
+        """Save batch processing results as ZIP with metadata"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        batch_name = f"batch_{timestamp}"
+        
+        # Create batch directory
+        batch_dir = self.paths["batch_results"] / batch_name
+        batch_dir.mkdir(exist_ok=True)
+        
+        # Copy files to batch directory
+        saved_files = []
+        for i, file_path in enumerate(batch_files):
+            if os.path.exists(file_path):
+                dest_name = f"batch_{i:03d}.wav"
+                dest_path = batch_dir / dest_name
+                shutil.copy2(file_path, dest_path)
+                saved_files.append(str(dest_path))
+        
+        # Create ZIP archive
+        zip_path = self.paths["exports"] / f"{batch_name}.zip"
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for file_path in saved_files:
+                zipf.write(file_path, Path(file_path).name)
+        
+        # Save metadata
+        metadata_path = batch_dir / "metadata.json"
+        full_metadata = {
+            **batch_metadata,
+            "batch_id": batch_name,
+            "created_at": datetime.now().isoformat(),
+            "num_files": len(saved_files),
+            "zip_path": str(zip_path),
+            "files": saved_files
+        }
+        
+        with open(metadata_path, 'w') as f:
+            json.dump(full_metadata, f, indent=2)
+        
+        return str(zip_path)
+    
+    def save_voice_sample(self, audio_path: str, voice_name: str, metadata: Dict) -> str:
+        """Save voice cloning reference samples"""
+        voice_dir = self.paths["voice_samples"] / voice_name
+        voice_dir.mkdir(exist_ok=True)
+        
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{voice_name}_{timestamp}.wav"
+        dest_path = voice_dir / filename
+        
+        shutil.copy2(audio_path, dest_path)
+        
+        # Save voice metadata
+        voice_metadata = {
+            **metadata,
+            "voice_name": voice_name,
+            "saved_at": datetime.now().isoformat(),
+            "file_path": str(dest_path),
+            "file_size": dest_path.stat().st_size
+        }
+        
+        metadata_path = voice_dir / f"{filename}.json"
+        with open(metadata_path, 'w') as f:
+            json.dump(voice_metadata, f, indent=2)
+        
+        return str(dest_path)
+    
+    def cache_model(self, model_name: str, model_path: str) -> str:
+        """Cache downloaded models for faster loading"""
+        model_dir = self.paths["models_cache"] / model_name.replace("/", "_")
+        model_dir.mkdir(exist_ok=True)
+        
+        if os.path.isdir(model_path):
+            # Copy entire model directory
+            dest_path = model_dir / "model"
+            if dest_path.exists():
+                shutil.rmtree(dest_path)
+            shutil.copytree(model_path, dest_path)
+        else:
+            # Copy single model file
+            dest_path = model_dir / Path(model_path).name
+            shutil.copy2(model_path, dest_path)
+        
+        # Save model info
+        info_path = model_dir / "model_info.json"
+        model_info = {
+            "model_name": model_name,
+            "cached_at": datetime.now().isoformat(),
+            "original_path": model_path,
+            "cached_path": str(dest_path),
+            "size": self._get_directory_size(dest_path) if dest_path.is_dir() else dest_path.stat().st_size
+        }
+        
+        with open(info_path, 'w') as f:
+            json.dump(model_info, f, indent=2)
+        
+        return str(dest_path)
+    
+    def log_webhook_event(self, event_data: Dict) -> str:
+        """Log webhook events to persistent storage"""
+        date_str = datetime.now().strftime("%Y%m%d")
+        log_file = self.paths["webhooks_logs"] / f"webhooks_{date_str}.jsonl"
+        
+        event_entry = {
+            **event_data,
+            "logged_at": datetime.now().isoformat()
+        }
+        
+        with open(log_file, 'a') as f:
+            f.write(json.dumps(event_entry) + '\n')
+        
+        return str(log_file)
+    
+    def save_analytics_data(self, analytics_data: Dict, data_type: str = "usage") -> str:
+        """Save analytics data for long-term analysis"""
+        date_str = datetime.now().strftime("%Y%m%d")
+        analytics_file = self.paths["analytics"] / f"{data_type}_{date_str}.json"
+        
+        # Load existing data if file exists
+        if analytics_file.exists():
+            with open(analytics_file, 'r') as f:
+                existing_data = json.load(f)
+        else:
+            existing_data = {"entries": []}
+        
+        # Add new entry
+        entry = {
+            **analytics_data,
+            "timestamp": datetime.now().isoformat()
+        }
+        existing_data["entries"].append(entry)
+        
+        # Save updated data
+        with open(analytics_file, 'w') as f:
+            json.dump(existing_data, f, indent=2)
+        
+        return str(analytics_file)
+    
+    def create_backup(self, backup_name: str = None) -> str:
+        """Create backup of important data"""
+        if backup_name is None:
+            backup_name = f"backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        
+        backup_path = self.paths["backups"] / f"{backup_name}.zip"
+        
+        with zipfile.ZipFile(backup_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            # Backup audio outputs (recent ones)
+            for audio_file in self.paths["audio_outputs"].rglob("*.wav"):
+                # Only backup files from last 30 days
+                if (datetime.now().timestamp() - audio_file.stat().st_mtime) < (30 * 24 * 3600):
+                    arcname = str(audio_file.relative_to(self.base_path))
+                    zipf.write(audio_file, arcname)
+            
+            # Backup voice samples
+            for voice_file in self.paths["voice_samples"].rglob("*"):
+                if voice_file.is_file():
+                    arcname = str(voice_file.relative_to(self.base_path))
+                    zipf.write(voice_file, arcname)
+            
+            # Backup analytics
+            for analytics_file in self.paths["analytics"].rglob("*.json"):
+                arcname = str(analytics_file.relative_to(self.base_path))
+                zipf.write(analytics_file, arcname)
+        
+        return str(backup_path)
+    
+    def get_storage_stats(self) -> StorageStats:
+        """Get storage usage statistics"""
+        total_size = 20 * 1024 * 1024 * 1024  # 20GB in bytes
+        used_size = self._get_directory_size(self.base_path)
+        
+        # Count files
+        audio_files = len(list(self.paths["audio_outputs"].rglob("*.wav")))
+        total_files = len(list(self.base_path.rglob("*")))
+        model_dirs = len(list(self.paths["models_cache"].iterdir()))
+        
+        return StorageStats(
+            total_space=total_size,
+            used_space=used_size,
+            free_space=total_size - used_size,
+            num_files=total_files,
+            num_audio_files=audio_files,
+            num_models=model_dirs
+        )
+    
+    def cleanup_old_files(self, days: int = 30):
+        """Clean up files older than specified days"""
+        cutoff_time = datetime.now().timestamp() - (days * 24 * 3600)
+        cleaned_files = []
+        
+        for file_path in self.base_path.rglob("*"):
+            if file_path.is_file() and file_path.stat().st_mtime < cutoff_time:
+                # Don't delete model cache or voice samples
+                if "models_cache" not in str(file_path) and "voice_samples" not in str(file_path):
+                    file_path.unlink()
+                    cleaned_files.append(str(file_path))
+        
+        return cleaned_files
+    
+    def _get_directory_size(self, directory: Path) -> int:
+        """Get total size of directory"""
+        total_size = 0
+        for file_path in directory.rglob("*"):
+            if file_path.is_file():
+                total_size += file_path.stat().st_size
+        return total_size
+    
+    def list_saved_outputs(self, user_id: str = None, limit: int = 50) -> List[Dict]:
+        """List saved audio outputs with metadata"""
+        outputs = []
+        
+        search_path = self.paths["audio_outputs"]
+        if user_id:
+            search_path = search_path / user_id
+            if not search_path.exists():
+                return outputs
+        
+        # Find audio files and their metadata
+        for audio_file in search_path.rglob("*.wav"):
+            metadata_file = audio_file.with_suffix(".wav.json")
+            if metadata_file.exists():
+                try:
+                    with open(metadata_file, 'r') as f:
+                        metadata = json.load(f)
+                    
+                    outputs.append({
+                        "file_path": str(audio_file),
+                        "metadata": metadata,
+                        "size": audio_file.stat().st_size,
+                        "created": datetime.fromtimestamp(audio_file.stat().st_ctime).isoformat()
+                    })
+                except Exception as e:
+                    print(f"Error reading metadata for {audio_file}: {e}")
+        
+        # Sort by creation time (newest first) and limit results
+        outputs.sort(key=lambda x: x["created"], reverse=True)
+        return outputs[:limit]
+
+# Global storage manager instance
+storage_manager = PersistentStorageManager()

webhook_manager.py

@@ -0,0 +1,210 @@
+# Generated by Copilot
+"""
+Programmatic Webhook Management for TTS Project
+Creates and manages Hugging Face webhooks automatically
+"""
+
+import os
+import json
+import asyncio
+from typing import List, Dict, Optional
+from huggingface_hub import HfApi, HfFolder
+import requests
+
+class WebhookManager:
+    """Manages Hugging Face webhooks programmatically"""
+    
+    def __init__(self, token: Optional[str] = None):
+        self.api = HfApi(token=token)
+        self.token = token or HfFolder.get_token()
+        self.base_url = "https://huggingface.co/api/webhooks"
+        self.space_url = "https://toowired-text2speech-gradio-app.hf.space"
+        
+    def get_headers(self) -> Dict[str, str]:
+        """Get API headers with authentication"""
+        return {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json"
+        }
+    
+    def create_webhook(self, 
+                      endpoint: str,
+                      name: str,
+                      secret: str,
+                      events: List[str],
+                      target_repos: List[str],
+                      description: str = "") -> Dict:
+        """Create a new webhook programmatically"""
+        
+        webhook_data = {
+            "url": f"{self.space_url}/webhooks/{endpoint}",
+            "name": name,
+            "secret": secret,
+            "events": events,
+            "repos": target_repos,
+            "description": description,
+            "active": True
+        }
+        
+        try:
+            response = requests.post(
+                self.base_url,
+                headers=self.get_headers(),
+                json=webhook_data
+            )
+            
+            if response.status_code == 201:
+                print(f"✅ Created webhook: {name}")
+                return response.json()
+            else:
+                print(f"❌ Failed to create webhook {name}: {response.status_code}")
+                print(f"Response: {response.text}")
+                return {"error": response.text}
+                
+        except Exception as e:
+            print(f"❌ Error creating webhook {name}: {e}")
+            return {"error": str(e)}
+    
+    def list_webhooks(self) -> List[Dict]:
+        """List all existing webhooks"""
+        try:
+            response = requests.get(
+                self.base_url,
+                headers=self.get_headers()
+            )
+            
+            if response.status_code == 200:
+                return response.json()
+            else:
+                print(f"❌ Failed to list webhooks: {response.status_code}")
+                return []
+                
+        except Exception as e:
+            print(f"❌ Error listing webhooks: {e}")
+            return []
+    
+    def delete_webhook(self, webhook_id: str) -> bool:
+        """Delete a webhook by ID"""
+        try:
+            response = requests.delete(
+                f"{self.base_url}/{webhook_id}",
+                headers=self.get_headers()
+            )
+            
+            if response.status_code == 204:
+                print(f"✅ Deleted webhook: {webhook_id}")
+                return True
+            else:
+                print(f"❌ Failed to delete webhook {webhook_id}: {response.status_code}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Error deleting webhook {webhook_id}: {e}")
+            return False
+    
+    def setup_tts_webhooks(self) -> Dict[str, Dict]:
+        """Set up all TTS project webhooks automatically"""
+        
+        webhook_secret = "tts_webhook_secret_2024"
+        target_repos = [
+            "Toowired/text2speech-gradio-app",
+            # Add any model repos you want to monitor
+            # "microsoft/speecht5_tts",
+            # "suno/bark",
+        ]
+        
+        webhooks_config = {
+            "main_automation": {
+                "endpoint": "tts_automation",
+                "name": "TTS Main Automation",
+                "description": "Main automation webhook for TTS project",
+                "events": [
+                    "repo.content.update",
+                    "repo.content.create",
+                    "space.runtime.restart",
+                    "discussion.create",
+                    "discussion.comment.create"
+                ]
+            },
+            "model_sync": {
+                "endpoint": "model_sync", 
+                "name": "TTS Model Synchronization",
+                "description": "Automatically sync new TTS models",
+                "events": [
+                    "repo.create",
+                    "repo.content.update",
+                    "model.create"
+                ]
+            },
+            "usage_tracker": {
+                "endpoint": "usage_tracker",
+                "name": "TTS Usage Analytics",
+                "description": "Track usage patterns and performance",
+                "events": [
+                    "space.runtime.start",
+                    "space.runtime.stop",
+                    "space.runtime.restart"
+                ]
+            },
+            "error_monitor": {
+                "endpoint": "error_monitor", 
+                "name": "TTS Error Monitoring",
+                "description": "Monitor for deployment errors and issues",
+                "events": [
+                    "space.runtime.failed",
+                    "space.build.failed",
+                    "repo.content.failed"
+                ]
+            }
+        }
+        
+        results = {}
+        
+        for webhook_key, config in webhooks_config.items():
+            result = self.create_webhook(
+                endpoint=config["endpoint"],
+                name=config["name"],
+                secret=webhook_secret,
+                events=config["events"],
+                target_repos=target_repos,
+                description=config["description"]
+            )
+            results[webhook_key] = result
+        
+        return results
+    
+    def cleanup_old_webhooks(self, name_pattern: str = "TTS"):
+        """Remove old TTS webhooks to avoid duplicates"""
+        webhooks = self.list_webhooks()
+        
+        for webhook in webhooks:
+            if name_pattern in webhook.get("name", ""):
+                print(f"🗑️ Removing old webhook: {webhook['name']}")
+                self.delete_webhook(webhook["id"])
+
+def setup_webhooks_programmatically():
+    """Main function to set up webhooks"""
+    print("🔗 Setting up TTS webhooks programmatically...")
+    
+    manager = WebhookManager()
+    
+    # Clean up old webhooks first
+    print("🗑️ Cleaning up old webhooks...")
+    manager.cleanup_old_webhooks("TTS")
+    
+    # Create new webhooks
+    print("🆕 Creating new webhooks...")
+    results = manager.setup_tts_webhooks()
+    
+    # Show results
+    print("\n📊 Webhook Setup Results:")
+    for webhook_name, result in results.items():
+        if "error" in result:
+            print(f"❌ {webhook_name}: {result['error']}")
+        else:
+            print(f"✅ {webhook_name}: Created successfully")
+    
+    return results
+
+if __name__ == "__main__":
+    setup_webhooks_programmatically()