🧬 Add Dynamic Model Management System

Major new feature: Complete model management system with admin interface.

Key Features:
- Add new AI models via admin interface (e.g., gpt-4.1, o3-mini)
- Support for all providers: OpenAI, Anthropic, Google, Mistral, Groq, Cohere
- Whitelist-only security model for model access control
- Firebase persistence for custom models
- Cost tracking and usage analytics
- Beautiful admin interface with modal forms

Technical Implementation:
- Enhanced ModelFamilyManager with dynamic model CRUD operations
- New API endpoints for model management
- Comprehensive model validation and error handling
- Custom models separate from default models
- Real-time model toggling and bulk operations

Documentation:
- Created comprehensive docs/model-management.md guide
- Updated README with documentation structure
- Added docs/README.md index

Security:
- Models must exist AND be whitelisted to be used
- Non-existent models like "o3-mini" are blocked with 403
- Default models preserved and auto-whitelisted
- Admin authentication required for all model operations

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

README.md

@@ -10,7 +10,7 @@ pinned: false
 
 # 🐱 NyanProxy - Meow-nificent AI Proxy!
 
-A sophisticated AI proxy service that provides unified access to multiple AI providers with advanced features like token tracking, rate limiting, and user management.
+A sophisticated AI proxy service that provides unified access to multiple AI providers with advanced features like dynamic model management, token tracking, rate limiting, and user management.
 
 ## 🔥 **IMPORTANT: Firebase Database Required!**
 
@@ -44,17 +44,31 @@ A sophisticated AI proxy service that provides unified access to multiple AI pro
 
 **NyanProxy is designed to be a privacy-first proxy that tracks usage without compromising your data privacy.**
 
-## Features
+## ✨ Key Features
 
+- **🧬 Dynamic Model Management**: Add/remove AI models via admin interface without code changes
 - **🔥 Firebase-Powered**: Persistent logging and user management
-- **🤖 Multi-Provider Support**: OpenAI, Anthropic, and more AI services
-- **📊 Advanced Analytics**: Real-time usage tracking and performance metrics
+- **🤖 Multi-Provider Support**: OpenAI, Anthropic, Google, Mistral, Groq, Cohere
+- **📊 Advanced Analytics**: Real-time usage tracking and cost analysis
 - **🛡️ Smart Rate Limiting**: Automatic key rotation and health monitoring
 - **👥 User Management**: Individual user tokens with quotas and permissions
-- **🎯 Model Whitelisting**: Configurable model access controls
-- **📱 Web Dashboard**: Beautiful admin interface for monitoring and management
+- **🎯 Model Whitelisting**: Secure whitelist-only model access
+- **📱 Beautiful Admin Dashboard**: Web interface for monitoring and management
 - **🔐 Flexible Authentication**: Support for proxy keys or individual user tokens
 
+## 📚 Documentation
+
+### 📖 Detailed Guides
+- **[🧬 Model Management](docs/model-management.md)** - Add/configure AI models dynamically
+- **[🔐 Authentication Setup](AUTHENTICATION.md)** - User management and authentication modes
+
+### 🎯 Quick Links
+- **[💡 Usage Examples](#-usage-examples)** - API integration examples
+- **[🔧 API Endpoints](#-api-endpoints)** - Complete endpoint reference
+- **[⚙️ Environment Variables](#step-2-api-keys-setup)** - Configuration guide
+
+*More documentation coming soon as features are added!*
+
 ## 🚀 Quick Setup Guide
 
 ### **Step 1: Firebase Database Setup (REQUIRED)**

docs/README.md

@@ -0,0 +1,51 @@
+# 📚 NyanProxy Documentation
+
+Welcome to the NyanProxy documentation! Here you'll find detailed guides and tutorials for all features.
+
+## 📖 Available Guides
+
+### 🧬 [Model Management](model-management.md)
+Learn how to dynamically add, configure, and manage AI models through the admin interface.
+
+- Adding new models (like gpt-4.1, o1-preview, etc.)
+- Configuring model properties and costs
+- Managing model whitelisting and security
+- Understanding usage analytics
+
+### 🔐 [Authentication Setup](../AUTHENTICATION.md)
+Comprehensive guide to user management and authentication modes.
+
+- Setting up user tokens
+- Configuring authentication modes
+- Managing user quotas and permissions
+
+## 🎯 Quick Reference
+
+### Essential Links
+- **[Main README](../README.md)** - Project overview and quick start
+- **[Admin Dashboard](../README.md#-api-endpoints)** - Management interface guide
+- **[API Endpoints](../README.md#-api-endpoints)** - Complete API reference
+
+### Common Tasks
+- **Add New Model**: [Model Management Guide](model-management.md#adding-a-new-model)
+- **Configure Authentication**: [Authentication Setup](../AUTHENTICATION.md)
+- **Set Up Firebase**: [Main README](../README.md#step-1-firebase-database-setup-required)
+
+## 🚀 Getting Started
+
+1. **[Set up Firebase](../README.md#step-1-firebase-database-setup-required)** - Required for persistence
+2. **[Configure API Keys](../README.md#step-2-api-keys-setup)** - Add your AI service keys
+3. **[Deploy to HF](../README.md#step-3-local-development)** - Run locally or deploy
+4. **[Manage Models](model-management.md)** - Add and configure AI models
+5. **[Set up Users](../AUTHENTICATION.md)** - Configure authentication
+
+## 🆘 Need Help?
+
+If you can't find what you're looking for:
+1. Check the [main README](../README.md) for basic setup
+2. Look through the specific guide for your feature
+3. Create an issue on the repository with your question
+
+---
+
+*Documentation is continuously updated as new features are added!*

docs/model-management.md

@@ -0,0 +1,225 @@
+# 🧬 Model Management Guide
+
+NyanProxy provides a comprehensive model management system that allows you to dynamically add, configure, and control AI models without modifying code or environment variables.
+
+## 🎯 Overview
+
+The Model Management system provides:
+- **Dynamic Model Addition**: Add new models via admin interface
+- **Provider Support**: OpenAI, Anthropic, Google, Mistral, Groq, Cohere
+- **Security**: Whitelist-only access control
+- **Cost Tracking**: Per-model usage and cost analytics
+- **Firebase Persistence**: Automatic synchronization across deployments
+
+## 🚀 Quick Start
+
+### Accessing Model Management
+
+1. Navigate to your NyanProxy admin panel: `/admin/login`
+2. Enter your admin credentials
+3. Click "🧬 Model Families" in the navigation menu
+
+### Adding a New Model
+
+1. Click **"➕ Add New Model"** button
+2. Fill in the model details:
+   - **Model ID**: `gpt-4.1-turbo` (API identifier)
+   - **Provider**: Select from dropdown (OpenAI, Anthropic, etc.)
+   - **Display Name**: `GPT-4.1 Turbo` (human-readable name)
+   - **Description**: Brief description of capabilities
+   - **Costs**: Input/output cost per 1K tokens
+   - **Context Length**: Maximum tokens (e.g., 128000)
+   - **Cat Personality**: Fun theme (curious, playful, smart, etc.)
+   - **Capabilities**: Streaming, function calling, premium status
+3. Check **"Auto-enable when added"** to immediately whitelist the model
+4. Click **"Add Model"**
+
+The model is now available for API requests!
+
+## 🔧 Managing Models
+
+### Default Models
+
+NyanProxy comes with these pre-configured models:
+
+**OpenAI Models:**
+- `gpt-4o` - Most advanced GPT-4 model
+- `gpt-4o-mini` - Smaller, faster GPT-4 model  
+- `gpt-3.5-turbo` - Fast and efficient for most tasks
+
+**Anthropic Models:**
+- `claude-3-5-sonnet-20241022` - Most intelligent Claude model
+- `claude-3-haiku-20240307` - Fastest Claude model
+
+**Google Models:**
+- `gemini-1.5-pro` - Google's most capable model
+- `gemini-1.5-flash` - Fast and efficient Gemini model
+
+### Model Controls
+
+**Individual Model Toggle:**
+- Use the toggle switches to enable/disable specific models
+- Changes are applied immediately
+
+**Bulk Operations:**
+- **Enable All Models**: Enable all models across all providers
+- **Disable All Models**: Disable all models (use with caution!)
+- **Provider Controls**: Enable/disable all models for a specific provider
+
+### Custom Models Management
+
+1. Click **"🔧 Manage Custom Models"** to view all custom models
+2. See detailed information: costs, context length, status
+3. **Delete**: Remove custom models you no longer need
+
+## 🔒 Security & Whitelisting
+
+### How Whitelisting Works
+
+NyanProxy uses a **whitelist-only** security model:
+
+1. **Model Must Exist**: The model must be defined in the system
+2. **Model Must Be Whitelisted**: The model must be explicitly enabled
+3. **Request Validation**: Every API request checks both conditions
+
+### Security Examples
+
+```
+✅ ALLOWED: "gpt-4o" (exists + whitelisted)
+❌ BLOCKED: "o3-mini" (doesn't exist)
+❌ BLOCKED: "custom-model" (exists but not whitelisted)
+```
+
+### API Response for Blocked Models
+
+```json
+{
+  "error": {
+    "message": "Model 'o3-mini' is not whitelisted for use",
+    "type": "model_not_allowed"
+  }
+}
+```
+
+## 📊 Usage Analytics
+
+### Cost Tracking
+
+Each model tracks:
+- **Total Requests**: Number of API calls
+- **Token Usage**: Input/output tokens consumed
+- **Cost**: Calculated cost based on token usage
+- **Success Rate**: Percentage of successful requests
+
+### Viewing Analytics
+
+1. Navigate to **"📊 Usage Analytics"** from the Model Families page
+2. View:
+   - Top models by cost
+   - Top models by requests
+   - Per-model performance metrics
+   - Cost breakdown by provider
+
+## 🔧 Advanced Configuration
+
+### Model Properties
+
+When adding a model, you can configure:
+
+**Required Fields:**
+- `model_id`: API identifier (e.g., "gpt-4.1-turbo")
+- `provider`: AI service provider
+- `display_name`: Human-readable name
+- `description`: Model capabilities description
+
+**Optional Fields:**
+- `input_cost_per_1k`: Cost per 1K input tokens ($)
+- `output_cost_per_1k`: Cost per 1K output tokens ($)
+- `context_length`: Maximum context window (default: 4096)
+- `supports_streaming`: Real-time response support
+- `supports_function_calling`: Function/tool calling capability
+- `is_premium`: Premium model designation
+- `cat_personality`: Theme for fun categorization
+
+### Cat Personalities
+
+Choose from these fun themes:
+- 🙀 **Curious**: Inquisitive models
+- 😸 **Playful**: Fun, creative models
+- 😴 **Sleepy**: Relaxed, casual models
+- 😾 **Grumpy**: Serious, no-nonsense models
+- 🤓 **Smart**: Intelligent, analytical models
+- 💨 **Fast**: Quick, efficient models
+
+## 🗄️ Data Persistence
+
+### Firebase Integration
+
+When Firebase is configured:
+- Custom models sync automatically across deployments
+- Model configurations persist through restarts
+- Real-time updates across multiple instances
+
+### Local File Fallback
+
+Without Firebase:
+- Models saved to `custom_models.json`
+- Configuration persists locally
+- Manual backup recommended
+
+## 🛠️ Troubleshooting
+
+### Common Issues
+
+**Model Not Appearing:**
+1. Check if model was added successfully
+2. Verify model is whitelisted (toggle on)
+3. Refresh the page
+
+**API Requests Failing:**
+1. Confirm model exists in system
+2. Verify model is whitelisted
+3. Check API key is configured for the provider
+
+**Permission Errors:**
+1. Ensure you're logged in as admin
+2. Check admin key is correct
+3. Verify session hasn't expired
+
+### Getting Help
+
+If you encounter issues:
+1. Check the browser console for JavaScript errors
+2. Review the NyanProxy logs for backend errors
+3. Verify your Firebase configuration (if using)
+4. Test with default models first
+
+## 🎉 Best Practices
+
+### Model Naming
+
+- Use clear, descriptive model IDs
+- Follow provider conventions (e.g., `gpt-4.1-turbo`)
+- Avoid special characters or spaces
+
+### Cost Management
+
+- Set realistic cost estimates for budget tracking
+- Monitor usage analytics regularly
+- Consider token limits for expensive models
+
+### Security
+
+- Only whitelist models you trust
+- Regularly review enabled models
+- Use the "Disable All" feature for maintenance
+
+### Performance
+
+- Enable streaming for better user experience
+- Set appropriate context lengths
+- Monitor response times via analytics
+
+---
+
+*Need help? Check out the [main documentation](../README.md) or create an issue on the repository.*

pages/admin/model_families.html

@@ -160,6 +160,151 @@
         font-size: 1.2em;
         margin-right: 5px;
     }
+    
+    .modal {
+        display: none;
+        position: fixed;
+        z-index: 1000;
+        left: 0;
+        top: 0;
+        width: 100%;
+        height: 100%;
+        background-color: rgba(0,0,0,0.5);
+    }
+    
+    .modal-content {
+        background-color: white;
+        margin: 5% auto;
+        padding: 20px;
+        border-radius: 10px;
+        width: 80%;
+        max-width: 500px;
+        max-height: 80vh;
+        overflow-y: auto;
+    }
+    
+    .close {
+        color: #aaa;
+        float: right;
+        font-size: 28px;
+        font-weight: bold;
+        cursor: pointer;
+    }
+    
+    .close:hover {
+        color: black;
+    }
+    
+    .form-group {
+        margin-bottom: 15px;
+    }
+    
+    .form-group label {
+        display: block;
+        margin-bottom: 5px;
+        font-weight: bold;
+    }
+    
+    .form-group input,
+    .form-group select,
+    .form-group textarea {
+        width: 100%;
+        padding: 8px;
+        border: 1px solid #ddd;
+        border-radius: 4px;
+        font-size: 14px;
+    }
+    
+    .form-group textarea {
+        height: 80px;
+        resize: vertical;
+    }
+    
+    .error {
+        background-color: #f8d7da;
+        color: #721c24;
+        padding: 10px;
+        border-radius: 4px;
+        margin-bottom: 15px;
+    }
+    
+    .success {
+        background-color: #d4edda;
+        color: #155724;
+        padding: 10px;
+        border-radius: 4px;
+        margin-bottom: 15px;
+    }
+    
+    .custom-model-item {
+        border: 1px solid #ddd;
+        border-radius: 8px;
+        padding: 15px;
+        margin-bottom: 10px;
+        background: #f9f9f9;
+    }
+    
+    .custom-model-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 10px;
+    }
+    
+    .custom-model-name {
+        font-weight: bold;
+        font-size: 1.1em;
+    }
+    
+    .custom-model-actions {
+        display: flex;
+        gap: 10px;
+    }
+    
+    .btn {
+        padding: 8px 16px;
+        border: none;
+        border-radius: 4px;
+        cursor: pointer;
+        font-size: 14px;
+        text-decoration: none;
+        display: inline-block;
+    }
+    
+    .btn-primary {
+        background-color: #007bff;
+        color: white;
+    }
+    
+    .btn-secondary {
+        background-color: #6c757d;
+        color: white;
+    }
+    
+    .btn-success {
+        background-color: #28a745;
+        color: white;
+    }
+    
+    .btn-warning {
+        background-color: #ffc107;
+        color: black;
+    }
+    
+    .btn-danger {
+        background-color: #dc3545;
+        color: white;
+    }
+    
+    .btn-info {
+        background-color: #17a2b8;
+        color: white;
+    }
+    
+    .btn-sm {
+        padding: 4px 8px;
+        font-size: 12px;
+    }
 </style>
 {% endblock %}
 
@@ -190,9 +335,11 @@
     
     <!-- Action Buttons -->
     <div style="margin-bottom: 20px;">
+        <button onclick="showAddModelModal()" class="btn btn-primary">➕ Add New Model</button>
         <button onclick="enableAllModels()" class="btn btn-success">🐱 Enable All Models</button>
         <button onclick="disableAllModels()" class="btn btn-warning">😾 Disable All Models</button>
         <a href="{{ url_for('model_families.usage_analytics') }}" class="btn btn-info">📊 Usage Analytics</a>
+        <button onclick="showCustomModels()" class="btn btn-secondary">🔧 Manage Custom Models</button>
     </div>
     
     <!-- Provider Cards -->
@@ -251,6 +398,111 @@
     </div>
 </div>
 
+<!-- Add New Model Modal -->
+<div id="addModelModal" class="modal" style="display: none;">
+    <div class="modal-content" style="max-width: 600px;">
+        <span class="close" onclick="hideModal('addModelModal')">&times;</span>
+        <h3>🐱 Add New Model</h3>
+        <form id="addModelForm">
+            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 15px;">
+                <div class="form-group">
+                    <label for="model_id">Model ID *</label>
+                    <input type="text" id="model_id" name="model_id" required 
+                           placeholder="e.g., gpt-4.1-turbo">
+                </div>
+                <div class="form-group">
+                    <label for="provider">Provider *</label>
+                    <select id="provider" name="provider" required>
+                        <option value="">Select provider...</option>
+                        <option value="openai">OpenAI</option>
+                        <option value="anthropic">Anthropic</option>
+                        <option value="google">Google</option>
+                        <option value="mistral">Mistral</option>
+                        <option value="groq">Groq</option>
+                        <option value="cohere">Cohere</option>
+                    </select>
+                </div>
+                <div class="form-group">
+                    <label for="display_name">Display Name *</label>
+                    <input type="text" id="display_name" name="display_name" required 
+                           placeholder="e.g., GPT-4.1 Turbo">
+                </div>
+                <div class="form-group">
+                    <label for="cat_personality">Cat Personality</label>
+                    <select id="cat_personality" name="cat_personality">
+                        <option value="curious">Curious 🙀</option>
+                        <option value="playful">Playful 😸</option>
+                        <option value="sleepy">Sleepy 😴</option>
+                        <option value="grumpy">Grumpy 😾</option>
+                        <option value="smart">Smart 🤓</option>
+                        <option value="fast">Fast 💨</option>
+                    </select>
+                </div>
+                <div class="form-group">
+                    <label for="input_cost_per_1k">Input Cost per 1K tokens ($)</label>
+                    <input type="number" id="input_cost_per_1k" name="input_cost_per_1k" 
+                           step="0.001" min="0" placeholder="0.000">
+                </div>
+                <div class="form-group">
+                    <label for="output_cost_per_1k">Output Cost per 1K tokens ($)</label>
+                    <input type="number" id="output_cost_per_1k" name="output_cost_per_1k" 
+                           step="0.001" min="0" placeholder="0.000">
+                </div>
+                <div class="form-group">
+                    <label for="context_length">Context Length</label>
+                    <input type="number" id="context_length" name="context_length" 
+                           min="1" value="4096" placeholder="4096">
+                </div>
+                <div class="form-group">
+                    <label>
+                        <input type="checkbox" id="supports_streaming" name="supports_streaming" checked>
+                        Supports Streaming
+                    </label>
+                </div>
+                <div class="form-group">
+                    <label>
+                        <input type="checkbox" id="supports_function_calling" name="supports_function_calling">
+                        Supports Function Calling
+                    </label>
+                </div>
+                <div class="form-group">
+                    <label>
+                        <input type="checkbox" id="is_premium" name="is_premium">
+                        Premium Model
+                    </label>
+                </div>
+                <div class="form-group">
+                    <label>
+                        <input type="checkbox" id="auto_whitelist" name="auto_whitelist" checked>
+                        Auto-enable when added
+                    </label>
+                </div>
+            </div>
+            <div class="form-group">
+                <label for="description">Description *</label>
+                <textarea id="description" name="description" required 
+                          placeholder="Brief description of the model capabilities..."></textarea>
+            </div>
+            <div id="addModelErrors" class="error" style="display: none;"></div>
+            <div style="margin-top: 20px;">
+                <button type="submit" class="btn btn-primary">Add Model</button>
+                <button type="button" class="btn btn-secondary" onclick="hideModal('addModelModal')">Cancel</button>
+            </div>
+        </form>
+    </div>
+</div>
+
+<!-- Custom Models Management Modal -->
+<div id="customModelsModal" class="modal" style="display: none;">
+    <div class="modal-content" style="max-width: 800px;">
+        <span class="close" onclick="hideModal('customModelsModal')">&times;</span>
+        <h3>🔧 Custom Models Management</h3>
+        <div id="customModelsList">
+            <div class="loading">Loading custom models...</div>
+        </div>
+    </div>
+</div>
+
 <script>
 function toggleModel(provider, modelId, checkbox) {
     fetch(`/admin/model-families/api/model/${modelId}/toggle`, {
@@ -398,5 +650,173 @@ function showNotification(message, type) {
         notification.remove();
     }, 3000);
 }
+
+function showModal(modalId) {
+    document.getElementById(modalId).style.display = 'block';
+}
+
+function hideModal(modalId) {
+    document.getElementById(modalId).style.display = 'none';
+}
+
+function showAddModelModal() {
+    document.getElementById('addModelForm').reset();
+    document.getElementById('addModelErrors').style.display = 'none';
+    showModal('addModelModal');
+}
+
+function showCustomModels() {
+    showModal('customModelsModal');
+    loadCustomModels();
+}
+
+document.getElementById('addModelForm').addEventListener('submit', function(e) {
+    e.preventDefault();
+    
+    const formData = new FormData(e.target);
+    const data = {};
+    
+    // Convert form data to object
+    for (let [key, value] of formData.entries()) {
+        if (key.startsWith('supports_') || key.startsWith('is_') || key === 'auto_whitelist') {
+            data[key] = true; // Checkbox is checked
+        } else {
+            data[key] = value;
+        }
+    }
+    
+    // Set unchecked checkboxes to false
+    const checkboxes = ['supports_streaming', 'supports_function_calling', 'is_premium', 'auto_whitelist'];
+    checkboxes.forEach(cb => {
+        if (!data[cb]) {
+            data[cb] = false;
+        }
+    });
+    
+    // Submit the form
+    fetch('/admin/model-families/api/models', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'X-CSRFToken': document.querySelector('meta[name="csrf-token"]')?.getAttribute('content') || ''
+        },
+        body: JSON.stringify(data)
+    })
+    .then(response => response.json())
+    .then(result => {
+        if (result.success) {
+            showNotification(result.message, 'success');
+            hideModal('addModelModal');
+            // Refresh the page to show the new model
+            location.reload();
+        } else {
+            const errorDiv = document.getElementById('addModelErrors');
+            if (result.field_errors) {
+                let errorText = 'Validation errors:\n';
+                for (const [field, error] of Object.entries(result.field_errors)) {
+                    errorText += `${field}: ${error}\n`;
+                }
+                errorDiv.textContent = errorText;
+            } else {
+                errorDiv.textContent = result.error || 'Unknown error occurred';
+            }
+            errorDiv.style.display = 'block';
+        }
+    })
+    .catch(error => {
+        console.error('Error:', error);
+        showNotification('Network error occurred', 'error');
+    });
+});
+
+function loadCustomModels() {
+    const customModelsList = document.getElementById('customModelsList');
+    customModelsList.innerHTML = '<div class="loading">Loading custom models...</div>';
+    
+    fetch('/admin/model-families/api/models/custom')
+        .then(response => response.json())
+        .then(result => {
+            if (result.success) {
+                renderCustomModels(result.models);
+            } else {
+                customModelsList.innerHTML = '<div class="error">Error loading custom models: ' + result.error + '</div>';
+            }
+        })
+        .catch(error => {
+            console.error('Error:', error);
+            customModelsList.innerHTML = '<div class="error">Network error occurred</div>';
+        });
+}
+
+function renderCustomModels(models) {
+    const customModelsList = document.getElementById('customModelsList');
+    
+    if (models.length === 0) {
+        customModelsList.innerHTML = '<div class="info">No custom models found. Add your first custom model using the "Add New Model" button!</div>';
+        return;
+    }
+    
+    let html = '';
+    models.forEach(model => {
+        html += `
+            <div class="custom-model-item">
+                <div class="custom-model-header">
+                    <div class="custom-model-name">
+                        ${model.cat_emoji} ${model.display_name}
+                        ${model.is_premium ? '<span class="premium-badge">PREMIUM</span>' : ''}
+                    </div>
+                    <div class="custom-model-actions">
+                        <button class="btn btn-sm btn-danger" onclick="deleteCustomModel('${model.model_id}')">Delete</button>
+                    </div>
+                </div>
+                <div style="font-size: 0.9em; color: #666;">
+                    <strong>ID:</strong> ${model.model_id}<br>
+                    <strong>Provider:</strong> ${model.provider.toUpperCase()}<br>
+                    <strong>Description:</strong> ${model.description}<br>
+                    <strong>Costs:</strong> $${model.input_cost_per_1k.toFixed(3)}/1K in, $${model.output_cost_per_1k.toFixed(3)}/1K out<br>
+                    <strong>Context:</strong> ${model.context_length.toLocaleString()} tokens<br>
+                    <strong>Status:</strong> ${model.is_whitelisted ? '<span style="color: green;">Enabled</span>' : '<span style="color: red;">Disabled</span>'}
+                </div>
+            </div>
+        `;
+    });
+    
+    customModelsList.innerHTML = html;
+}
+
+function deleteCustomModel(modelId) {
+    if (!confirm('Are you sure you want to delete this custom model? This action cannot be undone.')) {
+        return;
+    }
+    
+    fetch(`/admin/model-families/api/models/${modelId}`, {
+        method: 'DELETE',
+        headers: {
+            'X-CSRFToken': document.querySelector('meta[name="csrf-token"]')?.getAttribute('content') || ''
+        }
+    })
+    .then(response => response.json())
+    .then(result => {
+        if (result.success) {
+            showNotification(result.message, 'success');
+            loadCustomModels(); // Refresh the list
+            // Also refresh the main page after a short delay
+            setTimeout(() => location.reload(), 1000);
+        } else {
+            showNotification(result.error || 'Failed to delete model', 'error');
+        }
+    })
+    .catch(error => {
+        console.error('Error:', error);
+        showNotification('Network error occurred', 'error');
+    });
+}
+
+// Close modal when clicking outside
+window.onclick = function(event) {
+    if (event.target.classList.contains('modal')) {
+        event.target.style.display = 'none';
+    }
+}
 </script>
 {% endblock %}

src/routes/model_families_admin.py

@@ -10,7 +10,7 @@ from typing import Dict, Any, List
 import json
 
 from ..middleware.auth import require_admin_session
-from ..services.model_families import model_manager, AIProvider
+from ..services.model_families import model_manager, AIProvider, ModelInfo
 from ..services.firebase_logger import structured_logger
 
 model_families_bp = Blueprint('model_families', __name__, url_prefix='/admin/model-families')
@@ -246,4 +246,195 @@ def usage_analytics():
                          cost_analysis=cost_analysis,
                          top_models_by_cost=top_models_by_cost,
                          top_models_by_requests=top_models_by_requests,
-                         global_stats=global_stats)
+                         global_stats=global_stats)
+
+@model_families_bp.route('/api/models', methods=['POST'])
+@require_admin_session
+def add_custom_model():
+    """Add a new custom model"""
+    data = request.get_json()
+    
+    if not data:
+        return jsonify({'error': 'No data provided'}), 400
+    
+    # Validate the model data
+    errors = model_manager.validate_model_data(data)
+    if errors:
+        return jsonify({'error': 'Validation failed', 'field_errors': errors}), 400
+    
+    try:
+        # Create ModelInfo object
+        model_info = ModelInfo(
+            model_id=data['model_id'],
+            provider=AIProvider(data['provider'].lower()),
+            display_name=data['display_name'],
+            description=data['description'],
+            input_cost_per_1k=float(data.get('input_cost_per_1k', 0)),
+            output_cost_per_1k=float(data.get('output_cost_per_1k', 0)),
+            context_length=int(data.get('context_length', 4096)),
+            supports_streaming=bool(data.get('supports_streaming', True)),
+            supports_function_calling=bool(data.get('supports_function_calling', False)),
+            is_premium=bool(data.get('is_premium', False)),
+            cat_personality=data.get('cat_personality', 'curious')
+        )
+        
+        # Add the model
+        auto_whitelist = data.get('auto_whitelist', True)
+        success = model_manager.add_custom_model(model_info, auto_whitelist)
+        
+        if success:
+            # Log admin action
+            structured_logger.log_user_action(
+                user_token='admin',
+                action='custom_model_added',
+                details={
+                    'model_id': model_info.model_id,
+                    'provider': model_info.provider.value,
+                    'display_name': model_info.display_name,
+                    'auto_whitelisted': auto_whitelist
+                },
+                admin_user='admin'
+            )
+            
+            return jsonify({
+                'success': True,
+                'message': f'Model {model_info.display_name} added successfully',
+                'model_id': model_info.model_id,
+                'whitelisted': auto_whitelist
+            })
+        else:
+            return jsonify({'error': 'Failed to add model (already exists?)'}), 400
+            
+    except ValueError as e:
+        return jsonify({'error': f'Invalid data: {str(e)}'}), 400
+    except Exception as e:
+        return jsonify({'error': f'Server error: {str(e)}'}), 500
+
+@model_families_bp.route('/api/models/<model_id>', methods=['PUT'])
+@require_admin_session
+def update_custom_model(model_id: str):
+    """Update an existing custom model"""
+    data = request.get_json()
+    
+    if not data:
+        return jsonify({'error': 'No data provided'}), 400
+    
+    # Remove model_id from validation data to prevent uniqueness check
+    validation_data = data.copy()
+    validation_data.pop('model_id', None)
+    
+    # Validate the model data (excluding model_id)
+    errors = model_manager.validate_model_data(validation_data)
+    if errors:
+        return jsonify({'error': 'Validation failed', 'field_errors': errors}), 400
+    
+    try:
+        # Convert numeric fields
+        updates = {}
+        for field in ['input_cost_per_1k', 'output_cost_per_1k', 'context_length']:
+            if field in data:
+                updates[field] = float(data[field]) if field != 'context_length' else int(data[field])
+        
+        # Convert boolean fields
+        for field in ['supports_streaming', 'supports_function_calling', 'is_premium']:
+            if field in data:
+                updates[field] = bool(data[field])
+        
+        # Copy string fields
+        for field in ['display_name', 'description', 'cat_personality']:
+            if field in data:
+                updates[field] = data[field]
+        
+        success = model_manager.update_model_info(model_id, updates)
+        
+        if success:
+            # Log admin action
+            structured_logger.log_user_action(
+                user_token='admin',
+                action='custom_model_updated',
+                details={
+                    'model_id': model_id,
+                    'updates': updates
+                },
+                admin_user='admin'
+            )
+            
+            return jsonify({
+                'success': True,
+                'message': f'Model {model_id} updated successfully'
+            })
+        else:
+            return jsonify({'error': 'Model not found'}), 404
+            
+    except Exception as e:
+        return jsonify({'error': f'Server error: {str(e)}'}), 500
+
+@model_families_bp.route('/api/models/<model_id>', methods=['DELETE'])
+@require_admin_session
+def delete_custom_model(model_id: str):
+    """Delete a custom model"""
+    try:
+        # Get model info for logging
+        model_info = model_manager.get_model_info(model_id)
+        if not model_info:
+            return jsonify({'error': 'Model not found'}), 404
+        
+        success = model_manager.remove_custom_model(model_id)
+        
+        if success:
+            # Log admin action
+            structured_logger.log_user_action(
+                user_token='admin',
+                action='custom_model_deleted',
+                details={
+                    'model_id': model_id,
+                    'display_name': model_info.display_name,
+                    'provider': model_info.provider.value
+                },
+                admin_user='admin'
+            )
+            
+            return jsonify({
+                'success': True,
+                'message': f'Model {model_info.display_name} deleted successfully'
+            })
+        else:
+            return jsonify({'error': 'Failed to delete model'}), 500
+            
+    except Exception as e:
+        return jsonify({'error': f'Server error: {str(e)}'}), 500
+
+@model_families_bp.route('/api/models/custom')
+@require_admin_session
+def get_custom_models():
+    """Get all custom models"""
+    try:
+        custom_models = model_manager.get_custom_models()
+        
+        models_data = []
+        for model in custom_models:
+            model_dict = {
+                'model_id': model.model_id,
+                'provider': model.provider.value,
+                'display_name': model.display_name,
+                'description': model.description,
+                'input_cost_per_1k': model.input_cost_per_1k,
+                'output_cost_per_1k': model.output_cost_per_1k,
+                'context_length': model.context_length,
+                'supports_streaming': model.supports_streaming,
+                'supports_function_calling': model.supports_function_calling,
+                'is_premium': model.is_premium,
+                'cat_personality': model.cat_personality,
+                'cat_emoji': model.get_cat_emoji(),
+                'is_whitelisted': model_manager.is_model_whitelisted(model.provider, model.model_id)
+            }
+            models_data.append(model_dict)
+        
+        return jsonify({
+            'success': True,
+            'models': models_data,
+            'count': len(models_data)
+        })
+        
+    except Exception as e:
+        return jsonify({'error': f'Server error: {str(e)}'}), 500

src/services/model_families.py

@@ -149,6 +149,9 @@ class ModelFamilyManager:
         
         # Load configuration
         self._load_configuration()
+        
+        # Load custom models
+        self._load_custom_models()
     
     def _initialize_default_models(self):
         """Initialize with default model configurations"""
@@ -496,6 +499,196 @@ class ModelFamilyManager:
                 'by_provider': by_provider,
                 'currency': 'USD'
             }
+    
+    def add_custom_model(self, model_info: ModelInfo, auto_whitelist: bool = True) -> bool:
+        """Add a custom model to the system"""
+        with self.lock:
+            # Check if model already exists
+            if model_info.model_id in self.models:
+                return False
+            
+            # Add the model
+            self.models[model_info.model_id] = model_info
+            
+            # Auto-whitelist if requested
+            if auto_whitelist:
+                provider = model_info.provider
+                if provider not in self.whitelisted_models:
+                    self.whitelisted_models[provider] = set()
+                self.whitelisted_models[provider].add(model_info.model_id)
+            
+            # Save configuration
+            self._save_configuration()
+            
+            # Save custom models to Firebase/file
+            self._save_custom_models()
+            
+            return True
+    
+    def remove_custom_model(self, model_id: str) -> bool:
+        """Remove a custom model from the system"""
+        with self.lock:
+            if model_id not in self.models:
+                return False
+            
+            model_info = self.models[model_id]
+            
+            # Remove from whitelist first
+            provider = model_info.provider
+            if provider in self.whitelisted_models:
+                self.whitelisted_models[provider].discard(model_id)
+            
+            # Remove from models
+            del self.models[model_id]
+            
+            # Save configuration
+            self._save_configuration()
+            
+            # Save custom models to Firebase/file
+            self._save_custom_models()
+            
+            return True
+    
+    def get_custom_models(self) -> List[ModelInfo]:
+        """Get all custom (non-default) models"""
+        with self.lock:
+            # Default models are those defined in _initialize_default_models
+            default_model_ids = {
+                "gpt-4o", "gpt-4o-mini", "gpt-3.5-turbo",
+                "claude-3-5-sonnet-20241022", "claude-3-haiku-20240307",
+                "gemini-1.5-pro", "gemini-1.5-flash"
+            }
+            
+            return [
+                model for model_id, model in self.models.items()
+                if model_id not in default_model_ids
+            ]
+    
+    def update_model_info(self, model_id: str, updates: Dict[str, Any]) -> bool:
+        """Update an existing model's information"""
+        with self.lock:
+            if model_id not in self.models:
+                return False
+            
+            model_info = self.models[model_id]
+            
+            # Update allowed fields
+            allowed_fields = {
+                'display_name', 'description', 'input_cost_per_1k', 'output_cost_per_1k',
+                'context_length', 'supports_streaming', 'supports_function_calling',
+                'is_premium', 'cat_personality'
+            }
+            
+            for field, value in updates.items():
+                if field in allowed_fields and hasattr(model_info, field):
+                    setattr(model_info, field, value)
+            
+            # Save configuration
+            self._save_configuration()
+            self._save_custom_models()
+            
+            return True
+    
+    def _save_custom_models(self):
+        """Save custom models to persistent storage"""
+        custom_models = self.get_custom_models()
+        
+        # Convert to serializable format
+        models_data = []
+        for model in custom_models:
+            model_dict = asdict(model)
+            model_dict['provider'] = model.provider.value  # Convert enum to string
+            models_data.append(model_dict)
+        
+        config = {
+            'custom_models': models_data,
+            'last_updated': datetime.now().isoformat()
+        }
+        
+        if self.firebase_db:
+            try:
+                custom_models_ref = self.firebase_db.child('custom_models')
+                custom_models_ref.set(config)
+            except Exception as e:
+                print(f"Failed to save custom models to Firebase: {e}")
+        else:
+            try:
+                with open("custom_models.json", 'w') as f:
+                    json.dump(config, f, indent=2)
+            except Exception as e:
+                print(f"Failed to save custom models to file: {e}")
+    
+    def _load_custom_models(self):
+        """Load custom models from persistent storage"""
+        if self.firebase_db:
+            try:
+                custom_models_ref = self.firebase_db.child('custom_models')
+                config = custom_models_ref.get()
+                
+                if config and 'custom_models' in config:
+                    for model_data in config['custom_models']:
+                        # Convert provider string back to enum
+                        model_data['provider'] = AIProvider(model_data['provider'])
+                        model_info = ModelInfo(**model_data)
+                        self.models[model_info.model_id] = model_info
+                
+            except Exception as e:
+                print(f"Failed to load custom models from Firebase: {e}")
+        else:
+            try:
+                if os.path.exists("custom_models.json"):
+                    with open("custom_models.json", 'r') as f:
+                        config = json.load(f)
+                    
+                    if 'custom_models' in config:
+                        for model_data in config['custom_models']:
+                            # Convert provider string back to enum
+                            model_data['provider'] = AIProvider(model_data['provider'])
+                            model_info = ModelInfo(**model_data)
+                            self.models[model_info.model_id] = model_info
+                            
+            except Exception as e:
+                print(f"Failed to load custom models from file: {e}")
+    
+    def validate_model_data(self, model_data: Dict[str, Any]) -> Dict[str, str]:
+        """Validate model data and return any errors"""
+        errors = {}
+        
+        # Required fields
+        required_fields = ['model_id', 'provider', 'display_name', 'description']
+        for field in required_fields:
+            if not model_data.get(field):
+                errors[field] = f"{field} is required"
+        
+        # Validate provider
+        if model_data.get('provider'):
+            try:
+                AIProvider(model_data['provider'].lower())
+            except ValueError:
+                errors['provider'] = "Invalid AI provider"
+        
+        # Validate numeric fields
+        numeric_fields = ['input_cost_per_1k', 'output_cost_per_1k', 'context_length']
+        for field in numeric_fields:
+            if field in model_data:
+                try:
+                    float(model_data[field])
+                    if float(model_data[field]) < 0:
+                        errors[field] = f"{field} must be non-negative"
+                except (ValueError, TypeError):
+                    errors[field] = f"{field} must be a valid number"
+        
+        # Validate model_id uniqueness
+        if model_data.get('model_id') and model_data['model_id'] in self.models:
+            errors['model_id'] = "Model ID already exists"
+        
+        # Validate cat personality
+        if model_data.get('cat_personality'):
+            valid_personalities = {"curious", "playful", "sleepy", "grumpy", "smart", "fast"}
+            if model_data['cat_personality'] not in valid_personalities:
+                errors['cat_personality'] = f"Invalid cat personality. Must be one of: {', '.join(valid_personalities)}"
+        
+        return errors
 
 # Global instance
 model_manager = ModelFamilyManager()