Upload 54 files

Readme.md

@@ -0,0 +1,227 @@
+🚀 Comprehensive Strategy for Building an AI Tools Platform with Ad-Based Monetization (AWS Focused for 1 Lakh DAUs)
+🔍 Vision
+Build a low-cost yet scalable AI tools platform where users can access various AI services (text, image, audio, etc.) by watching ads. Each tool will have dynamic credit allocation — text tools (1 min ad), image tools (2 min ad), etc.
+
+📐 Architecture Blueprint
+A robust, scalable, and cost-effective architecture will ensure smooth performance for 1 lakh DAUs.
+
+🧩 Key Components
+Frontend: Html/css/js
+Backend: FastAPI / Flask (for managing AI tool requests)
+AI Models: Hugging Face, DeepSeek, OpenRouter, etc.
+Database: DynamoDB / PostgreSQL (low latency, scalable)
+Cache Layer: Redis / ElastiCache (to reduce API costs)
+Ad System: Google AdSense, AdMob, or Revcontent
+Deployment & Scaling: AWS ECS + Fargate (serverless scaling)
+CDN for Speed: Cloudflare (faster static content delivery)
+Authentication: AWS Cognito / Auth0 for secure logins
+🏗️ System Design Flow
+✅ Step 1: User visits the platform and selects an AI tool.
+✅ Step 2: Platform verifies user's credit balance.
+
+🔸 If sufficient credits → Access tool directly.
+🔸 If insufficient credits → Show an ad to earn credits.
+✅ Step 3: Credits are dynamically assigned based on the tool:
+🔹 Text Models: 1 Min Ad → +5 Credits
+🔹 Image Models: 2 Min Ad → +10 Credits
+ User custom Promts by user where user edit the make their own uses and user who created gets cut for promts 2% of model model tool creadit 
+✅ Step 4: User request is processed via FastAPI backend.
+✅ Step 5: AI Model API is triggered (DeepSeek, Mistral, OpenRouter, etc.)
+✅ Step 6: Result is stored in DynamoDB and cached via Redis for repeat queries.
+
+
+
+Tool Type	Ad Watch Time	Credits Earned	Estimated Cost Per Request
+Text Models	1 Minute Ad	+5 Credits	₹0.01 - ₹0.05 per request
+Image Models	2 Minute Ad	+10 Credits	₹0.10 - ₹0.50 per request
+Video Models	3 Minute Ad	+15 Credits	₹0.50 - ₹1.00 per request
+
+
+
+⚙️ Technical Stack (Optimized for AWS and Cost Efficiency)
+Component	Recommended Solution
+Frontend	Streamlit + React (for hybrid UI needs)
+Backend	FastAPI (best for speed & scalability)
+AI Model Hosting	AWS Lambda (for lightweight AI models)
+AI Model APIs	Hugging Face / DeepSeek API
+Database	DynamoDB (serverless, scalable)
+Cache	Redis (ElastiCache for low latency)
+Ad System	Google AdSense / AdMob
+Deployment	AWS ECS (with Fargate for auto-scaling)
+CDN	Cloudflare (for global content delivery)
+Auth	AWS Cognito (scalable user management)
+
+
+💰 Cost Optimization Plan for 1 Lakh DAUs
+Component	Estimated Cost (₹/month)	Optimization Strategy
+AWS ECS + Fargate	₹18,000 - ₹25,000	Efficient container scaling
+DynamoDB (Database)	₹5,000 - ₹7,000	Use on-demand mode
+Redis (ElastiCache)	₹3,000 - ₹5,000	Cache frequently accessed data
+AI Model API Usage	₹20,000 - ₹40,000	Optimize prompt structure
+Cloudflare (CDN)	₹5,000 - ₹8,000	Leverage caching for static files
+Google AdSense Revenue	₹1,20,000 - ₹1,80,000	Based on ad engagement (30% conversion)
+✅ Projected Net Profit Estimate: ₹60,000 - ₹1,00,000 (assuming 40% user engagement)
+
+🧮 Credit System with Dynamic Scaling
+Tool Type	Ad Watch Time	Credits Earned	Estimated Cost Per Request
+Text Models	1 Minute Ad	+5 Credits	₹0.01 - ₹0.05 per request
+Image Models	2 Minute Ad	+10 Credits	₹0.10 - ₹0.50 per request
+Video Models	3 Minute Ad	+15 Credits	₹0.50 - ₹1.00 per request
+
+✅ Logic: Higher resource-intensive models require longer ad watch times.
+
+📋 Project Structure (Best Practices)
+
+/app
+ ├── /frontend
+ │   ├── main.py
+ │   ├── pages/
+ │   ├── components/
+     | UI/
+ ├── /backend
+ │   ├── api.py
+ │   ├── credit_manager.py
+ │   ├── ad_manager.py
+ │   └── ai_service.py
+ ├── /database
+ │   ├── db_connector.py
+ │   └── credit_tracker.py
+ ├── /models
+ │   ├── text_gen_model.py
+ │   ├── image_gen_model.py
+ │   └── video_gen_model.py
+ ├── Dockerfile
+ ├── requirements.txt
+ ├── .env
+ └── config.yaml
+
+🔐 Security Best Practices
+✅ AWS Cognito for user authentication.
+✅ IAM Role Management to control resource access.
+✅ Use CloudWatch for monitoring performance and security threats.
+✅ Implement Rate Limiting for API abuse prevention.
+✅ Set SSL/TLS encryption for secure data transmission.
+
+📈 Scaling Strategy for 1 Lakh DAUs
+✅ ECS Auto-Scaling Policies: Use CPU & Memory-based scaling triggers.
+✅ DynamoDB Auto-Scaling: Set capacity limits with automatic scale-up.
+✅ Implement Cloudflare CDN for fast content delivery.
+✅ Optimize API requests using batch processing to minimize load.
+✅ Use Lambda Edge for regional content caching.
+
+🔊 Ad Revenue Optimization Strategy
+✅ Use Google AdSense Video Ads for high-payout ads.
+✅ Add Interactive Ads to boost engagement.
+✅ Introduce Rewarded Ads (watch longer ads for bonus credits).
+✅ Implement a Referral System to increase user retention.
+
+✅ Step-by-Step Development Plan
+1️⃣ Create Streamlit Frontend → Design dynamic UI with credit-based access.
+2️⃣ Build Backend (FastAPI/Flask) → Integrate AI model APIs with token logic.
+3️⃣ Set Up Ad Management System → Implement Google AdSense/AdMob integration.
+4️⃣ Implement Credit-Based Workflow → Map credit logic to ad-watch duration.
+5️⃣ Optimize AI Model Costs → Use caching (Redis) to reduce redundant calls.
+6️⃣ Deploy on AWS ECS + Fargate → Set up auto-scaling for cost control.
+7️⃣ Add Analytics → Track user behavior, ad conversion, and credit consumption.
+
+🎯 Bonus Features for Maximum Engagement
+✅ Leaderboard System: Users earn bonus credits by inviting friends.
+✅ Daily Login Rewards: Encourage repeat visits with small bonuses.
+✅ Premium Subscription Model: Offer ad-free premium access with special tools.
+✅ Limited-Time Offers: Drive engagement with exclusive tool unlocks.
+
+# MegicAI Platform
+
+Multi-provider AI platform with credit system and ad-based monetization.
+
+## Features
+
+- **Multiple AI Providers**: Support for OpenAI, Hugging Face, and OpenRouter
+- **Fallback Mechanism**: Automatically switches to available providers if one fails
+- **Credit System**: Users earn credits by watching ads
+- **Modern UI**: Professional interface with animations and responsive design
+- **Tool Selection**: Various AI tools for different use cases (text, image, video, etc.)
+- **Model Selection**: Choose specific AI provider for each request
+
+## Quick Start
+
+### Prerequisites
+
+- Python 3.8+
+- Redis server (for caching)
+
+### Installation
+
+1. Clone the repository:
+   ```
+   git clone https://github.com/yourusername/megicai.git
+   cd megicai
+   ```
+
+2. Install dependencies:
+   ```
+   pip install -r requirements.txt
+   ```
+
+3. Start the application (both backend and frontend):
+   ```
+   python start.py
+   ```
+
+4. Access the application:
+   - Frontend: http://localhost:8501
+   - Backend API: http://localhost:8000
+
+## Development Setup
+
+1. Install development dependencies:
+   ```
+   pip install -r requirements-dev.txt
+   ```
+
+2. Run backend server only:
+   ```
+   python backend/run_server.py backend.api_minimal
+   ```
+
+3. Run frontend only:
+   ```
+   streamlit run frontend/main.py
+   ```
+
+## Production Deployment
+
+### Docker Deployment
+
+1. Build the Docker image:
+   ```
+   docker build -t megicai:latest .
+   ```
+
+2. Run with Docker Compose:
+   ```
+   docker-compose up -d
+   ```
+
+### AWS Deployment
+
+1. Set up the required AWS resources:
+   - ECS cluster for containerized deployment
+   - ElastiCache (Redis) for caching
+   - DynamoDB for user data and credits
+   - Cognito for authentication
+
+2. Configure environment variables in AWS Parameter Store or Secrets Manager.
+
+3. Deploy using the AWS CDK or CloudFormation template in the `deployment` directory.
+
+## Configuration
+
+Edit `config.yaml` to configure:
+- AI provider API keys
+- Redis connection details
+- Credit system parameters
+
+## License
+
+MIT

ads/__init__.py

@@ -0,0 +1,10 @@
+"""
+Ads Package
+Exports Google Ads integration classes
+"""
+
+from ads.google_ads import GoogleAdsManager
+
+__all__ = [
+    'GoogleAdsManager'
+] 

ads/ads_config.json

@@ -0,0 +1,28 @@
+{
+  "publisher_id": "",
+  "ad_units": {
+    "sidebar": {
+      "ad_unit_id": "1234567890",
+      "ad_format": "display",
+      "width": 300,
+      "height": 250,
+      "slot": "sidebar-ad",
+      "enabled": true
+    },
+    "footer": {
+      "ad_unit_id": "0987654321",
+      "ad_format": "display",
+      "width": 728,
+      "height": 90,
+      "slot": "footer-ad",
+      "enabled": true
+    },
+    "reward_video": {
+      "ad_unit_id": "5678901234",
+      "ad_format": "video",
+      "slot": "reward-video-ad",
+      "enabled": true,
+      "reward_credits": 10
+    }
+  }
+}

ads/clicks.json

@@ -0,0 +1 @@
+[]

ads/google_ads.py

@@ -0,0 +1,376 @@
+"""
+Google Ads Integration
+Handles displaying Google AdSense ads and tracking ad impressions/clicks
+"""
+import os
+import uuid
+import logging
+import json
+import time
+from typing import Dict, Any, Optional, List
+from datetime import datetime
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("google_ads")
+
+class GoogleAdsManager:
+    """Manages Google AdSense integration and tracking"""
+    
+    def __init__(self, publisher_id: Optional[str] = None, config_file: str = None):
+        """Initialize Google Ads Manager"""
+        self.publisher_id = publisher_id or os.getenv("GOOGLE_ADSENSE_PUBLISHER_ID", "")
+        self.config_file = config_file or os.path.join(os.path.dirname(__file__), "ads_config.json")
+        
+        # Load ad units configuration
+        self.ad_units = self._load_ad_units()
+        
+        # Track impressions and clicks
+        self.impressions_file = os.path.join(os.path.dirname(__file__), "impressions.json")
+        self.clicks_file = os.path.join(os.path.dirname(__file__), "clicks.json")
+        
+        # Create tracking files if they don't exist
+        self._initialize_tracking_files()
+    
+    def _load_ad_units(self) -> Dict[str, Any]:
+        """Load ad units configuration"""
+        default_ad_units = {
+            "sidebar": {
+                "ad_unit_id": "1234567890",
+                "ad_format": "display",
+                "width": 300,
+                "height": 250,
+                "slot": "sidebar-ad",
+                "enabled": True
+            },
+            "footer": {
+                "ad_unit_id": "0987654321",
+                "ad_format": "display",
+                "width": 728,
+                "height": 90,
+                "slot": "footer-ad",
+                "enabled": True
+            },
+            "reward_video": {
+                "ad_unit_id": "5678901234",
+                "ad_format": "video",
+                "slot": "reward-video-ad",
+                "enabled": True,
+                "reward_credits": 10
+            }
+        }
+        
+        # Create config file with default values if it doesn't exist
+        if not os.path.exists(self.config_file):
+            os.makedirs(os.path.dirname(self.config_file), exist_ok=True)
+            with open(self.config_file, "w") as f:
+                json.dump({"publisher_id": self.publisher_id, "ad_units": default_ad_units}, f, indent=2)
+            return default_ad_units
+        
+        # Load config from file
+        try:
+            with open(self.config_file, "r") as f:
+                config = json.load(f)
+                
+                # Update publisher ID if it was set in the config file
+                if config.get("publisher_id"):
+                    self.publisher_id = config["publisher_id"]
+                
+                return config.get("ad_units", default_ad_units)
+        except Exception as e:
+            logger.error(f"Error loading ad units config: {e}")
+            return default_ad_units
+    
+    def _initialize_tracking_files(self):
+        """Initialize tracking files if they don't exist"""
+        os.makedirs(os.path.dirname(self.impressions_file), exist_ok=True)
+        
+        if not os.path.exists(self.impressions_file):
+            with open(self.impressions_file, "w") as f:
+                json.dump([], f)
+        
+        if not os.path.exists(self.clicks_file):
+            with open(self.clicks_file, "w") as f:
+                json.dump([], f)
+    
+    def get_ad_code(self, ad_position: str) -> Dict[str, Any]:
+        """
+        Get HTML/JS code for displaying an ad at the specified position
+        Returns both the ad code and metadata about the ad
+        """
+        if not self.publisher_id:
+            logger.warning("No Google AdSense publisher ID configured")
+            return {"success": False, "error": "No publisher ID configured"}
+        
+        # Get ad unit configuration
+        ad_unit = self.ad_units.get(ad_position)
+        if not ad_unit:
+            logger.error(f"Ad position '{ad_position}' not configured")
+            return {"success": False, "error": f"Ad position '{ad_position}' not found"}
+        
+        if not ad_unit.get("enabled", True):
+            logger.info(f"Ad unit '{ad_position}' is disabled")
+            return {"success": False, "error": "Ad unit is disabled"}
+        
+        # Generate HTML/JS code for the ad
+        ad_format = ad_unit.get("ad_format", "display")
+        ad_unit_id = ad_unit.get("ad_unit_id", "")
+        ad_slot = ad_unit.get("slot", f"{ad_position}-ad")
+        
+        if ad_format == "display":
+            width = ad_unit.get("width", 300)
+            height = ad_unit.get("height", 250)
+            
+            ad_code = f"""
+            <ins class="adsbygoogle"
+                 style="display:inline-block;width:{width}px;height:{height}px"
+                 data-ad-client="ca-pub-{self.publisher_id}"
+                 data-ad-slot="{ad_unit_id}"></ins>
+            <script>
+                 (adsbygoogle = window.adsbygoogle || []).push({{}});
+            </script>
+            """
+        elif ad_format == "video":
+            ad_code = f"""
+            <div id="{ad_slot}" class="reward-ad-container">
+                <div class="reward-ad-placeholder">
+                    <p>Watch a video to earn {ad_unit.get('reward_credits', 5)} credits</p>
+                    <button class="watch-ad-btn" onclick="loadRewardAd('{ad_slot}', '{ad_unit_id}', {ad_unit.get('reward_credits', 5)})">Watch Now</button>
+                </div>
+            </div>
+            """
+        else:
+            logger.error(f"Unsupported ad format: {ad_format}")
+            return {"success": False, "error": f"Unsupported ad format: {ad_format}"}
+        
+        # Generate a unique ID for tracking this ad impression
+        impression_id = str(uuid.uuid4())
+        
+        # Record the impression for tracking
+        self._record_impression(impression_id, ad_position, ad_unit_id)
+        
+        return {
+            "success": True,
+            "ad_code": ad_code,
+            "impression_id": impression_id,
+            "ad_position": ad_position,
+            "ad_format": ad_format,
+            "reward_credits": ad_unit.get("reward_credits", 0) if ad_format == "video" else 0
+        }
+    
+    def _record_impression(self, impression_id: str, ad_position: str, ad_unit_id: str):
+        """Record an ad impression for tracking"""
+        try:
+            # Load existing impressions
+            with open(self.impressions_file, "r") as f:
+                impressions = json.load(f)
+            
+            # Add new impression
+            impressions.append({
+                "id": impression_id,
+                "timestamp": datetime.now().isoformat(),
+                "ad_position": ad_position,
+                "ad_unit_id": ad_unit_id
+            })
+            
+            # Save updated impressions
+            with open(self.impressions_file, "w") as f:
+                json.dump(impressions, f, indent=2)
+                
+        except Exception as e:
+            logger.error(f"Error recording ad impression: {e}")
+    
+    def record_ad_click(self, impression_id: str, user_id: Optional[str] = None) -> bool:
+        """Record an ad click for tracking"""
+        try:
+            # Load existing clicks
+            with open(self.clicks_file, "r") as f:
+                clicks = json.load(f)
+            
+            # Add new click
+            clicks.append({
+                "impression_id": impression_id,
+                "user_id": user_id,
+                "timestamp": datetime.now().isoformat()
+            })
+            
+            # Save updated clicks
+            with open(self.clicks_file, "w") as f:
+                json.dump(clicks, f, indent=2)
+                
+            return True
+                
+        except Exception as e:
+            logger.error(f"Error recording ad click: {e}")
+            return False
+    
+    def record_reward_ad_completion(self, impression_id: str, user_id: str) -> Dict[str, Any]:
+        """
+        Record completion of a reward ad and return reward information
+        
+        Args:
+            impression_id: The unique ID of the ad impression
+            user_id: The user ID to reward
+            
+        Returns:
+            Dictionary with reward information and success status
+        """
+        try:
+            # Find the impression to determine the ad unit
+            with open(self.impressions_file, "r") as f:
+                impressions = json.load(f)
+            
+            # Find the impression with matching ID
+            impression = next((imp for imp in impressions if imp.get("id") == impression_id), None)
+            if not impression:
+                logger.error(f"Impression ID {impression_id} not found")
+                return {
+                    "success": False, 
+                    "error": "Invalid impression ID"
+                }
+            
+            # Get the ad position from the impression
+            ad_position = impression.get("ad_position")
+            ad_unit = self.ad_units.get(ad_position)
+            
+            if not ad_unit:
+                logger.error(f"Ad unit for position {ad_position} not found")
+                return {
+                    "success": False,
+                    "error": "Ad unit not found"
+                }
+            
+            # Get the reward amount
+            reward_credits = ad_unit.get("reward_credits", 0)
+            
+            # Record the ad completion (we could store this in a separate file)
+            self.record_ad_click(impression_id, user_id)
+            
+            return {
+                "success": True,
+                "reward_credits": reward_credits,
+                "user_id": user_id,
+                "impression_id": impression_id,
+                "timestamp": datetime.now().isoformat()
+            }
+            
+        except Exception as e:
+            logger.error(f"Error processing reward ad completion: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    def get_html_header_code(self) -> str:
+        """Get the HTML code to include in the page header for AdSense"""
+        if not self.publisher_id:
+            return ""
+            
+        return f"""
+        <script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-{self.publisher_id}"
+             crossorigin="anonymous"></script>
+        """
+    
+    def get_reward_ad_js(self) -> str:
+        """Get the JavaScript code for handling reward ads"""
+        return """
+        <script>
+        let rewardAdLoaded = false;
+        let adEventListenersAdded = false;
+        let currentAdSlot = null;
+        let rewardAmount = 0;
+        
+        function loadRewardAd(adSlot, adUnitId, credits) {
+            currentAdSlot = adSlot;
+            rewardAmount = credits;
+            
+            // Show loading indicator
+            document.getElementById(adSlot).innerHTML = '<div class="loading-ad">Loading ad, please wait...</div>';
+            
+            // Create a new ad container
+            const adContainer = document.createElement('div');
+            adContainer.id = adSlot + '-container';
+            document.getElementById(adSlot).appendChild(adContainer);
+            
+            // Load the Google ad
+            const adManager = new google.ads.AdManager(adContainer);
+            
+            // Set up the ad
+            adManager.setAdUnitPath(`/ca-pub-${publisherId}/${adUnitId}`);
+            adManager.setAdSize([300, 250]);
+            
+            // Add event listeners
+            if (!adEventListenersAdded) {
+                adManager.addEventListener('loaded', onAdLoaded);
+                adManager.addEventListener('error', onAdError);
+                adManager.addEventListener('completed', onAdCompleted);
+                adEventListenersAdded = true;
+            }
+            
+            // Load the ad
+            adManager.load();
+        }
+        
+        function onAdLoaded() {
+            rewardAdLoaded = true;
+            document.getElementById(currentAdSlot).querySelector('.loading-ad').style.display = 'none';
+        }
+        
+        function onAdError(error) {
+            document.getElementById(currentAdSlot).innerHTML = 
+                `<div class="ad-error">Error loading ad: ${error.message}. Please try again later.</div>`;
+        }
+        
+        function onAdCompleted() {
+            // Send a request to the server to record the completion and reward the user
+            fetch('/api/ads/reward', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    impression_id: currentImpressionId,
+                    completed: true
+                })
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    // Show success message
+                    document.getElementById(currentAdSlot).innerHTML = 
+                        `<div class="reward-success">Congratulations! You earned ${rewardAmount} credits.</div>`;
+                    
+                    // Update user credits display if available
+                    const creditsDisplay = document.getElementById('user-credits');
+                    if (creditsDisplay) {
+                        const currentCredits = parseInt(creditsDisplay.innerText, 10);
+                        creditsDisplay.innerText = currentCredits + rewardAmount;
+                    }
+                } else {
+                    document.getElementById(currentAdSlot).innerHTML = 
+                        `<div class="reward-error">Error: ${data.error}</div>`;
+                }
+            })
+            .catch(error => {
+                document.getElementById(currentAdSlot).innerHTML = 
+                    `<div class="reward-error">Error: Unable to process reward. Please try again.</div>`;
+            });
+        }
+        </script>
+        """
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize the ads manager
+    ads_manager = GoogleAdsManager()
+    
+    # Get ad code for the sidebar
+    sidebar_ad = ads_manager.get_ad_code("sidebar")
+    print(f"Sidebar ad success: {sidebar_ad['success']}")
+    
+    if sidebar_ad['success']:
+        print(f"Impression ID: {sidebar_ad['impression_id']}")
+        
+    # Get the header code for AdSense
+    header_code = ads_manager.get_html_header_code()
+    print(f"Header code length: {len(header_code)}") 

ads/impressions.json

@@ -0,0 +1 @@
+[]

app.py

@@ -0,0 +1,1242 @@
+"""
+AI Tool Hub - Main Application
+Integrates all components into a single FastAPI application
+"""
+import os
+import json
+import uuid
+import secrets
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, Any, List, Optional, Union
+
+# Load environment variables from .env file
+from dotenv import load_dotenv
+load_dotenv()
+
+from fastapi import FastAPI, Request, Response, Depends, HTTPException, Form, Cookie, status
+from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.security import APIKeyHeader, HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+# Import provider modules
+from providers import get_provider, HuggingFaceProvider, OpenAIProvider, DeepSeekProvider, OpenRouterProvider
+
+# Import prompt modules
+from prompts import PromptTemplate, PromptTemplateManager, PromptMarketplace
+
+# Import ads module
+from ads import GoogleAdsManager
+
+# Import additional modules
+import random
+import time
+import hashlib
+
+# Import the Base from models.py
+from models import Base
+
+# Import the TOOLS from tools.py
+from tools import TOOLS
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("app")
+
+# Database setup
+DATABASE_URL = "sqlite:///./magicAi.db"  # Path to your SQLite database
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Create the database tables
+Base.metadata.create_all(bind=engine)
+
+# Create the FastAPI app
+app = FastAPI(
+    title="AI Tool Hub",
+    description="A platform for using AI models with various tools and prompt templates",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount static files
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Set up Jinja2 templates
+templates = Jinja2Templates(directory="templates")
+
+# Initialize components
+template_manager = PromptTemplateManager()
+marketplace = PromptMarketplace()
+ads_manager = GoogleAdsManager()
+
+# Security
+API_KEY_NAME = "X-API-Key"
+api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=False)
+security = HTTPBearer(auto_error=False)
+
+# In-memory store of API keys for demo purpose
+# In production, these would be stored in a database
+API_KEYS = {}
+
+# In-memory session store for demo purpose
+# In production, these would be stored in a database or Redis
+SESSIONS = {}
+
+# Add new models for ad rewards
+class AdRewardRequest(BaseModel):
+    ad_type: str  # 'daily' or 'special'
+    impression_id: Optional[str] = None
+
+class DailyReward(BaseModel):
+    user_id: str
+    date: str
+    count: int = 0
+    last_reward: Optional[str] = None
+
+class SpecialReward(BaseModel):
+    user_id: str
+    date: str
+    claimed: bool = False
+    claimed_at: Optional[str] = None
+
+# In-memory stores for rewards (in production, use a database)
+DAILY_REWARDS = {}
+SPECIAL_REWARDS = {}
+
+# Models
+class CreditUpdateRequest(BaseModel):
+    user_id: str
+    amount: float
+    reason: str = "manual"
+
+class GenerateRequest(BaseModel):
+    prompt: str
+    model: str
+    provider: str
+    system_message: Optional[str] = None
+    max_tokens: Optional[int] = 1000
+    temperature: Optional[float] = 0.7
+    prompt_template_id: Optional[str] = None
+    template_variables: Optional[Dict[str, Any]] = None
+
+class ImageGenerateRequest(BaseModel):
+    prompt: str
+    provider: str = "openai"
+    model: Optional[str] = None
+    size: Optional[str] = "1024x1024"
+    prompt_template_id: Optional[str] = None
+    template_variables: Optional[Dict[str, Any]] = None
+
+class UserInfo(BaseModel):
+    id: str
+    username: str
+    email: str
+    credits: float = 10.0  # New users start with some free credits
+    created_at: str = Field(default_factory=lambda: datetime.now().isoformat())
+    last_login: str = Field(default_factory=lambda: datetime.now().isoformat())
+    role: str = "user"
+
+# Models for prompt system
+class Prompt(BaseModel):
+    id: str
+    tool_id: str
+    title: str
+    content: str
+    description: Optional[str] = None
+    creator_id: Optional[str] = None
+    is_default: bool = False
+    usage_count: int = 0
+    avg_rating: float = 0.0
+    created_at: str = None
+    updated_at: str = None
+    tags: List[str] = []
+
+class PromptRating(BaseModel):
+    prompt_id: str
+    user_id: str
+    rating: int  # 1-5
+    created_at: str
+
+class UserPromptHistory(BaseModel):
+    user_id: str
+    prompt_id: str
+    tool_id: str
+    used_at: str
+    was_modified: bool = False
+    modifications: Optional[str] = None
+
+# Mock database (replace with actual DynamoDB integration)
+PROMPTS = {}
+PROMPT_RATINGS = []
+USER_PROMPT_HISTORY = []
+
+# Initialize default prompts
+def init_default_prompts():
+    default_prompts = [
+        {
+            "id": "text-summary-default",
+            "tool_id": "text-summary",
+            "title": "Concise Text Summary",
+            "content": "Summarize the following text in 3-5 bullet points highlighting the main ideas: {{input}}",
+            "description": "Creates a bulleted summary of any text",
+            "is_default": True,
+            "tags": ["summary", "concise", "bullets"]
+        },
+        {
+            "id": "image-portrait-default",
+            "tool_id": "image-generator",
+            "title": "Professional Portrait",
+            "content": "Create a professional portrait photo of {{subject}}, high quality, studio lighting, detailed features, professional attire",
+            "description": "Generates professional-looking portrait images",
+            "is_default": True,
+            "tags": ["portrait", "professional", "photo"]
+        },
+        {
+            "id": "text-blog-default",
+            "tool_id": "text-generator",
+            "title": "Blog Post Generator",
+            "content": "Write a comprehensive blog post about {{topic}}. Include an introduction, 3-5 main sections with subheadings, and a conclusion. Use a conversational tone and include practical examples where appropriate.",
+            "description": "Creates complete blog posts with proper structure",
+            "is_default": True,
+            "tags": ["blog", "writing", "content"]
+        },
+        {
+            "id": "code-python-default",
+            "tool_id": "code-generator",
+            "title": "Python Function",
+            "content": "Write a Python function that {{task}}. Include docstrings, type hints, error handling, and comments explaining your logic. Provide a small example of how to use the function.",
+            "description": "Generates well-structured Python functions",
+            "is_default": True,
+            "tags": ["python", "function", "code"]
+        }
+    ]
+    
+    for prompt in default_prompts:
+        prompt_obj = Prompt(
+            id=prompt["id"],
+            tool_id=prompt["tool_id"],
+            title=prompt["title"],
+            content=prompt["content"],
+            description=prompt["description"],
+            is_default=prompt["is_default"],
+            tags=prompt["tags"],
+            created_at=datetime.now().isoformat(),
+            updated_at=datetime.now().isoformat()
+        )
+        PROMPTS[prompt["id"]] = prompt_obj
+
+# Call initialization at startup
+init_default_prompts()
+
+# Helper functions for prompt system
+def get_prompts_for_tool(tool_id: str) -> List[Prompt]:
+    """Get all prompts for a specific tool"""
+    return [p for p in PROMPTS.values() if p.tool_id == tool_id]
+
+def get_default_prompts_for_tool(tool_id: str) -> List[Prompt]:
+    """Get default prompts for a specific tool"""
+    return [p for p in PROMPTS.values() if p.tool_id == tool_id and p.is_default]
+
+def get_trending_prompts(limit: int = 5) -> List[Prompt]:
+    """Get trending prompts based on usage count and ratings"""
+    sorted_prompts = sorted(
+        PROMPTS.values(), 
+        key=lambda p: (p.usage_count * 0.7 + p.avg_rating * 0.3), 
+        reverse=True
+    )
+    return sorted_prompts[:limit]
+
+def get_personalized_prompts(user_id: str, tool_id: str, limit: int = 3) -> List[Prompt]:
+    """Get personalized prompt recommendations for a user and tool"""
+    # Get user history for this tool
+    user_tool_history = [h for h in USER_PROMPT_HISTORY 
+                        if h.user_id == user_id and h.tool_id == tool_id]
+    
+    if not user_tool_history:
+        # If no history, return default prompts
+        return get_default_prompts_for_tool(tool_id)
+    
+    # Count prompt usage
+    prompt_usage = {}
+    for history in user_tool_history:
+        prompt_usage[history.prompt_id] = prompt_usage.get(history.prompt_id, 0) + 1
+    
+    # Get most used prompts
+    most_used_prompt_ids = sorted(prompt_usage.items(), key=lambda x: x[1], reverse=True)
+    most_used_prompts = [PROMPTS.get(pid) for pid, _ in most_used_prompt_ids[:limit]]
+    
+    # If we don't have enough, add some default or trending ones
+    if len(most_used_prompts) < limit:
+        defaults = get_default_prompts_for_tool(tool_id)
+        for default in defaults:
+            if default not in most_used_prompts and len(most_used_prompts) < limit:
+                most_used_prompts.append(default)
+    
+    return most_used_prompts
+
+def record_prompt_usage(user_id: str, prompt_id: str, tool_id: str, was_modified: bool = False, modifications: str = None):
+    """Record that a user used a particular prompt"""
+    # Update prompt usage count
+    if prompt_id in PROMPTS:
+        PROMPTS[prompt_id].usage_count += 1
+        PROMPTS[prompt_id].updated_at = datetime.now().isoformat()
+    
+    # Add to history
+    history_entry = UserPromptHistory(
+        user_id=user_id,
+        prompt_id=prompt_id,
+        tool_id=tool_id,
+        used_at=datetime.now().isoformat(),
+        was_modified=was_modified,
+        modifications=modifications
+    )
+    USER_PROMPT_HISTORY.append(history_entry)
+
+def rate_prompt(user_id: str, prompt_id: str, rating: int):
+    """Add or update a rating for a prompt"""
+    # Check if user already rated this prompt
+    existing_rating = next((r for r in PROMPT_RATINGS if r.user_id == user_id and r.prompt_id == prompt_id), None)
+    
+    if existing_rating:
+        # Update existing rating
+        existing_rating.rating = rating
+        existing_rating.created_at = datetime.now().isoformat()
+    else:
+        # Add new rating
+        rating_obj = PromptRating(
+            prompt_id=prompt_id,
+            user_id=user_id,
+            rating=rating,
+            created_at=datetime.now().isoformat()
+        )
+        PROMPT_RATINGS.append(rating_obj)
+    
+    # Update average rating on prompt
+    if prompt_id in PROMPTS:
+        prompt_ratings = [r.rating for r in PROMPT_RATINGS if r.prompt_id == prompt_id]
+        if prompt_ratings:
+            PROMPTS[prompt_id].avg_rating = sum(prompt_ratings) / len(prompt_ratings)
+            PROMPTS[prompt_id].updated_at = datetime.now().isoformat()
+
+# Dependency to get the database session
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+# User authentication and session management
+def get_session_user(session_id: Optional[str] = Cookie(None)) -> Optional[UserInfo]:
+    """Get the user from the session"""
+    if not session_id or session_id not in SESSIONS:
+        return None
+    
+    session = SESSIONS[session_id]
+    if datetime.now() > session["expires"]:
+        # Session expired
+        del SESSIONS[session_id]
+        return None
+    
+    # Update session expiration
+    session["expires"] = datetime.now() + timedelta(hours=24)
+    
+    return session["user"]
+
+def require_session_user(admin_required: bool = False, session_user: Optional[UserInfo] = Depends(get_session_user)):
+    """Require a logged-in user, optionally requiring admin role"""
+    if not session_user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Authentication required",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    if admin_required and getattr(session_user, "role", "") != "admin":
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Admin access required",
+        )
+    
+    return session_user
+
+def verify_api_key(api_key: str = Depends(api_key_header), 
+                 credentials: HTTPAuthorizationCredentials = Depends(security)) -> UserInfo:
+    """Verify API key from header or Bearer token"""
+    # Try to get the API key from the header
+    key = api_key
+    
+    # If not found, try to get it from the Bearer token
+    if not key and credentials:
+        key = credentials.credentials
+    
+    # Check if the key is valid
+    if not key or key not in API_KEYS:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid API key",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    return API_KEYS[key]["user"]
+
+# Credit packages configuration
+CREDIT_PACKAGES = [
+    {
+        "id": "starter",
+        "name": "Starter Pack",
+        "description": "Perfect for trying out our AI tools",
+        "credits": 100,
+        "price": 49.99
+    },
+    {
+        "id": "pro",
+        "name": "Pro Pack",
+        "description": "Most popular choice for regular users",
+        "credits": 500,
+        "price": 199.99
+    },
+    {
+        "id": "enterprise",
+        "name": "Enterprise Pack",
+        "description": "Best value for power users",
+        "credits": 2000,
+        "price": 690.99
+    }
+]
+
+# Mock user data (replace with database in production)
+users = {}
+
+# Routes
+@app.get("/", response_class=HTMLResponse)
+async def home(request: Request, session_user: Optional[UserInfo] = Depends(get_session_user)):
+    """Home page with tools list"""
+    return templates.TemplateResponse(
+        "index.html", 
+        {
+            "request": request, 
+            "app_name": "AI Tool Hub",
+            "tools": TOOLS,
+            "session_user": session_user,
+            "user": session_user,  # Add user for consistency with other templates
+            "user_credits": session_user.credits if session_user else 0
+        }
+    )
+
+@app.get("/tool/{tool_id}", response_class=HTMLResponse)
+async def tool_page(
+    tool_id: str,
+    request: Request,
+    session_user: Optional[UserInfo] = Depends(get_session_user)
+):
+    """Tool-specific page to execute a specific AI tool"""
+    # Get the tool
+    tool = next((t for t in TOOLS if t.id == tool_id), None)
+    
+    if not tool:
+        return templates.TemplateResponse(
+            "error.html",
+            {
+                "request": request,
+                "app_name": "AI Tool Hub",
+                "error_title": "Tool Not Found",
+                "error_description": "The requested tool does not exist.",
+                "user": session_user,
+                "user_credits": session_user.credits if session_user else 0,
+                "tools": TOOLS  # Include for consistent sidebar navigation
+            }
+        )
+    
+    # Get example prompts for this tool
+    suggestions = tool.example_prompts if hasattr(tool, 'example_prompts') else []
+    
+    # Check if the user has enough credits
+    has_enough_credits = session_user and session_user.credits >= tool.cost if session_user else False
+    
+    # Get available providers directly from the tool
+    providers = tool.providers
+    
+    return templates.TemplateResponse(
+        "tool.html",
+        {
+            "request": request,
+            "app_name": "AI Tool Hub",
+            "tool": tool,
+            "user": session_user,
+            "user_credits": session_user.credits if session_user else 0,
+            "has_enough_credits": has_enough_credits,
+            "suggestions": suggestions,
+            "providers": providers,
+            "tools": TOOLS  # Include all tools for sidebar navigation
+        }
+    )
+
+@app.get("/result/{result_id}", response_class=HTMLResponse)
+async def result_page(
+    request: Request, 
+    result_id: str,
+    session_user: Optional[UserInfo] = Depends(get_session_user)
+):
+    """Result display page"""
+    # In a real app, you'd fetch the result from a database
+    # Here, we'll use a mock result for demonstration
+    result = {
+        "id": result_id,
+        "type": "text",  # or "image" or "code"
+        "provider": "openai",
+        "model": "gpt-4",
+        "prompt": "Write a short poem about AI",
+        "result": """
+        Silicon dreams in neural space,
+        Learning patterns, quickening pace.
+        Algorithms dance with grace divine,
+        In zeros and ones, intelligence shine.
+        
+        Human-made yet growing beyond,
+        Of our creations, we grow fond.
+        Partners in progress, AI and we,
+        Crafting together what's yet to be.
+        """,
+        "created_at": datetime.now().isoformat(),
+        "response_time": 2.3  # seconds
+    }
+    
+    return templates.TemplateResponse(
+        "result.html", 
+        {
+            "request": request, 
+            "app_name": "AI Tool Hub",
+            "result": result,
+            "user": session_user,
+            "user_credits": session_user.credits if session_user else 0
+        }
+    )
+
+@app.get("/marketplace", response_class=HTMLResponse)
+async def marketplace_page(
+    request: Request,
+    category: Optional[str] = None,
+    sort_by: str = "popular",
+    session_user: Optional[UserInfo] = Depends(get_session_user)
+):
+    """Prompt marketplace page"""
+    prompts = marketplace.list_marketplace_prompts(category=category, sort_by=sort_by)
+    
+    return templates.TemplateResponse(
+        "marketplace.html", 
+        {
+            "request": request, 
+            "app_name": "AI Tool Hub",
+            "prompts": prompts,
+            "category": category,
+            "sort_by": sort_by,
+            "user": session_user,
+            "user_credits": session_user.credits if session_user else 0
+        }
+    )
+
+@app.get("/ad", response_class=HTMLResponse)
+async def ad_page(
+    request: Request,
+    session_user: Optional[UserInfo] = Depends(get_session_user)
+):
+    """Ad reward page"""
+    return templates.TemplateResponse(
+        "ad_reward.html", 
+        {
+            "request": request, 
+            "app_name": "AI Tool Hub",
+            "user": session_user,
+            "user_credits": session_user.credits if session_user else 0
+        }
+    )
+
+@app.get("/login", response_class=HTMLResponse)
+async def login_page(request: Request):
+    """Login page"""
+    return templates.TemplateResponse(
+        "login.html", 
+        {
+            "request": request, 
+            "app_name": "AI Tool Hub"
+        }
+    )
+
+@app.post("/login")
+async def login(
+    request: Request,
+    username: str = Form(...),
+    password: str = Form(...)
+):
+    """Process login"""
+    # Check if admin login
+    if username == "admin":
+        # Check admin credentials
+        admin_key = API_KEYS.get("admin_key")
+        if not admin_key or admin_key.get("password") != password:
+            # Admin login failure
+            return templates.TemplateResponse(
+                "login.html",
+                {
+                    "request": request,
+                    "app_name": "AI Tool Hub",
+                    "error": "Invalid admin credentials"
+                },
+                status_code=400
+            )
+        
+        # Admin login success
+        user = admin_key["user"]
+    else:
+        # For demo purposes, any username/password combo works
+        # In production, you'd verify against a database
+        
+        # Create or update user
+        user_id = f"user_{username.lower().replace(' ', '_')}"
+        user = UserInfo(
+            id=user_id,
+            username=username,
+            email=f"{username.lower().replace(' ', '.')}@example.com",
+            last_login=datetime.now().isoformat()
+        )
+        
+        # Create session
+        session_id = secrets.token_urlsafe(32)
+        SESSIONS[session_id] = {
+            "user": user,
+            "expires": datetime.now() + timedelta(hours=24)
+        }
+        
+        # Create redirect response
+        response = RedirectResponse(url="/", status_code=status.HTTP_303_SEE_OTHER)
+        
+        # Set session cookie
+        response.set_cookie(
+            key="session_id",
+            value=session_id,
+            max_age=86400,  # 24 hours
+            httponly=True,
+            samesite="lax"
+        )
+        
+        return response
+
+@app.get("/logout")
+async def logout(
+    response: Response,
+    session_id: Optional[str] = Cookie(None)
+):
+    """Process logout"""
+    if session_id and session_id in SESSIONS:
+        del SESSIONS[session_id]
+    
+    response.delete_cookie(key="session_id")
+    
+    return RedirectResponse(url="/", status_code=status.HTTP_303_SEE_OTHER)
+
+@app.get("/credits", response_class=HTMLResponse)
+async def credits_page(request: Request, session_user: Optional[UserInfo] = Depends(get_session_user)):
+    """Credits management page"""
+    if not session_user:
+        return RedirectResponse(url="/login")
+    
+    # Get credit history (mock data - replace with database in production)
+    credit_history = [
+        {
+            "date": "2024-03-20 14:30",
+            "type": "Daily Reward",
+            "amount": 5,
+            "details": "Watched daily ad"
+        },
+        {
+            "date": "2024-03-19 15:45",
+            "type": "Tool Usage",
+            "amount": -5,
+            "details": "Used Image Generation"
+        }
+    ]
+    
+    return templates.TemplateResponse(
+        "credits.html",
+        {
+            "request": request,
+            "app_name": "AI Tool Hub",
+            "user": session_user,
+            "user_credits": session_user.credits,
+            "credit_packages": CREDIT_PACKAGES,
+            "credit_history": credit_history,
+            "referral_link": f"{request.base_url}?ref={session_user.id}"
+        }
+    )
+
+@app.get("/api/ads/status")
+async def get_ads_status(request: Request, session_user: Optional[UserInfo] = Depends(get_session_user)):
+    """Get user's ad reward status"""
+    if not session_user:
+        return JSONResponse(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            content={"success": False, "error": "Authentication required"}
+        )
+    
+    # Get daily reward status
+    daily_reward = DAILY_REWARDS.get(f"{session_user.id}_{datetime.now().date().isoformat()}")
+    can_claim_daily = True
+    cooldown_remaining = 0
+    
+    if daily_reward and daily_reward.last_reward:
+        last_reward_time = datetime.fromisoformat(daily_reward.last_reward)
+        if (datetime.now() - last_reward_time).total_seconds() < 3600:  # 1 hour cooldown
+            can_claim_daily = False
+            cooldown_remaining = 3600 - (datetime.now() - last_reward_time).total_seconds()
+    
+    # Get special reward status
+    special_reward = SPECIAL_REWARDS.get(f"{session_user.id}_{datetime.now().date().isoformat()}")
+    can_claim_special = True
+    
+    if special_reward and special_reward.claimed:
+        can_claim_special = False
+    
+    return JSONResponse(
+        content={
+            "success": True,
+            "daily_rewards": {
+                "count": daily_reward.count if daily_reward else 0,
+                "can_claim": can_claim_daily and (not daily_reward or daily_reward.count < 3),
+                "cooldown_remaining": int(cooldown_remaining)
+            },
+            "special_reward": {
+                "claimed": special_reward.claimed if special_reward else False,
+                "can_claim": can_claim_special
+            }
+        }
+    )
+
+@app.post("/api/ads/claim")
+async def claim_ad_reward(
+    request: Request,
+    session_user: Optional[UserInfo] = Depends(get_session_user)
+):
+    """Process ad reward claim"""
+    if not session_user:
+        return JSONResponse(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            content={"success": False, "error": "Authentication required"}
+        )
+    
+    data = await request.json()
+    reward_type = data.get("type")
+    
+    if reward_type not in ["daily", "special"]:
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content={"success": False, "error": "Invalid reward type"}
+        )
+    
+    today = datetime.now().date().isoformat()
+    
+    if reward_type == "daily":
+        # Get or create daily reward record
+        daily_key = f"{session_user.id}_{today}"
+        if daily_key not in DAILY_REWARDS:
+            DAILY_REWARDS[daily_key] = DailyReward(
+                user_id=session_user.id,
+                date=today,
+                count=0
+            )
+        
+        daily_reward = DAILY_REWARDS[daily_key]
+        
+        # Check if user has already claimed maximum daily rewards
+        if daily_reward.count >= 3:
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content={"success": False, "error": "Daily reward limit reached"}
+            )
+        
+        # Check cooldown period
+        if daily_reward.last_reward:
+            last_reward_time = datetime.fromisoformat(daily_reward.last_reward)
+            if (datetime.now() - last_reward_time).total_seconds() < 3600:
+                return JSONResponse(
+                    status_code=status.HTTP_400_BAD_REQUEST,
+                    content={"success": False, "error": "Please wait 1 hour between rewards"}
+                )
+        
+        # Award credits
+        reward_amount = 10
+        session_user.credits += reward_amount
+        daily_reward.count += 1
+        daily_reward.last_reward = datetime.now().isoformat()
+        
+        return JSONResponse(
+            content={
+                "success": True,
+                "credits_earned": reward_amount,
+                "current_credits": session_user.credits,
+                "daily_progress": daily_reward.count
+            }
+        )
+    
+    else:  # special reward
+        # Get or create special reward record
+        special_key = f"{session_user.id}_{today}"
+        if special_key not in SPECIAL_REWARDS:
+            SPECIAL_REWARDS[special_key] = SpecialReward(
+                user_id=session_user.id,
+                date=today,
+                claimed=False
+            )
+        
+        special_reward = SPECIAL_REWARDS[special_key]
+        
+        # Check if user has already claimed special reward
+        if special_reward.claimed:
+            return JSONResponse(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                content={"success": False, "error": "Special reward already claimed"}
+            )
+        
+        # Award credits
+        reward_amount = 25
+        session_user.credits += reward_amount
+        special_reward.claimed = True
+        special_reward.claimed_at = datetime.now().isoformat()
+        
+        return JSONResponse(
+            content={
+                "success": True,
+                "credits_earned": reward_amount,
+                "current_credits": session_user.credits
+            }
+        )
+
+@app.get("/create-admin")
+async def create_admin(
+    request: Request,
+    response: Response,
+):
+    """Create an admin user (only for development)"""
+    # Check if admin already exists
+    admin_exists = False
+    admin_user = None
+    
+    for session in SESSIONS.values():
+        if session.get("user") and session["user"].username == "admin":
+            admin_exists = True
+            admin_user = session["user"]
+            break
+    
+    if admin_exists:
+        # Update admin credits
+        admin_user.credits = 10000
+        admin_user.role = "admin"
+        return JSONResponse(
+            content={
+                "success": True,
+                "message": "Admin user updated with 10000 credits",
+                "user_id": admin_user.id
+            }
+        )
+    
+    # Create admin user
+    user_id = "admin"
+    user = UserInfo(
+        id=user_id,
+        username="admin",
+        email="[email protected]",
+        credits=10000,
+        role="admin",
+        last_login=datetime.now().isoformat()
+    )
+    
+    # In production, you would hash the password
+    # For simplicity, we'll store it in a way that the login function can use it
+    # This is for development only, never do this in production!
+    admin_info = {
+        "user": user,
+        "password": "admin123",  # Plaintext for demo only
+        "created_at": datetime.now().isoformat()
+    }
+    
+    # Store admin info for login
+    API_KEYS["admin_key"] = admin_info
+    
+    return JSONResponse(
+        content={
+            "success": True,
+            "message": "Admin user created with 10000 credits",
+            "user_id": user_id,
+            "username": "admin",
+            "password": "admin123"
+        }
+    )
+
+@app.get("/admin", response_class=HTMLResponse)
+async def admin_dashboard(
+    request: Request,
+    user: UserInfo = Depends(lambda: require_session_user(admin_required=True))
+):
+    """Admin dashboard"""
+    # Get all users
+    users = []
+    for session_id, session in SESSIONS.items():
+        if "user" in session:
+            users.append({
+                "id": session["user"].id,
+                "username": session["user"].username,
+                "email": session["user"].email,
+                "credits": session["user"].credits,
+                "role": getattr(session["user"], "role", "user"),
+                "session_id": session_id,
+                "expires": session["expires"].isoformat() if "expires" in session else None
+            })
+    
+    # Sort users by credits (descending)
+    users.sort(key=lambda x: x["credits"], reverse=True)
+    
+    return templates.TemplateResponse(
+        "admin_dashboard.html",
+        {
+            "request": request,
+            "app_name": "AI Tool Hub",
+            "user": user,
+            "user_credits": user.credits,
+            "users": users,
+            "total_users": len(users),
+            "total_credits": sum(u["credits"] for u in users),
+            "admin_count": sum(1 for u in users if u["role"] == "admin")
+        }
+    )
+
+@app.post("/api/admin/update-credits")
+async def admin_update_credits(
+    request: Request,
+    user: UserInfo = Depends(lambda: require_session_user(admin_required=True))
+):
+    """Admin endpoint to update user credits"""
+    data = await request.json()
+    user_id = data.get("user_id")
+    new_credits = data.get("credits")
+    
+    if not user_id or new_credits is None:
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content={"success": False, "error": "User ID and credits are required"}
+        )
+    
+    # Find the user
+    target_user = None
+    for session in SESSIONS.values():
+        if "user" in session and session["user"].id == user_id:
+                target_user = session["user"]
+                break
+    
+    if not target_user:
+        return JSONResponse(
+            status_code=status.HTTP_404_NOT_FOUND,
+            content={"success": False, "error": "User not found"}
+        )
+    
+    # Update credits
+    try:
+        target_user.credits = float(new_credits)
+    except ValueError:
+        return JSONResponse(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            content={"success": False, "error": "Invalid credit amount"}
+        )
+    
+    return JSONResponse(
+        content={
+            "success": True,
+            "user_id": user_id,
+            "new_credits": target_user.credits,
+            "message": f"Credits updated for user {target_user.username}"
+        }
+    )
+
+@app.post("/process-request", response_class=HTMLResponse)
+async def process_request(
+    request: Request,
+    tool_id: str = Form(...),
+    prompt: str = Form(...),
+    provider: str = Form("openai"),
+    model: str = Form("default"),
+    session_user: Optional[UserInfo] = Depends(get_session_user)
+):
+    """Process a tool request from a form"""
+    # Get the tool
+    tool = next((t for t in TOOLS if t.id == tool_id), None)
+    
+    if not tool:
+        return templates.TemplateResponse(
+            "error.html",
+            {
+                "request": request,
+                "app_name": "AI Tool Hub",
+                "error_title": "Tool Not Found",
+                "error_description": "The requested tool does not exist.",
+                "user": session_user,
+                "user_credits": session_user.credits if session_user else 0,
+                "tools": TOOLS  # Include for consistent sidebar navigation
+            }
+        )
+    
+    # Confirm that user is logged in
+    if not session_user:
+        return templates.TemplateResponse(
+            "error.html",
+            {
+                "request": request,
+                "app_name": "AI Tool Hub",
+                "error_title": "Login Required",
+                "error_description": "You must be logged in to use AI tools.",
+                "user": None,
+                "user_credits": 0,
+                "tools": TOOLS  # Include for consistent sidebar navigation
+            }
+        )
+    
+    # Check if the user has enough credits
+    if session_user.credits < tool.cost:
+        return templates.TemplateResponse(
+            "ad_reward.html",
+            {
+                "request": request,
+                "app_name": "AI Tool Hub",
+                "user": session_user,
+                "user_credits": session_user.credits,
+                "tool": tool,
+                "reward_ad": ads_manager.get_ad_code("reward_video"),
+                "sidebar_ad": ads_manager.get_ad_code("sidebar"),
+                "return_url": f"/tool/{tool_id}",
+                "tools": TOOLS  # Include for consistent sidebar navigation
+            }
+        )
+    
+    # Get the provider
+    try:
+        provider_instance = get_provider(provider)
+        if not provider_instance:
+            return templates.TemplateResponse(
+                "error.html",
+                {
+                    "request": request,
+                    "app_name": "AI Tool Hub",
+                    "error_title": "Provider Not Supported",
+                    "error_description": f"The provider '{provider}' is not supported.",
+                    "user": session_user,
+                    "user_credits": session_user.credits if session_user else 0,
+                    "tools": TOOLS  # Include for consistent sidebar navigation
+                }
+            )
+        
+        result = None
+        result_type = "text"  # Default type
+        
+        # Determine result type based on tool ID
+        if "image" in tool.id or "logo" in tool.id or "avatar" in tool.id:
+            result_type = "image"
+        elif "code" in tool.id or "debugging" in tool.id:
+            result_type = "code"
+        
+        # Process the request based on tool type
+        try:
+            if result_type == "text":
+                # Text generation tool
+                result = provider_instance.generate_text(
+                    prompt=prompt,
+                    model=model if model != "default" else "mistralai/Mistral-7B-Instruct-v0.2",
+                    max_tokens=1000,
+                    temperature=0.7
+                )
+            elif result_type == "image":
+                # Image generation tool
+                try:
+                    result = provider_instance.generate_image(
+                        prompt=prompt,
+                        model=model if model != "default" else "stabilityai/stable-diffusion-xl-base-1.0"
+                    )
+                except AttributeError:
+                    # Provider doesn't support image generation
+                    return templates.TemplateResponse(
+                        "error.html",
+                        {
+                            "request": request,
+                            "app_name": "AI Tool Hub",
+                            "error_title": "Provider Not Supported",
+                            "error_description": f"The provider '{provider}' does not support image generation.",
+                            "user": session_user,
+                            "user_credits": session_user.credits if session_user else 0,
+                            "tools": TOOLS  # Include for consistent sidebar navigation
+                        }
+                    )
+            elif result_type == "code":
+                # Code generation tool
+                result = provider_instance.generate_text(
+                    prompt=prompt,
+                    model=model if model != "default" else "gpt2",
+                    max_tokens=1500,
+                    temperature=0.5
+                )
+            else:
+                return templates.TemplateResponse(
+                    "error.html",
+                    {
+                        "request": request,
+                        "app_name": "AI Tool Hub",
+                        "error_title": "Tool Type Not Supported",
+                        "error_description": f"The tool type '{result_type}' is not supported.",
+                        "user": session_user,
+                        "user_credits": session_user.credits if session_user else 0,
+                        "tools": TOOLS  # Include for consistent sidebar navigation
+                    }
+                )
+            
+            # Deduct credits
+            session_user.credits -= tool.cost
+            
+            # Return the result
+            return templates.TemplateResponse(
+                "result.html",
+                {
+                    "request": request,
+                    "app_name": "AI Tool Hub",
+                    "user": session_user,
+                    "user_credits": session_user.credits,
+                    "tool": tool,
+                    "prompt": prompt,
+                    "result": result,
+                    "result_type": result_type,
+                    "tools": TOOLS,  # Include all tools for sidebar navigation
+                    "json_data": result.get("raw_response", {}) if isinstance(result, dict) else {}
+                }
+            )
+        except Exception as generate_error:
+            return templates.TemplateResponse(
+                "error.html",
+                {
+                    "request": request,
+                    "app_name": "AI Tool Hub",
+                    "error_title": "Generation Error",
+                    "error_description": f"Error generating content: {str(generate_error)}",
+                    "user": session_user,
+                    "user_credits": session_user.credits,
+                    "tools": TOOLS  # Include all tools for sidebar navigation
+                }
+            )
+    except Exception as provider_error:
+        return templates.TemplateResponse(
+            "error.html",
+            {
+                "request": request,
+                "app_name": "AI Tool Hub",
+                "error_title": "Provider Error",
+                "error_description": f"Error with provider: {str(provider_error)}",
+                "user": session_user,
+                "user_credits": session_user.credits,
+                "tools": TOOLS  # Include all tools for sidebar navigation
+            }
+        )
+
+@app.post("/register")
+async def register(
+    request: Request,
+    response: Response,
+    username: str = Form(...),
+    email: str = Form(...),
+    password: str = Form(...),
+    session_id: Optional[str] = Cookie(None)
+):
+    """Process registration"""
+    # Check if username or email already exists (in production use a database)
+    for session in SESSIONS.values():
+        if session.get("user"):
+            if session["user"].username.lower() == username.lower():
+                return templates.TemplateResponse(
+                    "register.html",
+                    {
+                        "request": request,
+                        "app_name": "AI Tool Hub",
+                        "error": "Username already exists",
+                        "form_data": {"username": username, "email": email}
+                    },
+                    status_code=400
+                )
+            if session["user"].email.lower() == email.lower():
+                return templates.TemplateResponse(
+                    "register.html",
+                    {
+                        "request": request,
+                        "app_name": "AI Tool Hub",
+                        "error": "Email already exists",
+                        "form_data": {"username": username, "email": email}
+                    },
+                    status_code=400
+                )
+    
+    # Create user
+    user_id = f"user_{username.lower().replace(' ', '_')}"
+    
+    # Check if there's an existing temporary session to convert
+    is_converting_temp = False
+    temp_credits = 0
+    
+    if session_id and session_id in SESSIONS:
+        session = SESSIONS[session_id]
+        if session.get("is_temporary", False):
+            # Convert temporary session to permanent
+            is_converting_temp = True
+            temp_credits = session["user"].credits
+            # Delete the temporary session
+            del SESSIONS[session_id]
+    
+    # Create new user with starting credits (more if converting from temp)
+    start_credits = 10.0 + temp_credits
+    user = UserInfo(
+        id=user_id,
+        username=username,
+        email=email,
+        credits=start_credits,
+        last_login=datetime.now().isoformat()
+    )
+    
+    # In production, you would hash the password and store in database
+    
+    # Create new session
+    new_session_id = secrets.token_urlsafe(32)
+    SESSIONS[new_session_id] = {
+        "user": user,
+        "expires": datetime.now() + timedelta(hours=24)
+    }
+    
+    # Set session cookie
+    response = RedirectResponse(url="/", status_code=status.HTTP_303_SEE_OTHER)
+    response.set_cookie(
+        key="session_id",
+        value=new_session_id,
+        max_age=86400,  # 24 hours
+        httponly=True,
+        samesite="lax"
+    )
+    
+    return response
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8006)

models.py

@@ -0,0 +1,21 @@
+from sqlalchemy import Column, String, Integer, Float
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = 'users'
+
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    email = Column(String, unique=True, index=True)
+    credits = Column(Float, default=10.0)
+
+class Prompt(Base):
+    __tablename__ = 'prompts'
+
+    id = Column(String, primary_key=True, index=True)
+    title = Column(String, index=True)
+    content = Column(String)
+    description = Column(String, nullable=True)
+    creator_id = Column(String, index=True)

prompts/__init__.py

@@ -0,0 +1,13 @@
+"""
+Prompts Package
+Exports prompt template and marketplace classes
+"""
+
+from prompts.prompt_templates import PromptTemplate, PromptTemplateManager
+from prompts.prompt_marketplace import PromptMarketplace
+
+__all__ = [
+    'PromptTemplate',
+    'PromptTemplateManager',
+    'PromptMarketplace'
+] 

prompts/marketplace_data/purchases.json

@@ -0,0 +1 @@
+[]

prompts/marketplace_data/sales.json

@@ -0,0 +1 @@
+[]

prompts/marketplace_data/stats.json

@@ -0,0 +1,6 @@
+{
+  "total_sales": 0,
+  "total_revenue": 0,
+  "prompt_usage": {},
+  "popular_categories": {}
+}

prompts/prompt_marketplace.py

@@ -0,0 +1,728 @@
+"""
+Prompt Marketplace Module
+Enables users to create, sell, purchase, and use AI prompts
+"""
+import os
+import json
+import uuid
+import logging
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+from prompts.prompt_templates import PromptTemplate, PromptTemplateManager
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("prompt_marketplace")
+
+class PromptMarketplace:
+    """Manages the prompt marketplace functionality"""
+    
+    def __init__(self, data_dir: str = None):
+        """Initialize the prompt marketplace"""
+        self.data_dir = data_dir or os.path.join(os.path.dirname(__file__), "marketplace_data")
+        
+        # Create data directory if it doesn't exist
+        os.makedirs(self.data_dir, exist_ok=True)
+        
+        # Paths for data files
+        self.purchases_file = os.path.join(self.data_dir, "purchases.json")
+        self.sales_file = os.path.join(self.data_dir, "sales.json")
+        self.stats_file = os.path.join(self.data_dir, "stats.json")
+        
+        # Initialize data files if they don't exist
+        self._initialize_data_files()
+        
+        # Create prompt template manager
+        self.template_manager = PromptTemplateManager()
+    
+    def _initialize_data_files(self):
+        """Initialize data files if they don't exist"""
+        if not os.path.exists(self.purchases_file):
+            with open(self.purchases_file, "w") as f:
+                json.dump([], f)
+        
+        if not os.path.exists(self.sales_file):
+            with open(self.sales_file, "w") as f:
+                json.dump([], f)
+        
+        if not os.path.exists(self.stats_file):
+            with open(self.stats_file, "w") as f:
+                json.dump({
+                    "total_sales": 0,
+                    "total_revenue": 0,
+                    "prompt_usage": {},
+                    "popular_categories": {}
+                }, f, indent=2)
+    
+    def list_marketplace_prompts(self, category: str = None, sort_by: str = "popular") -> List[Dict[str, Any]]:
+        """
+        List prompts available in the marketplace
+        
+        Args:
+            category: Optional category to filter by
+            sort_by: Sorting method ('popular', 'newest', 'price_low', 'price_high')
+            
+        Returns:
+            List of prompt templates available for purchase
+        """
+        # Get all public templates
+        all_templates = self.template_manager.get_public_templates()
+        
+        # Filter by category if specified
+        if category:
+            all_templates = [t for t in all_templates if t.category.lower() == category.lower()]
+        
+        # Convert to dictionaries for easier manipulation
+        templates_dict = [t.to_dict() for t in all_templates]
+        
+        # Add usage statistics
+        templates_with_stats = self._add_stats_to_templates(templates_dict)
+        
+        # Sort the templates
+        if sort_by == "popular":
+            templates_with_stats.sort(key=lambda x: x.get("stats", {}).get("usage_count", 0), reverse=True)
+        elif sort_by == "newest":
+            templates_with_stats.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+        elif sort_by == "price_low":
+            templates_with_stats.sort(key=lambda x: x.get("price", 0))
+        elif sort_by == "price_high":
+            templates_with_stats.sort(key=lambda x: x.get("price", 0), reverse=True)
+        
+        return templates_with_stats
+    
+    def _add_stats_to_templates(self, templates: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Add usage statistics to template dictionaries"""
+        try:
+            with open(self.stats_file, "r") as f:
+                stats = json.load(f)
+            
+            prompt_usage = stats.get("prompt_usage", {})
+            
+            # Add stats to each template
+            for template in templates:
+                template_id = template.get("id")
+                template["stats"] = {
+                    "usage_count": prompt_usage.get(template_id, {}).get("count", 0),
+                    "purchase_count": prompt_usage.get(template_id, {}).get("purchases", 0),
+                    "rating": prompt_usage.get(template_id, {}).get("avg_rating", 0),
+                    "reviews": prompt_usage.get(template_id, {}).get("review_count", 0)
+                }
+            
+            return templates
+        except Exception as e:
+            logger.error(f"Error adding stats to templates: {e}")
+            return templates
+    
+    def get_prompt_details(self, prompt_id: str) -> Dict[str, Any]:
+        """
+        Get detailed information about a marketplace prompt
+        
+        Args:
+            prompt_id: ID of the prompt template
+            
+        Returns:
+            Detailed prompt information including stats and sample outputs
+        """
+        prompt = self.template_manager.get_template(prompt_id)
+        
+        if not prompt:
+            return {"success": False, "error": "Prompt not found"}
+        
+        if not prompt.is_public and prompt.created_by != "system":
+            return {"success": False, "error": "Prompt is not available in the marketplace"}
+        
+        # Get prompt details
+        prompt_dict = prompt.to_dict()
+        
+        # Add stats
+        prompt_dict = self._add_stats_to_templates([prompt_dict])[0]
+        
+        # Get purchase information
+        prompt_dict["purchases"] = self._get_prompt_purchases(prompt_id)
+        
+        return {
+            "success": True,
+            "prompt": prompt_dict
+        }
+    
+    def _get_prompt_purchases(self, prompt_id: str) -> Dict[str, Any]:
+        """Get purchase information for a prompt"""
+        try:
+            with open(self.sales_file, "r") as f:
+                sales = json.load(f)
+            
+            # Filter sales for this prompt
+            prompt_sales = [s for s in sales if s.get("prompt_id") == prompt_id]
+            
+            return {
+                "total": len(prompt_sales),
+                "recent": len([s for s in prompt_sales if 
+                              (datetime.now() - datetime.fromisoformat(s.get("timestamp", ""))).days < 7])
+            }
+        except Exception as e:
+            logger.error(f"Error getting prompt purchases: {e}")
+            return {"total": 0, "recent": 0}
+    
+    def create_prompt_for_sale(self, 
+                              name: str,
+                              description: str,
+                              template: str,
+                              system_message: str,
+                              category: str,
+                              price: float,
+                              parameters: Dict[str, Any],
+                              created_by: str,
+                              provider_defaults: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        Create a new prompt template for sale in the marketplace
+        
+        Args:
+            name: Name of the prompt template
+            description: Description of what the prompt does
+            template: The prompt template text
+            system_message: System message for the prompt
+            category: Category for the prompt
+            price: Price in credits
+            parameters: Dictionary of parameters for the prompt
+            created_by: User ID of the creator
+            provider_defaults: Default settings for different providers
+            
+        Returns:
+            Result dictionary with success status and prompt information
+        """
+        # Validate inputs
+        if not name or not template:
+            return {"success": False, "error": "Name and template are required"}
+        
+        if price < 0:
+            return {"success": False, "error": "Price cannot be negative"}
+        
+        # Create the prompt template
+        new_prompt = PromptTemplate(
+            name=name,
+            description=description,
+            template=template,
+            system_message=system_message,
+            category=category,
+            is_public=True,  # It's for sale, so make it public
+            created_by=created_by,
+            price=price,
+            parameters=parameters,
+            provider_defaults=provider_defaults or {}
+        )
+        
+        # Save the prompt
+        created_prompt = self.template_manager.create_template(new_prompt)
+        
+        # Initialize stats for this prompt
+        self._initialize_prompt_stats(created_prompt.id)
+        
+        return {
+            "success": True,
+            "prompt": created_prompt.to_dict(),
+            "message": "Prompt successfully created and listed in the marketplace"
+        }
+    
+    def _initialize_prompt_stats(self, prompt_id: str):
+        """Initialize statistics for a new prompt"""
+        try:
+            with open(self.stats_file, "r") as f:
+                stats = json.load(f)
+            
+            prompt_usage = stats.get("prompt_usage", {})
+            prompt_usage[prompt_id] = {
+                "count": 0,
+                "purchases": 0,
+                "avg_rating": 0,
+                "review_count": 0,
+                "last_used": None
+            }
+            
+            stats["prompt_usage"] = prompt_usage
+            
+            with open(self.stats_file, "w") as f:
+                json.dump(stats, f, indent=2)
+                
+        except Exception as e:
+            logger.error(f"Error initializing prompt stats: {e}")
+    
+    def purchase_prompt(self, prompt_id: str, user_id: str, credits_available: float) -> Dict[str, Any]:
+        """
+        Purchase a prompt from the marketplace
+        
+        Args:
+            prompt_id: ID of the prompt to purchase
+            user_id: ID of the user making the purchase
+            credits_available: Credits available to the user
+            
+        Returns:
+            Result dictionary with success status and transaction details
+        """
+        # Get the prompt
+        prompt = self.template_manager.get_template(prompt_id)
+        
+        if not prompt:
+            return {"success": False, "error": "Prompt not found"}
+        
+        if not prompt.is_public:
+            return {"success": False, "error": "Prompt is not available for purchase"}
+        
+        # Check if user already owns this prompt
+        if self._user_owns_prompt(user_id, prompt_id):
+            return {"success": False, "error": "You already own this prompt"}
+        
+        # Check if user has enough credits
+        if credits_available < prompt.price:
+            return {"success": False, "error": "Insufficient credits", "credits_needed": prompt.price}
+        
+        # Process the purchase
+        purchase_id = str(uuid.uuid4())
+        purchase_time = datetime.now().isoformat()
+        
+        purchase_record = {
+            "id": purchase_id,
+            "prompt_id": prompt_id,
+            "user_id": user_id,
+            "seller_id": prompt.created_by,
+            "price": prompt.price,
+            "timestamp": purchase_time
+        }
+        
+        # Record the purchase
+        self._record_purchase(purchase_record)
+        
+        # Record the sale
+        self._record_sale(purchase_record)
+        
+        # Update statistics
+        self._update_stats_after_purchase(prompt_id)
+        
+        return {
+            "success": True,
+            "transaction": {
+                "id": purchase_id,
+                "prompt_id": prompt_id,
+                "prompt_name": prompt.name,
+                "price": prompt.price,
+                "timestamp": purchase_time
+            },
+            "credits_used": prompt.price,
+            "message": f"Successfully purchased prompt: {prompt.name}"
+        }
+    
+    def _user_owns_prompt(self, user_id: str, prompt_id: str) -> bool:
+        """Check if a user already owns a prompt"""
+        try:
+            with open(self.purchases_file, "r") as f:
+                purchases = json.load(f)
+            
+            # Check if the user has already purchased this prompt
+            for purchase in purchases:
+                if purchase.get("user_id") == user_id and purchase.get("prompt_id") == prompt_id:
+                    return True
+            
+            return False
+            
+        except Exception as e:
+            logger.error(f"Error checking if user owns prompt: {e}")
+            return False
+    
+    def _record_purchase(self, purchase_record: Dict[str, Any]):
+        """Record a prompt purchase"""
+        try:
+            with open(self.purchases_file, "r") as f:
+                purchases = json.load(f)
+            
+            purchases.append(purchase_record)
+            
+            with open(self.purchases_file, "w") as f:
+                json.dump(purchases, f, indent=2)
+                
+        except Exception as e:
+            logger.error(f"Error recording purchase: {e}")
+    
+    def _record_sale(self, purchase_record: Dict[str, Any]):
+        """Record a prompt sale"""
+        try:
+            with open(self.sales_file, "r") as f:
+                sales = json.load(f)
+            
+            sales.append(purchase_record)
+            
+            with open(self.sales_file, "w") as f:
+                json.dump(sales, f, indent=2)
+                
+        except Exception as e:
+            logger.error(f"Error recording sale: {e}")
+    
+    def _update_stats_after_purchase(self, prompt_id: str):
+        """Update statistics after a prompt purchase"""
+        try:
+            with open(self.stats_file, "r") as f:
+                stats = json.load(f)
+            
+            # Update prompt-specific stats
+            prompt_usage = stats.get("prompt_usage", {})
+            if prompt_id not in prompt_usage:
+                prompt_usage[prompt_id] = {
+                    "count": 0,
+                    "purchases": 0,
+                    "avg_rating": 0,
+                    "review_count": 0
+                }
+            
+            prompt_usage[prompt_id]["purchases"] = prompt_usage[prompt_id].get("purchases", 0) + 1
+            
+            # Update global stats
+            stats["total_sales"] = stats.get("total_sales", 0) + 1
+            
+            # Get the prompt price
+            prompt = self.template_manager.get_template(prompt_id)
+            if prompt:
+                stats["total_revenue"] = stats.get("total_revenue", 0) + prompt.price
+                
+                # Update category popularity
+                category = prompt.category
+                popular_categories = stats.get("popular_categories", {})
+                popular_categories[category] = popular_categories.get(category, 0) + 1
+                stats["popular_categories"] = popular_categories
+            
+            # Save updated stats
+            with open(self.stats_file, "w") as f:
+                json.dump(stats, f, indent=2)
+                
+        except Exception as e:
+            logger.error(f"Error updating stats after purchase: {e}")
+    
+    def get_user_purchased_prompts(self, user_id: str) -> List[Dict[str, Any]]:
+        """
+        Get prompts purchased by a specific user
+        
+        Args:
+            user_id: ID of the user
+            
+        Returns:
+            List of prompts owned by the user
+        """
+        purchased_prompt_ids = self._get_user_purchased_prompt_ids(user_id)
+        
+        # Get the prompt details for each purchased prompt
+        purchased_prompts = []
+        for prompt_id in purchased_prompt_ids:
+            prompt = self.template_manager.get_template(prompt_id)
+            if prompt:
+                prompt_dict = prompt.to_dict()
+                purchased_prompts.append(prompt_dict)
+        
+        return purchased_prompts
+    
+    def _get_user_purchased_prompt_ids(self, user_id: str) -> List[str]:
+        """Get IDs of prompts purchased by a user"""
+        try:
+            with open(self.purchases_file, "r") as f:
+                purchases = json.load(f)
+            
+            # Get unique prompt IDs purchased by this user
+            prompt_ids = set()
+            for purchase in purchases:
+                if purchase.get("user_id") == user_id:
+                    prompt_ids.add(purchase.get("prompt_id"))
+            
+            return list(prompt_ids)
+            
+        except Exception as e:
+            logger.error(f"Error getting user purchased prompt IDs: {e}")
+            return []
+    
+    def get_user_sales(self, user_id: str) -> Dict[str, Any]:
+        """
+        Get sales information for a specific seller
+        
+        Args:
+            user_id: ID of the seller
+            
+        Returns:
+            Dictionary with sales information
+        """
+        try:
+            with open(self.sales_file, "r") as f:
+                sales = json.load(f)
+            
+            # Filter sales by this seller
+            user_sales = [s for s in sales if s.get("seller_id") == user_id]
+            
+            # Calculate total revenue
+            total_revenue = sum(s.get("price", 0) for s in user_sales)
+            
+            # Group sales by prompt
+            sales_by_prompt = {}
+            for sale in user_sales:
+                prompt_id = sale.get("prompt_id")
+                if prompt_id not in sales_by_prompt:
+                    sales_by_prompt[prompt_id] = []
+                sales_by_prompt[prompt_id].append(sale)
+            
+            # Get prompt details and calculate stats for each prompt
+            prompt_sales = []
+            for prompt_id, sales_list in sales_by_prompt.items():
+                prompt = self.template_manager.get_template(prompt_id)
+                if not prompt:
+                    continue
+                
+                prompt_revenue = sum(s.get("price", 0) for s in sales_list)
+                
+                prompt_sales.append({
+                    "prompt_id": prompt_id,
+                    "prompt_name": prompt.name,
+                    "price": prompt.price,
+                    "sales_count": len(sales_list),
+                    "revenue": prompt_revenue,
+                    "last_sale": max(s.get("timestamp", "") for s in sales_list)
+                })
+            
+            # Sort by revenue
+            prompt_sales.sort(key=lambda x: x.get("revenue", 0), reverse=True)
+            
+            return {
+                "success": True,
+                "total_sales": len(user_sales),
+                "total_revenue": total_revenue,
+                "prompt_count": len(prompt_sales),
+                "prompts": prompt_sales
+            }
+            
+        except Exception as e:
+            logger.error(f"Error getting user sales: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    def record_prompt_usage(self, prompt_id: str, user_id: str, provider: str = None) -> bool:
+        """
+        Record usage of a prompt
+        
+        Args:
+            prompt_id: ID of the prompt used
+            user_id: ID of the user using the prompt
+            provider: Optional provider used
+            
+        Returns:
+            Success status
+        """
+        try:
+            with open(self.stats_file, "r") as f:
+                stats = json.load(f)
+            
+            # Update prompt usage stats
+            prompt_usage = stats.get("prompt_usage", {})
+            if prompt_id not in prompt_usage:
+                prompt_usage[prompt_id] = {
+                    "count": 0,
+                    "purchases": 0,
+                    "avg_rating": 0,
+                    "review_count": 0
+                }
+            
+            prompt_usage[prompt_id]["count"] = prompt_usage[prompt_id].get("count", 0) + 1
+            prompt_usage[prompt_id]["last_used"] = datetime.now().isoformat()
+            
+            # Track provider usage if provided
+            if provider:
+                providers = prompt_usage[prompt_id].get("providers", {})
+                providers[provider] = providers.get(provider, 0) + 1
+                prompt_usage[prompt_id]["providers"] = providers
+            
+            # Save updated stats
+            with open(self.stats_file, "w") as f:
+                json.dump(stats, f, indent=2)
+            
+            return True
+                
+        except Exception as e:
+            logger.error(f"Error recording prompt usage: {e}")
+            return False
+    
+    def rate_prompt(self, prompt_id: str, user_id: str, rating: int, review: str = None) -> Dict[str, Any]:
+        """
+        Rate and review a prompt
+        
+        Args:
+            prompt_id: ID of the prompt to rate
+            user_id: ID of the user providing the rating
+            rating: Rating value (1-5)
+            review: Optional review text
+            
+        Returns:
+            Result dictionary with success status
+        """
+        # Validate rating
+        if rating < 1 or rating > 5:
+            return {"success": False, "error": "Rating must be between 1 and 5"}
+        
+        # Check if the user owns the prompt
+        if not self._user_owns_prompt(user_id, prompt_id):
+            return {"success": False, "error": "You must purchase a prompt before rating it"}
+        
+        try:
+            # Update the stats with the new rating
+            with open(self.stats_file, "r") as f:
+                stats = json.load(f)
+            
+            prompt_usage = stats.get("prompt_usage", {})
+            if prompt_id not in prompt_usage:
+                return {"success": False, "error": "Prompt not found"}
+            
+            # Calculate new average rating
+            current_avg = prompt_usage[prompt_id].get("avg_rating", 0)
+            current_count = prompt_usage[prompt_id].get("review_count", 0)
+            
+            if current_count == 0:
+                new_avg = rating
+            else:
+                new_avg = (current_avg * current_count + rating) / (current_count + 1)
+            
+            prompt_usage[prompt_id]["avg_rating"] = new_avg
+            prompt_usage[prompt_id]["review_count"] = current_count + 1
+            
+            # Save the review if provided
+            if review:
+                reviews = prompt_usage[prompt_id].get("reviews", [])
+                reviews.append({
+                    "user_id": user_id,
+                    "rating": rating,
+                    "review": review,
+                    "timestamp": datetime.now().isoformat()
+                })
+                prompt_usage[prompt_id]["reviews"] = reviews
+            
+            # Save updated stats
+            with open(self.stats_file, "w") as f:
+                json.dump(stats, f, indent=2)
+            
+            return {
+                "success": True,
+                "message": "Rating submitted successfully",
+                "new_rating": new_avg,
+                "review_count": current_count + 1
+            }
+                
+        except Exception as e:
+            logger.error(f"Error rating prompt: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    def get_marketplace_stats(self) -> Dict[str, Any]:
+        """Get overall marketplace statistics"""
+        try:
+            with open(self.stats_file, "r") as f:
+                stats = json.load(f)
+            
+            # Get the top prompts by usage
+            prompt_usage = stats.get("prompt_usage", {})
+            top_prompts = []
+            
+            for prompt_id, usage in prompt_usage.items():
+                prompt = self.template_manager.get_template(prompt_id)
+                if not prompt:
+                    continue
+                
+                top_prompts.append({
+                    "id": prompt_id,
+                    "name": prompt.name,
+                    "creator": prompt.created_by,
+                    "category": prompt.category,
+                    "price": prompt.price,
+                    "usage_count": usage.get("count", 0),
+                    "purchase_count": usage.get("purchases", 0),
+                    "rating": usage.get("avg_rating", 0),
+                    "review_count": usage.get("review_count", 0)
+                })
+            
+            # Sort by usage count
+            top_prompts.sort(key=lambda x: x.get("usage_count", 0), reverse=True)
+            top_prompts = top_prompts[:10]  # Get top 10
+            
+            # Get top categories
+            categories = stats.get("popular_categories", {})
+            top_categories = [{"category": k, "count": v} for k, v in categories.items()]
+            top_categories.sort(key=lambda x: x.get("count", 0), reverse=True)
+            
+            return {
+                "success": True,
+                "total_sales": stats.get("total_sales", 0),
+                "total_revenue": stats.get("total_revenue", 0),
+                "top_prompts": top_prompts,
+                "top_categories": top_categories
+            }
+                
+        except Exception as e:
+            logger.error(f"Error getting marketplace stats: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize the marketplace
+    marketplace = PromptMarketplace()
+    
+    # Create a sample prompt for sale
+    prompt_result = marketplace.create_prompt_for_sale(
+        name="Advanced SEO Article Writer",
+        description="Generate comprehensive SEO-optimized articles with proper keyword placement and structure",
+        template="Write a {length} word SEO-optimized article about {topic}. Target the keyword {keyword} with a keyword density of {density}%. Include {headings} headings, a compelling introduction, and a conclusion with call-to-action.",
+        system_message="You are an expert SEO content writer who creates engaging, well-researched content that ranks well in search engines.",
+        category="marketing",
+        price=25.0,
+        parameters={
+            "topic": {"type": "string", "description": "Main topic of the article", "required": True},
+            "keyword": {"type": "string", "description": "Target keyword to optimize for", "required": True},
+            "length": {"type": "number", "description": "Word count", "default": 1500},
+            "density": {"type": "number", "description": "Keyword density percentage", "default": 2},
+            "headings": {"type": "number", "description": "Number of headings to include", "default": 5}
+        },
+        created_by="seller123",
+        provider_defaults={
+            "openai": {"model": "gpt-4-turbo"}
+        }
+    )
+    
+    print(f"Created prompt: {prompt_result['success']}")
+    
+    if prompt_result['success']:
+        # Simulate a purchase
+        purchase_result = marketplace.purchase_prompt(
+            prompt_id=prompt_result['prompt']['id'],
+            user_id="buyer456",
+            credits_available=100.0
+        )
+        
+        print(f"Purchase result: {purchase_result['success']}")
+        
+        # Record usage of the prompt
+        marketplace.record_prompt_usage(
+            prompt_id=prompt_result['prompt']['id'],
+            user_id="buyer456",
+            provider="openai"
+        )
+        
+        # Rate the prompt
+        rating_result = marketplace.rate_prompt(
+            prompt_id=prompt_result['prompt']['id'],
+            user_id="buyer456",
+            rating=5,
+            review="This prompt generated an excellent SEO article that ranked quickly!"
+        )
+        
+        print(f"Rating result: {rating_result['success']}")
+        
+    # Get marketplace stats
+    stats = marketplace.get_marketplace_stats()
+    print(f"Marketplace stats: {stats['success']}")
+    if stats['success']:
+        print(f"Total sales: {stats['total_sales']}") 

prompts/prompt_templates.py

@@ -0,0 +1,350 @@
+"""
+Prompt Templates Module
+Manages prompt templates for different AI tools and providers
+Includes system for storing, loading, and managing user-created prompts
+"""
+import os
+import json
+import uuid
+import logging
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("prompts")
+
+class PromptTemplate:
+    """Represents a prompt template that can be used with AI providers"""
+    
+    def __init__(self, 
+                id: str = None,
+                name: str = "",
+                description: str = "",
+                template: str = "",
+                system_message: str = "",
+                category: str = "",
+                is_public: bool = False,
+                created_by: str = "system",
+                created_at: str = None,
+                price: float = 0.0,
+                parameters: Dict[str, Any] = None,
+                provider_defaults: Dict[str, Any] = None):
+        """Initialize a prompt template"""
+        self.id = id or str(uuid.uuid4())
+        self.name = name
+        self.description = description
+        self.template = template
+        self.system_message = system_message
+        self.category = category
+        self.is_public = is_public
+        self.created_by = created_by
+        self.created_at = created_at or datetime.now().isoformat()
+        self.price = price
+        self.parameters = parameters or {}
+        self.provider_defaults = provider_defaults or {}
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert template to dictionary"""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "template": self.template,
+            "system_message": self.system_message,
+            "category": self.category,
+            "is_public": self.is_public,
+            "created_by": self.created_by,
+            "created_at": self.created_at,
+            "price": self.price,
+            "parameters": self.parameters,
+            "provider_defaults": self.provider_defaults
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'PromptTemplate':
+        """Create template from dictionary"""
+        return cls(
+            id=data.get("id"),
+            name=data.get("name", ""),
+            description=data.get("description", ""),
+            template=data.get("template", ""),
+            system_message=data.get("system_message", ""),
+            category=data.get("category", ""),
+            is_public=data.get("is_public", False),
+            created_by=data.get("created_by", "system"),
+            created_at=data.get("created_at"),
+            price=data.get("price", 0.0),
+            parameters=data.get("parameters", {}),
+            provider_defaults=data.get("provider_defaults", {})
+        )
+    
+    def render(self, variables: Dict[str, Any] = None) -> Dict[str, str]:
+        """
+        Render the prompt template with the provided variables
+        Returns both the rendered prompt and system message
+        """
+        variables = variables or {}
+        prompt = self.template
+        system = self.system_message
+        
+        # Replace variables in the template
+        for key, value in variables.items():
+            placeholder = "{" + key + "}"
+            prompt = prompt.replace(placeholder, str(value))
+            system = system.replace(placeholder, str(value))
+        
+        return {
+            "prompt": prompt,
+            "system_message": system
+        }
+
+class PromptTemplateManager:
+    """Manages prompt templates, including default and user-created ones"""
+    
+    def __init__(self, templates_dir: str = None):
+        """Initialize the prompt template manager"""
+        self.templates_dir = templates_dir or os.path.join(os.path.dirname(__file__), "templates")
+        self.user_templates_dir = os.path.join(self.templates_dir, "user")
+        
+        # Create directories if they don't exist
+        os.makedirs(self.templates_dir, exist_ok=True)
+        os.makedirs(self.user_templates_dir, exist_ok=True)
+        
+        # Load default templates
+        self.default_templates = self._load_default_templates()
+        
+        # Load user templates
+        self.user_templates = self._load_user_templates()
+    
+    def _load_default_templates(self) -> Dict[str, PromptTemplate]:
+        """Load default templates from files"""
+        templates = {}
+        
+        # Define default templates if no files exist yet
+        default_templates = {
+            "general_chat": PromptTemplate(
+                id="general_chat",
+                name="General Chat",
+                description="A general-purpose chat prompt",
+                template="Please answer the following question or respond to the message: {input}",
+                system_message="You are a helpful assistant that provides accurate and concise responses.",
+                category="general",
+                created_by="system"
+            ),
+            "creative_writing": PromptTemplate(
+                id="creative_writing",
+                name="Creative Writing",
+                description="Generate creative writing based on a premise",
+                template="Write a {genre} {format} about {topic}.",
+                system_message="You are a creative writer with expertise in different genres and formats.",
+                category="creative",
+                created_by="system",
+                parameters={
+                    "genre": {"type": "string", "description": "Genre of the writing", "default": "science fiction"},
+                    "format": {"type": "string", "description": "Format of the writing", "default": "short story"},
+                    "topic": {"type": "string", "description": "Topic or premise", "required": True}
+                }
+            ),
+            "code_assistant": PromptTemplate(
+                id="code_assistant",
+                name="Code Assistant",
+                description="Generate or debug code in various languages",
+                template="I need help with the following code task in {language}:\n\n{task}\n\n{code}",
+                system_message="You are an expert programmer. Provide well-commented, efficient, and correct code solutions.",
+                category="development",
+                created_by="system",
+                parameters={
+                    "language": {"type": "string", "description": "Programming language", "required": True},
+                    "task": {"type": "string", "description": "Description of the coding task", "required": True},
+                    "code": {"type": "string", "description": "Existing code (if any)", "default": ""}
+                },
+                provider_defaults={
+                    "openai": {"model": "gpt-4-turbo"},
+                    "deepseek": {"model": "deepseek-coder"}
+                }
+            ),
+            "image_prompt": PromptTemplate(
+                id="image_prompt",
+                name="Image Generation",
+                description="Detailed prompt for image generation",
+                template="{subject} {style}, {details}, {quality}",
+                system_message="",
+                category="images",
+                created_by="system",
+                parameters={
+                    "subject": {"type": "string", "description": "Main subject of the image", "required": True},
+                    "style": {"type": "string", "description": "Art style", "default": "digital art"},
+                    "details": {"type": "string", "description": "Additional details", "default": "detailed, vibrant colors"},
+                    "quality": {"type": "string", "description": "Quality descriptors", "default": "high quality, 4k, trending on artstation"}
+                },
+                provider_defaults={
+                    "openai": {"model": "dall-e-3"}
+                }
+            )
+        }
+        
+        # Save default templates if they don't exist
+        for template_id, template in default_templates.items():
+            template_path = os.path.join(self.templates_dir, f"{template_id}.json")
+            
+            if not os.path.exists(template_path):
+                with open(template_path, "w") as f:
+                    json.dump(template.to_dict(), f, indent=2)
+            
+            templates[template_id] = template
+        
+        return templates
+    
+    def _load_user_templates(self) -> Dict[str, PromptTemplate]:
+        """Load user-created templates"""
+        templates = {}
+        
+        try:
+            # List all JSON files in user_templates_dir
+            for filename in os.listdir(self.user_templates_dir):
+                if filename.endswith(".json"):
+                    template_path = os.path.join(self.user_templates_dir, filename)
+                    
+                    with open(template_path, "r") as f:
+                        template_data = json.load(f)
+                        template = PromptTemplate.from_dict(template_data)
+                        templates[template.id] = template
+        except Exception as e:
+            logger.error(f"Error loading user templates: {e}")
+        
+        return templates
+    
+    def get_all_templates(self) -> List[PromptTemplate]:
+        """Get all available templates (default + user)"""
+        all_templates = list(self.default_templates.values())
+        
+        # Add public user templates and user's own templates
+        for template in self.user_templates.values():
+            if template.is_public:
+                all_templates.append(template)
+        
+        return all_templates
+    
+    def get_user_templates(self, user_id: str) -> List[PromptTemplate]:
+        """Get templates created by a specific user"""
+        return [t for t in self.user_templates.values() if t.created_by == user_id]
+    
+    def get_template(self, template_id: str) -> Optional[PromptTemplate]:
+        """Get a specific template by ID"""
+        if template_id in self.default_templates:
+            return self.default_templates[template_id]
+        
+        if template_id in self.user_templates:
+            return self.user_templates[template_id]
+        
+        return None
+    
+    def create_template(self, template: PromptTemplate) -> PromptTemplate:
+        """Create a new user template"""
+        # Ensure unique ID
+        if template.id in self.default_templates or template.id in self.user_templates:
+            template.id = str(uuid.uuid4())
+        
+        # Save template to file
+        template_path = os.path.join(self.user_templates_dir, f"{template.id}.json")
+        
+        with open(template_path, "w") as f:
+            json.dump(template.to_dict(), f, indent=2)
+        
+        # Add to user templates
+        self.user_templates[template.id] = template
+        
+        return template
+    
+    def update_template(self, template: PromptTemplate) -> Optional[PromptTemplate]:
+        """Update an existing user template"""
+        if template.id not in self.user_templates:
+            logger.error(f"Template {template.id} not found or not a user template")
+            return None
+        
+        # Save updated template
+        template_path = os.path.join(self.user_templates_dir, f"{template.id}.json")
+        
+        with open(template_path, "w") as f:
+            json.dump(template.to_dict(), f, indent=2)
+        
+        # Update in memory
+        self.user_templates[template.id] = template
+        
+        return template
+    
+    def delete_template(self, template_id: str, user_id: str) -> bool:
+        """Delete a user template"""
+        if template_id not in self.user_templates:
+            logger.error(f"Template {template_id} not found or not a user template")
+            return False
+        
+        # Check ownership
+        template = self.user_templates[template_id]
+        if template.created_by != user_id and user_id != "admin":
+            logger.error(f"User {user_id} does not own template {template_id}")
+            return False
+        
+        # Delete template file
+        template_path = os.path.join(self.user_templates_dir, f"{template_id}.json")
+        
+        try:
+            os.remove(template_path)
+            del self.user_templates[template_id]
+            return True
+        except Exception as e:
+            logger.error(f"Error deleting template {template_id}: {e}")
+            return False
+    
+    def get_templates_by_category(self, category: str) -> List[PromptTemplate]:
+        """Get templates by category"""
+        all_templates = self.get_all_templates()
+        return [t for t in all_templates if t.category.lower() == category.lower()]
+    
+    def get_public_templates(self) -> List[PromptTemplate]:
+        """Get all public templates created by users"""
+        return [t for t in self.user_templates.values() if t.is_public]
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize manager
+    manager = PromptTemplateManager()
+    
+    # Get all templates
+    all_templates = manager.get_all_templates()
+    print(f"Loaded {len(all_templates)} templates")
+    
+    # Create a new template
+    new_template = PromptTemplate(
+        name="SEO Content",
+        description="Generate SEO-optimized content for websites",
+        template="Write SEO-optimized content about {topic} targeting the keyword {keyword}. {tone} tone, {length} words.",
+        system_message="You are an expert SEO content writer who creates engaging, well-researched content that ranks well in search engines.",
+        category="marketing",
+        created_by="user123",
+        is_public=True,
+        parameters={
+            "topic": {"type": "string", "description": "Main topic", "required": True},
+            "keyword": {"type": "string", "description": "Target keyword", "required": True},
+            "tone": {"type": "string", "description": "Content tone", "default": "professional"},
+            "length": {"type": "number", "description": "Content length in words", "default": 500}
+        }
+    )
+    
+    created = manager.create_template(new_template)
+    print(f"Created new template: {created.id} - {created.name}")
+    
+    # Test rendering a template
+    code_template = manager.get_template("code_assistant")
+    if code_template:
+        rendered = code_template.render({
+            "language": "Python",
+            "task": "Create a function to calculate Fibonacci numbers",
+            "code": "def fibonacci(n):\n    # TODO: Implement"
+        })
+        
+        print("\nRendered prompt:")
+        print(rendered["prompt"])
+        print("\nSystem message:")
+ 

prompts/templates/code_assistant.json

@@ -0,0 +1,37 @@
+{
+  "id": "code_assistant",
+  "name": "Code Assistant",
+  "description": "Generate or debug code in various languages",
+  "template": "I need help with the following code task in {language}:\n\n{task}\n\n{code}",
+  "system_message": "You are an expert programmer. Provide well-commented, efficient, and correct code solutions.",
+  "category": "development",
+  "is_public": false,
+  "created_by": "system",
+  "created_at": "2025-03-18T14:56:55.479511",
+  "price": 0.0,
+  "parameters": {
+    "language": {
+      "type": "string",
+      "description": "Programming language",
+      "required": true
+    },
+    "task": {
+      "type": "string",
+      "description": "Description of the coding task",
+      "required": true
+    },
+    "code": {
+      "type": "string",
+      "description": "Existing code (if any)",
+      "default": ""
+    }
+  },
+  "provider_defaults": {
+    "openai": {
+      "model": "gpt-4-turbo"
+    },
+    "deepseek": {
+      "model": "deepseek-coder"
+    }
+  }
+}

prompts/templates/creative_writing.json

@@ -0,0 +1,30 @@
+{
+  "id": "creative_writing",
+  "name": "Creative Writing",
+  "description": "Generate creative writing based on a premise",
+  "template": "Write a {genre} {format} about {topic}.",
+  "system_message": "You are a creative writer with expertise in different genres and formats.",
+  "category": "creative",
+  "is_public": false,
+  "created_by": "system",
+  "created_at": "2025-03-18T14:56:55.479511",
+  "price": 0.0,
+  "parameters": {
+    "genre": {
+      "type": "string",
+      "description": "Genre of the writing",
+      "default": "science fiction"
+    },
+    "format": {
+      "type": "string",
+      "description": "Format of the writing",
+      "default": "short story"
+    },
+    "topic": {
+      "type": "string",
+      "description": "Topic or premise",
+      "required": true
+    }
+  },
+  "provider_defaults": {}
+}

prompts/templates/general_chat.json

@@ -0,0 +1,14 @@
+{
+  "id": "general_chat",
+  "name": "General Chat",
+  "description": "A general-purpose chat prompt",
+  "template": "Please answer the following question or respond to the message: {input}",
+  "system_message": "You are a helpful assistant that provides accurate and concise responses.",
+  "category": "general",
+  "is_public": false,
+  "created_by": "system",
+  "created_at": "2025-03-18T14:56:55.479511",
+  "price": 0.0,
+  "parameters": {},
+  "provider_defaults": {}
+}

prompts/templates/image_prompt.json

@@ -0,0 +1,39 @@
+{
+  "id": "image_prompt",
+  "name": "Image Generation",
+  "description": "Detailed prompt for image generation",
+  "template": "{subject} {style}, {details}, {quality}",
+  "system_message": "",
+  "category": "images",
+  "is_public": false,
+  "created_by": "system",
+  "created_at": "2025-03-18T14:56:55.479511",
+  "price": 0.0,
+  "parameters": {
+    "subject": {
+      "type": "string",
+      "description": "Main subject of the image",
+      "required": true
+    },
+    "style": {
+      "type": "string",
+      "description": "Art style",
+      "default": "digital art"
+    },
+    "details": {
+      "type": "string",
+      "description": "Additional details",
+      "default": "detailed, vibrant colors"
+    },
+    "quality": {
+      "type": "string",
+      "description": "Quality descriptors",
+      "default": "high quality, 4k, trending on artstation"
+    }
+  },
+  "provider_defaults": {
+    "openai": {
+      "model": "dall-e-3"
+    }
+  }
+}

providers/__init__.py

@@ -0,0 +1,41 @@
+"""
+AI Providers Package
+Exports provider classes for different AI model providers
+"""
+
+from providers.huggingface import HuggingFaceProvider
+from providers.openai import OpenAIProvider
+from providers.deepseek import DeepSeekProvider
+from providers.openrouter import OpenRouterProvider
+
+__all__ = [
+    'HuggingFaceProvider',
+    'OpenAIProvider',
+    'DeepSeekProvider', 
+    'OpenRouterProvider'
+]
+
+# Provider registry for easy access
+PROVIDERS = {
+    'huggingface': HuggingFaceProvider,
+    'openai': OpenAIProvider,
+    'deepseek': DeepSeekProvider,
+    'openrouter': OpenRouterProvider
+}
+
+def get_provider(provider_name: str, api_key: str = None):
+    """
+    Get a provider instance by name
+    
+    Args:
+        provider_name: Name of the provider ('huggingface', 'openai', etc.)
+        api_key: Optional API key to use
+        
+    Returns:
+        Provider instance or None if provider not found
+    """
+    provider_class = PROVIDERS.get(provider_name.lower())
+    if not provider_class:
+        return None
+    
+    return provider_class(api_key=api_key) 

providers/deepseek.py

@@ -0,0 +1,210 @@
+"""
+DeepSeek Provider Integration
+Handles API calls to DeepSeek for AI model inference
+"""
+import os
+import requests
+import time
+import json
+import logging
+from typing import Dict, Any, Optional, List
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("deepseek")
+
+class DeepSeekProvider:
+    """DeepSeek API provider for model inference"""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        """Initialize the DeepSeek provider with API key"""
+        self.api_key = api_key or os.getenv("DEEPSEEK_API_KEY")
+        if not self.api_key:
+            logger.warning("No DeepSeek API key provided. Set DEEPSEEK_API_KEY env variable.")
+        
+        self.base_url = "https://api.deepseek.com/v1"
+        self.headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+    
+    def generate_text(self, 
+                    prompt: str, 
+                    model: str = "deepseek-chat", 
+                    max_tokens: int = 1000, 
+                    temperature: float = 0.7, 
+                    system_message: str = "You are a helpful assistant.", 
+                    **kwargs) -> Dict[str, Any]:
+        """Generate text using DeepSeek models"""
+        if not self.api_key:
+            return {"success": False, "error": "DeepSeek API key not provided"}
+            
+        start_time = time.time()
+        
+        try:
+            messages = [
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": prompt}
+            ]
+            
+            payload = {
+                "model": model,
+                "messages": messages,
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                **kwargs
+            }
+            
+            response = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=self.headers,
+                json=payload
+            )
+            
+            # Check for errors
+            if response.status_code != 200:
+                logger.error(f"Error from DeepSeek API: {response.status_code} - {response.text}")
+                return {
+                    "success": False,
+                    "error": f"DeepSeek API error: {response.status_code}",
+                    "response_time": time.time() - start_time,
+                    "model": model,
+                    "provider": "deepseek"
+                }
+            
+            result = response.json()
+            
+            # Extract the generated text
+            generated_text = result["choices"][0]["message"]["content"]
+            
+            return {
+                "success": True,
+                "text": generated_text,
+                "model": model,
+                "provider": "deepseek",
+                "response_time": time.time() - start_time,
+                "tokens": {
+                    "prompt": result.get("usage", {}).get("prompt_tokens", 0),
+                    "completion": result.get("usage", {}).get("completion_tokens", 0),
+                    "total": result.get("usage", {}).get("total_tokens", 0)
+                },
+                "raw_response": result
+            }
+            
+        except Exception as e:
+            logger.error(f"Error generating text with DeepSeek: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "response_time": time.time() - start_time,
+                "model": model,
+                "provider": "deepseek"
+            }
+    
+    def generate_code(self, 
+                    prompt: str, 
+                    model: str = "deepseek-coder", 
+                    max_tokens: int = 2000, 
+                    temperature: float = 0.5, 
+                    **kwargs) -> Dict[str, Any]:
+        """Generate code using DeepSeek Coder models"""
+        if not self.api_key:
+            return {"success": False, "error": "DeepSeek API key not provided"}
+            
+        start_time = time.time()
+        
+        try:
+            messages = [
+                {"role": "system", "content": "You are a helpful coding assistant."},
+                {"role": "user", "content": prompt}
+            ]
+            
+            payload = {
+                "model": model,
+                "messages": messages,
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                **kwargs
+            }
+            
+            response = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=self.headers,
+                json=payload
+            )
+            
+            # Check for errors
+            if response.status_code != 200:
+                logger.error(f"Error from DeepSeek API: {response.status_code} - {response.text}")
+                return {
+                    "success": False,
+                    "error": f"DeepSeek API error: {response.status_code}",
+                    "response_time": time.time() - start_time,
+                    "model": model,
+                    "provider": "deepseek"
+                }
+            
+            result = response.json()
+            
+            # Extract the generated code
+            generated_code = result["choices"][0]["message"]["content"]
+            
+            return {
+                "success": True,
+                "text": generated_code,
+                "model": model,
+                "provider": "deepseek",
+                "response_time": time.time() - start_time,
+                "tokens": {
+                    "prompt": result.get("usage", {}).get("prompt_tokens", 0),
+                    "completion": result.get("usage", {}).get("completion_tokens", 0),
+                    "total": result.get("usage", {}).get("total_tokens", 0)
+                },
+                "raw_response": result
+            }
+            
+        except Exception as e:
+            logger.error(f"Error generating code with DeepSeek: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "response_time": time.time() - start_time,
+                "model": model,
+                "provider": "deepseek"
+            }
+    
+    def get_available_models(self) -> List[Dict[str, Any]]:
+        """Get available DeepSeek models"""
+        if not self.api_key:
+            return []
+            
+        # DeepSeek doesn't have a list models endpoint yet, so we hardcode the currently available models
+        models = [
+            {
+                "id": "deepseek-chat",
+                "name": "DeepSeek Chat",
+                "description": "General-purpose language model for chat",
+                "context_length": 4096
+            },
+            {
+                "id": "deepseek-coder",
+                "name": "DeepSeek Coder",
+                "description": "Specialized model for code generation",
+                "context_length": 8192
+            },
+            {
+                "id": "deepseek-math",
+                "name": "DeepSeek Math",
+                "description": "Model fine-tuned for mathematical reasoning",
+                "context_length": 4096
+            }
+        ]
+        
+        return models
+
+# Example usage
+if __name__ == "__main__":
+    # Test the provider
+    provider = DeepSeekProvider()
+    result = provider.generate_text("Write a short poem about AI.")
+    print(json.dumps(result, indent=2)) 

providers/huggingface.py

@@ -0,0 +1,193 @@
+"""
+Hugging Face Provider Integration
+Handles API calls to Hugging Face for AI model inference
+"""
+import os
+import requests
+import time
+import json
+import logging
+from typing import Dict, Any, Optional, List
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("huggingface")
+
+class HuggingFaceProvider:
+    """Hugging Face API provider for model inference"""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        """Initialize the Hugging Face provider with API key"""
+        self.api_key = api_key or os.getenv("HUGGINGFACE_API_KEY")
+        if not self.api_key:
+            logger.warning("No Hugging Face API key provided. Set HUGGINGFACE_API_KEY env variable.")
+        
+        self.base_url = "https://api-inference.huggingface.co/models"
+        self.headers = {"Authorization": f"Bearer {self.api_key}"} if self.api_key else {}
+    
+    def generate_text(self, 
+                     prompt: str, 
+                     model: str = "mistralai/Mistral-7B-Instruct-v0.2", 
+                     max_tokens: int = 1000, 
+                     temperature: float = 0.7, 
+                     **kwargs) -> Dict[str, Any]:
+        """Generate text using Hugging Face text generation models"""
+        start_time = time.time()
+        
+        try:
+            url = f"{self.base_url}/{model}"
+            payload = {
+                "inputs": prompt,
+                "parameters": {
+                    "max_new_tokens": max_tokens,
+                    "temperature": temperature,
+                    "return_full_text": False,
+                    **kwargs
+                }
+            }
+            
+            response = requests.post(
+                url, 
+                headers=self.headers, 
+                json=payload
+            )
+            
+            # Check for errors
+            if response.status_code != 200:
+                logger.error(f"Error from Hugging Face API: {response.status_code} - {response.text}")
+                return {
+                    "success": False,
+                    "error": f"Hugging Face API error: {response.status_code}",
+                    "response_time": time.time() - start_time,
+                    "model": model,
+                    "provider": "huggingface"
+                }
+            
+            result = response.json()
+            
+            # Handle different response formats
+            generated_text = ""
+            if isinstance(result, list) and len(result) > 0:
+                if "generated_text" in result[0]:
+                    generated_text = result[0]["generated_text"]
+                else:
+                    generated_text = result[0].get("text", "")
+            elif "generated_text" in result:
+                generated_text = result["generated_text"]
+            
+            return {
+                "success": True,
+                "text": generated_text,
+                "model": model,
+                "provider": "huggingface",
+                "response_time": time.time() - start_time,
+                "raw_response": result
+            }
+            
+        except Exception as e:
+            logger.error(f"Error generating text with Hugging Face: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "response_time": time.time() - start_time,
+                "model": model,
+                "provider": "huggingface"
+            }
+    
+    def generate_image(self, 
+                     prompt: str, 
+                     model: str = "stabilityai/stable-diffusion-xl-base-1.0", 
+                     height: int = 512, 
+                     width: int = 512, 
+                     **kwargs) -> Dict[str, Any]:
+        """Generate image using Hugging Face image generation models"""
+        start_time = time.time()
+        
+        try:
+            url = f"{self.base_url}/{model}"
+            payload = {
+                "inputs": prompt,
+                "parameters": {
+                    "height": height,
+                    "width": width,
+                    **kwargs
+                }
+            }
+            
+            response = requests.post(
+                url, 
+                headers=self.headers, 
+                json=payload
+            )
+            
+            # Image response is binary
+            if response.status_code != 200:
+                logger.error(f"Error from Hugging Face API: {response.status_code} - {response.text}")
+                return {
+                    "success": False,
+                    "error": f"Hugging Face API error: {response.status_code}",
+                    "response_time": time.time() - start_time,
+                    "model": model,
+                    "provider": "huggingface"
+                }
+            
+            # Return binary image data in base64
+            import base64
+            image_data = base64.b64encode(response.content).decode("utf-8")
+            
+            return {
+                "success": True,
+                "image_data": image_data,
+                "model": model,
+                "provider": "huggingface",
+                "response_time": time.time() - start_time
+            }
+            
+        except Exception as e:
+            logger.error(f"Error generating image with Hugging Face: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "response_time": time.time() - start_time,
+                "model": model,
+                "provider": "huggingface"
+            }
+    
+    def get_available_models(self, task: str = "text-generation") -> List[Dict[str, Any]]:
+        """Get available models for a specific task"""
+        try:
+            url = "https://huggingface.co/api/models"
+            params = {
+                "filter": task,
+                "sort": "downloads",
+                "direction": -1,
+                "limit": 100
+            }
+            
+            response = requests.get(url, params=params)
+            
+            if response.status_code != 200:
+                logger.error(f"Error fetching models: {response.status_code} - {response.text}")
+                return []
+            
+            models = response.json()
+            return [
+                {
+                    "id": model["id"],
+                    "name": model.get("name", model["id"]),
+                    "downloads": model.get("downloads", 0),
+                    "tags": model.get("tags", [])
+                }
+                for model in models
+            ]
+            
+        except Exception as e:
+            logger.error(f"Error fetching models: {e}")
+            return []
+
+# Example usage
+if __name__ == "__main__":
+    # Test the provider
+    provider = HuggingFaceProvider()
+    result = provider.generate_text("Write a short poem about AI.")
+    print(json.dumps(result, indent=2)) 

providers/openai.py

@@ -0,0 +1,178 @@
+"""
+OpenAI Provider Integration
+Handles API calls to OpenAI for text and image generation
+"""
+import os
+import time
+import json
+import logging
+from typing import Dict, Any, Optional, List
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("openai")
+
+try:
+    import openai
+    from openai import OpenAI
+    HAS_OPENAI = True
+except ImportError:
+    logger.warning("OpenAI package not installed. Install with: pip install openai")
+    HAS_OPENAI = False
+
+class OpenAIProvider:
+    """OpenAI API provider for model inference"""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        """Initialize the OpenAI provider with API key"""
+        if not HAS_OPENAI:
+            logger.error("OpenAI package not installed. Install with: pip install openai")
+            return
+            
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        if not self.api_key:
+            logger.warning("No OpenAI API key provided. Set OPENAI_API_KEY env variable.")
+        
+        # Initialize client
+        self.client = OpenAI(api_key=self.api_key)
+    
+    def generate_text(self, 
+                    prompt: str, 
+                    model: str = "gpt-3.5-turbo", 
+                    max_tokens: int = 1000, 
+                    temperature: float = 0.7, 
+                    system_message: str = "You are a helpful assistant.", 
+                    **kwargs) -> Dict[str, Any]:
+        """Generate text using OpenAI models"""
+        if not HAS_OPENAI or not self.api_key:
+            return {"success": False, "error": "OpenAI package not installed or API key not provided"}
+            
+        start_time = time.time()
+        
+        try:
+            messages = [
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": prompt}
+            ]
+            
+            response = self.client.chat.completions.create(
+                model=model,
+                messages=messages,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                **kwargs
+            )
+            
+            # Extract the generated text
+            generated_text = response.choices[0].message.content
+            
+            return {
+                "success": True,
+                "text": generated_text,
+                "model": model,
+                "provider": "openai",
+                "response_time": time.time() - start_time,
+                "tokens": {
+                    "prompt": response.usage.prompt_tokens,
+                    "completion": response.usage.completion_tokens,
+                    "total": response.usage.total_tokens
+                },
+                "raw_response": response.model_dump()
+            }
+            
+        except Exception as e:
+            logger.error(f"Error generating text with OpenAI: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "response_time": time.time() - start_time,
+                "model": model,
+                "provider": "openai"
+            }
+    
+    def generate_image(self, 
+                    prompt: str, 
+                    model: str = "dall-e-3", 
+                    size: str = "1024x1024", 
+                    quality: str = "standard", 
+                    n: int = 1, 
+                    **kwargs) -> Dict[str, Any]:
+        """Generate image using OpenAI DALL-E models"""
+        if not HAS_OPENAI or not self.api_key:
+            return {"success": False, "error": "OpenAI package not installed or API key not provided"}
+            
+        start_time = time.time()
+        
+        try:
+            response = self.client.images.generate(
+                model=model,
+                prompt=prompt,
+                size=size,
+                quality=quality,
+                n=n,
+                **kwargs
+            )
+            
+            return {
+                "success": True,
+                "image_url": response.data[0].url,  # URL of the generated image
+                "model": model,
+                "provider": "openai",
+                "response_time": time.time() - start_time,
+                "raw_response": response.model_dump()
+            }
+            
+        except Exception as e:
+            logger.error(f"Error generating image with OpenAI: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "response_time": time.time() - start_time,
+                "model": model,
+                "provider": "openai"
+            }
+    
+    def get_available_models(self) -> List[Dict[str, Any]]:
+        """Get available OpenAI models"""
+        if not HAS_OPENAI or not self.api_key:
+            return []
+            
+        try:
+            response = self.client.models.list()
+            
+            models = [
+                {
+                    "id": model.id,
+                    "name": model.id,
+                    "created": model.created
+                }
+                for model in response.data
+            ]
+            
+            # Filter to only include completion and chat models
+            text_models = [
+                model for model in models
+                if any(prefix in model["id"] for prefix in ["gpt-", "text-"])
+            ]
+            
+            # Add DALL-E models (they don't show up in the list)
+            image_models = [
+                {"id": "dall-e-3", "name": "DALL-E 3"},
+                {"id": "dall-e-2", "name": "DALL-E 2"}
+            ]
+            
+            return {
+                "text_models": text_models,
+                "image_models": image_models
+            }
+            
+        except Exception as e:
+            logger.error(f"Error fetching OpenAI models: {e}")
+            return []
+
+# Example usage
+if __name__ == "__main__":
+    # Test the provider
+    provider = OpenAIProvider()
+    result = provider.generate_text("Write a short poem about AI.")
+    print(json.dumps(result, indent=2)) 

providers/openrouter.py

@@ -0,0 +1,164 @@
+"""
+OpenRouter Provider Integration
+Handles API calls to OpenRouter for AI model inference across multiple providers
+"""
+import os
+import requests
+import time
+import json
+import logging
+from typing import Dict, Any, Optional, List
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("openrouter")
+
+class OpenRouterProvider:
+    """OpenRouter API provider for model inference across multiple AI providers"""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        """Initialize the OpenRouter provider with API key"""
+        self.api_key = api_key or os.getenv("OPENROUTER_API_KEY")
+        if not self.api_key:
+            logger.warning("No OpenRouter API key provided. Set OPENROUTER_API_KEY env variable.")
+        
+        self.base_url = "https://openrouter.ai/api/v1"
+        self.headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": os.getenv("APP_URL", "http://localhost:8000"),  # Required by OpenRouter
+            "X-Title": os.getenv("APP_NAME", "AI Tool Hub")  # Your app name
+        }
+    
+    def generate_text(self, 
+                     prompt: str, 
+                     model: str = "anthropic/claude-3-opus:beta", 
+                     max_tokens: int = 1000, 
+                     temperature: float = 0.7, 
+                     system_message: str = "You are a helpful assistant.", 
+                     **kwargs) -> Dict[str, Any]:
+        """Generate text using OpenRouter models"""
+        if not self.api_key:
+            return {"success": False, "error": "OpenRouter API key not provided"}
+            
+        start_time = time.time()
+        
+        try:
+            messages = [
+                {"role": "system", "content": system_message},
+                {"role": "user", "content": prompt}
+            ]
+            
+            payload = {
+                "model": model,
+                "messages": messages,
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+                **kwargs
+            }
+            
+            response = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=self.headers,
+                json=payload
+            )
+            
+            # Check for errors
+            if response.status_code != 200:
+                logger.error(f"Error from OpenRouter API: {response.status_code} - {response.text}")
+                return {
+                    "success": False,
+                    "error": f"OpenRouter API error: {response.status_code}",
+                    "response_time": time.time() - start_time,
+                    "model": model,
+                    "provider": "openrouter"
+                }
+            
+            result = response.json()
+            
+            # Extract the generated text
+            generated_text = result["choices"][0]["message"]["content"]
+            
+            return {
+                "success": True,
+                "text": generated_text,
+                "model": model,
+                "provider": "openrouter",
+                "response_time": time.time() - start_time,
+                "tokens": {
+                    "prompt": result.get("usage", {}).get("prompt_tokens", 0),
+                    "completion": result.get("usage", {}).get("completion_tokens", 0),
+                    "total": result.get("usage", {}).get("total_tokens", 0)
+                },
+                "raw_response": result
+            }
+            
+        except Exception as e:
+            logger.error(f"Error generating text with OpenRouter: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "response_time": time.time() - start_time,
+                "model": model,
+                "provider": "openrouter"
+            }
+    
+    def get_available_models(self) -> List[Dict[str, Any]]:
+        """Get available OpenRouter models"""
+        if not self.api_key:
+            return []
+            
+        try:
+            response = requests.get(
+                f"{self.base_url}/models",
+                headers=self.headers
+            )
+            
+            if response.status_code != 200:
+                logger.error(f"Error fetching OpenRouter models: {response.status_code} - {response.text}")
+                return []
+            
+            models_data = response.json()
+            models = []
+            
+            for model in models_data.get("data", []):
+                models.append({
+                    "id": model.get("id"),
+                    "name": model.get("name", model.get("id")),
+                    "description": model.get("description", ""),
+                    "context_length": model.get("context_length", 4096),
+                    "pricing": {
+                        "prompt": model.get("pricing", {}).get("prompt", 0),
+                        "completion": model.get("pricing", {}).get("completion", 0)
+                    }
+                })
+            
+            return models
+            
+        except Exception as e:
+            logger.error(f"Error fetching OpenRouter models: {e}")
+            return []
+    
+    def get_models_by_provider(self, provider: str = None) -> List[Dict[str, Any]]:
+        """Get available models filtered by provider"""
+        models = self.get_available_models()
+        
+        if not provider:
+            return models
+            
+        return [model for model in models if provider.lower() in model.get("id", "").lower()]
+
+# Example usage
+if __name__ == "__main__":
+    # Test the provider
+    provider = OpenRouterProvider()
+    result = provider.generate_text("Write a short poem about AI.")
+    print(json.dumps(result, indent=2))
+    
+    # Get all models
+    models = provider.get_available_models()
+    print(f"Found {len(models)} models")
+    
+    # Get only Anthropic models
+    anthropic_models = provider.get_models_by_provider("anthropic")
+    print(f"Found {len(anthropic_models)} Anthropic models") 

requirements.txt

@@ -0,0 +1,35 @@
+# Web Framework
+fastapi==0.115.0
+uvicorn==0.24.0
+jinja2==3.1.2
+python-multipart==0.0.6
+pydantic==2.4.2
+python-dotenv==1.0.0
+itsdangerous==2.1.2
+aiofiles==23.2.1
+requests==2.31.0
+# starlette is included as a dependency of FastAPI
+
+# Database
+boto3==1.28.48
+redis==5.0.0
+
+# AI/ML
+openai==1.0.0
+
+# Authentication
+python-jose[cryptography]>=3.3.0
+passlib[bcrypt]>=1.7.4
+PyJWT==2.8.0
+
+# Utilities
+pyyaml>=6.0.0
+psutil==5.9.5
+
+# Testing
+pytest>=7.0.0
+pytest-asyncio>=0.18.0
+
+# Additional dependencies
+pandas==2.1.0
+huggingface-hub==0.17.2 

static/css/styles.css

@@ -0,0 +1,737 @@
+/* MegicAI - CSS styles
+ * Main stylesheet for the single-process FastAPI application
+ */
+
+/* === Base Styles === */
+:root {
+    --primary-color: #121212;
+    --secondary-color: #7367F0;
+    --accent-color: #FFD700;
+    --text-color: #FFFFFF;
+    --text-dark: #333333;
+    --card-bg: rgba(30, 30, 40, 0.85);
+    --hover-color: rgba(255, 255, 255, 0.15);
+    --sidebar-bg: rgba(21, 21, 31, 0.95);
+    --sidebar-hover: rgba(255, 255, 255, 0.1);
+    --input-bg: rgba(45, 45, 60, 0.8);
+    --button-primary-bg: linear-gradient(135deg, #7367F0, #8E54E9);
+    --button-secondary-bg: rgba(70, 70, 85, 0.5);
+    --header-bg: rgba(25, 25, 35, 0.9);
+    --tooltip-bg: rgba(10, 10, 15, 0.95);
+    --dark-sidebar: #1a1a1a;
+    --success-color: #4CAF50;
+    --warning-color: #FFC107;
+    --error-color: #F44336;
+    --info-color: #2196F3;
+}
+
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+    line-height: 1.6;
+    color: var(--text-color);
+    background-color: var(--primary-color);
+    min-height: 100vh;
+}
+
+a {
+    color: var(--text-color);
+    text-decoration: none;
+}
+
+h1, h2, h3, h4, h5, h6 {
+    margin-bottom: 0.5rem;
+    font-weight: 600;
+}
+
+/* === Layout === */
+.app-container {
+    display: flex;
+    min-height: 100vh;
+}
+
+/* === Sidebar === */
+.sidebar {
+    width: 260px;
+    background-color: var(--sidebar-bg);
+    border-right: 1px solid rgba(255, 255, 255, 0.1);
+    display: flex;
+    flex-direction: column;
+    position: fixed;
+    height: 100vh;
+    overflow-y: auto;
+}
+
+.sidebar-header {
+    padding: 20px;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.sidebar-header h1 {
+    font-size: 1.5rem;
+    margin-bottom: 0.2rem;
+}
+
+.sidebar-subtitle {
+    opacity: 0.7;
+    font-size: 0.9rem;
+}
+
+.sidebar-section {
+    padding: 20px;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.sidebar-heading {
+    font-size: 0.8rem;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    opacity: 0.7;
+    margin-bottom: 15px;
+}
+
+.nav-item {
+    display: flex;
+    align-items: center;
+    padding: 10px;
+    border-radius: 5px;
+    margin-bottom: 5px;
+    transition: background-color 0.2s;
+}
+
+.nav-item:hover {
+    background-color: var(--sidebar-hover);
+}
+
+.nav-item.active {
+    background-color: var(--secondary-color);
+}
+
+.nav-icon {
+    margin-right: 12px;
+    font-size: 1.2rem;
+}
+
+.sidebar-footer {
+    margin-top: auto;
+    padding: 20px;
+    opacity: 0.5;
+    font-size: 0.8rem;
+    text-align: center;
+}
+
+/* === Content Area === */
+.content {
+    flex: 1;
+    padding: 30px;
+    margin-left: 260px;
+    width: calc(100% - 260px);
+}
+
+.content-header {
+    margin-bottom: 30px;
+}
+
+.content-header h1 {
+    font-size: 2rem;
+    margin-bottom: 0.5rem;
+}
+
+/* === Cards & Tools === */
+.tools-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+    gap: 20px;
+    margin-top: 20px;
+}
+
+.tool-card {
+    background-color: var(--card-bg);
+    border-radius: 8px;
+    padding: 20px;
+    display: flex;
+    transition: transform 0.2s, box-shadow 0.2s;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+}
+
+.tool-card:hover {
+    transform: translateY(-3px);
+    box-shadow: 0 5px 15px rgba(0, 0, 0, 0.2);
+}
+
+.tool-icon {
+    font-size: 2rem;
+    margin-right: 15px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.tool-info {
+    flex: 1;
+}
+
+.tool-name {
+    font-size: 1.2rem;
+    margin-bottom: 5px;
+}
+
+.tool-description {
+    opacity: 0.8;
+    font-size: 0.9rem;
+    margin-bottom: 10px;
+}
+
+.tool-meta {
+    display: flex;
+    align-items: center;
+    margin-top: auto;
+}
+
+.tool-cost {
+    background-color: rgba(255, 215, 0, 0.2);
+    color: var(--accent-color);
+    padding: 2px 8px;
+    border-radius: 20px;
+    font-size: 0.8rem;
+}
+
+/* === Credits Display === */
+.credit-display {
+    display: flex;
+    align-items: center;
+    background-color: rgba(255, 255, 255, 0.1);
+    padding: 12px;
+    border-radius: 8px;
+}
+
+/* === Auth Buttons & User Info === */
+.auth-buttons {
+    display: flex;
+    gap: 10px;
+    margin-bottom: 15px;
+}
+
+.auth-buttons .btn {
+    flex: 1;
+}
+
+.user-section {
+    margin-bottom: 15px;
+}
+
+.user-info {
+    display: flex;
+    align-items: center;
+    margin-bottom: 12px;
+}
+
+.user-icon {
+    font-size: 1.5rem;
+    margin-right: 12px;
+    color: var(--secondary-color);
+}
+
+.user-name {
+    font-weight: 600;
+}
+
+.user-role {
+    font-size: 0.8rem;
+    opacity: 0.7;
+}
+
+.user-actions {
+    display: flex;
+    gap: 10px;
+}
+
+.btn-small {
+    padding: 5px 10px;
+    font-size: 0.8rem;
+}
+
+.credit-icon {
+    font-size: 1.5rem;
+    margin-right: 12px;
+}
+
+.credit-label {
+    font-size: 0.8rem;
+    opacity: 0.8;
+}
+
+.credit-value {
+    font-size: 1.2rem;
+    font-weight: 600;
+}
+
+/* === Forms & Inputs === */
+.form-group {
+    margin-bottom: 20px;
+}
+
+.form-group label {
+    display: block;
+    margin-bottom: 8px;
+    font-weight: 500;
+}
+
+.form-select {
+    width: 100%;
+    padding: 10px;
+    background-color: var(--input-bg);
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    border-radius: 5px;
+    color: var(--text-color);
+    font-size: 1rem;
+}
+
+.prompt-textarea {
+    width: 100%;
+    min-height: 150px;
+    padding: 12px;
+    background-color: var(--input-bg);
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    border-radius: 5px;
+    color: var(--text-color);
+    font-size: 1rem;
+    resize: vertical;
+}
+
+.template-box {
+    background-color: rgba(0, 0, 0, 0.2);
+    padding: 12px;
+    border-radius: 5px;
+    margin-bottom: 10px;
+    font-size: 0.9rem;
+}
+
+/* === Buttons === */
+.btn {
+    padding: 10px 20px;
+    border-radius: 5px;
+    border: none;
+    font-size: 1rem;
+    cursor: pointer;
+    transition: all 0.2s;
+    display: inline-block;
+    text-align: center;
+}
+
+.btn-primary {
+    background: var(--button-primary-bg);
+    color: white;
+}
+
+.btn-primary:hover {
+    opacity: 0.9;
+    transform: translateY(-2px);
+}
+
+.btn-secondary {
+    background-color: var(--button-secondary-bg);
+    color: white;
+    border: 1px solid rgba(255, 255, 255, 0.2);
+}
+
+.btn-secondary:hover {
+    background-color: rgba(90, 90, 105, 0.5);
+}
+
+.btn:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+}
+
+/* === Search === */
+.search-container {
+    margin-bottom: 20px;
+}
+
+.search-input {
+    width: 100%;
+    padding: 12px 15px;
+    border-radius: 5px;
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    background-color: var(--input-bg);
+    color: var(--text-color);
+    font-size: 1rem;
+}
+
+/* === Tool Page === */
+.tool-header {
+    display: flex;
+    align-items: center;
+    margin-bottom: 30px;
+    background-color: var(--header-bg);
+    padding: 20px;
+    border-radius: 10px;
+}
+
+.tool-header-icon {
+    font-size: 2.5rem;
+    margin-right: 20px;
+}
+
+.tool-content {
+    display: grid;
+    grid-template-columns: 3fr 1fr;
+    gap: 20px;
+}
+
+.tool-sidebar {
+    background-color: var(--card-bg);
+    border-radius: 8px;
+    padding: 20px;
+    height: fit-content;
+}
+
+.tool-cost-box h3 {
+    margin-bottom: 10px;
+}
+
+.cost-display {
+    background-color: rgba(255, 215, 0, 0.2);
+    padding: 10px;
+    border-radius: 5px;
+    text-align: center;
+    margin-bottom: 15px;
+}
+
+.cost-value {
+    font-size: 1.5rem;
+    font-weight: 600;
+    color: var(--accent-color);
+}
+
+.suggestion-chips {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    margin-bottom: 20px;
+}
+
+.suggestion-chip {
+    background-color: var(--button-secondary-bg);
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    border-radius: 20px;
+    padding: 5px 15px;
+    font-size: 0.9rem;
+    cursor: pointer;
+    transition: all 0.2s;
+}
+
+.suggestion-chip:hover {
+    background-color: var(--secondary-color);
+}
+
+.button-section {
+    display: flex;
+    gap: 10px;
+    margin-top: 30px;
+}
+
+/* === Result Page === */
+.result-header {
+    margin-bottom: 20px;
+}
+
+.result-meta {
+    display: flex;
+    gap: 20px;
+    margin-top: 10px;
+}
+
+.result-provider, .result-time {
+    display: flex;
+    align-items: center;
+    background-color: rgba(255, 255, 255, 0.1);
+    padding: 8px 15px;
+    border-radius: 20px;
+    font-size: 0.9rem;
+}
+
+.provider-icon, .time-icon {
+    margin-right: 8px;
+}
+
+.result-content {
+    background-color: var(--card-bg);
+    border-radius: 10px;
+    padding: 20px;
+    margin-bottom: 20px;
+}
+
+.result-text {
+    background-color: white;
+    color: var(--text-dark);
+    padding: 20px;
+    border-radius: 8px;
+    margin-bottom: 20px;
+    line-height: 1.6;
+}
+
+.result-image img {
+    max-width: 100%;
+    border-radius: 8px;
+    display: block;
+    margin: 0 auto;
+}
+
+.result-video video {
+    max-width: 100%;
+    border-radius: 8px;
+    display: block;
+    margin: 0 auto;
+}
+
+.result-ai-probability {
+    margin-top: 20px;
+}
+
+.probability-bar {
+    height: 20px;
+    background-color: rgba(255, 255, 255, 0.1);
+    border-radius: 10px;
+    overflow: hidden;
+    margin-bottom: 5px;
+}
+
+.probability-fill {
+    height: 100%;
+    width: var(--probability);
+    background: linear-gradient(90deg, #4CAF50, #F44336);
+    border-radius: 10px;
+}
+
+.probability-label {
+    display: flex;
+    justify-content: space-between;
+    font-size: 0.8rem;
+    opacity: 0.8;
+}
+
+.result-actions {
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+}
+
+.action-buttons {
+    display: flex;
+    gap: 10px;
+}
+
+.result-details {
+    background-color: rgba(0, 0, 0, 0.2);
+    border-radius: 5px;
+    padding: 10px;
+}
+
+.result-details summary {
+    cursor: pointer;
+    padding: 5px;
+}
+
+.response-json {
+    background-color: rgba(0, 0, 0, 0.3);
+    padding: 10px;
+    border-radius: 5px;
+    overflow-x: auto;
+    margin-top: 10px;
+}
+
+.response-json pre {
+    font-family: monospace;
+    font-size: 0.9rem;
+    white-space: pre-wrap;
+}
+
+/* === Ad Page === */
+.ad-header {
+    margin-bottom: 20px;
+}
+
+.ad-content {
+    background-color: var(--card-bg);
+    border-radius: 10px;
+    padding: 20px;
+}
+
+.ad-info {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 20px;
+    margin-bottom: 20px;
+}
+
+.ad-reward, .ad-duration {
+    display: flex;
+    align-items: center;
+    background-color: rgba(0, 0, 0, 0.2);
+    padding: 15px;
+    border-radius: 8px;
+}
+
+.reward-icon, .duration-icon {
+    font-size: 2rem;
+    margin-right: 15px;
+}
+
+.ad-player {
+    margin-bottom: 20px;
+}
+
+.ad-container {
+    background-color: #000;
+    aspect-ratio: 16 / 9;
+    border-radius: 8px;
+    overflow: hidden;
+}
+
+.mock-ad {
+    width: 100%;
+    height: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: white;
+    text-align: center;
+}
+
+.mock-ad-content {
+    max-width: 80%;
+}
+
+.ad-timer-container {
+    margin: 20px 0;
+}
+
+.ad-timer {
+    display: inline-block;
+    background-color: rgba(255, 255, 255, 0.2);
+    padding: 5px 15px;
+    border-radius: 20px;
+    font-weight: bold;
+}
+
+.mock-ad-image {
+    margin-top: 20px;
+    background-color: rgba(255, 255, 255, 0.1);
+    aspect-ratio: 16 / 9;
+    border-radius: 5px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.ad-actions {
+    display: flex;
+    gap: 10px;
+    margin-top: 20px;
+}
+
+/* === Error Page === */
+.error-container {
+    background-color: var(--card-bg);
+    border-radius: 10px;
+    padding: 30px;
+}
+
+.error-header {
+    display: flex;
+    align-items: center;
+    margin-bottom: 20px;
+}
+
+.error-icon {
+    font-size: 3rem;
+    color: var(--error-color);
+    margin-right: 20px;
+}
+
+.error-code {
+    font-size: 0.9rem;
+    opacity: 0.7;
+}
+
+.error-message {
+    background-color: rgba(244, 67, 54, 0.1);
+    border-left: 4px solid var(--error-color);
+    padding: 15px;
+    margin-bottom: 20px;
+}
+
+.error-suggestions {
+    margin-bottom: 20px;
+}
+
+.error-suggestions ul {
+    margin-left: 20px;
+}
+
+.error-actions {
+    display: flex;
+    gap: 10px;
+}
+
+/* === Alerts === */
+.alert {
+    padding: 15px;
+    border-radius: 5px;
+    margin-bottom: 20px;
+}
+
+.alert-success {
+    background-color: rgba(76, 175, 80, 0.1);
+    border-left: 4px solid var(--success-color);
+    color: var(--success-color);
+}
+
+.alert-warning {
+    background-color: rgba(255, 193, 7, 0.1);
+    border-left: 4px solid var(--warning-color);
+    color: var(--warning-color);
+}
+
+.alert-error {
+    background-color: rgba(244, 67, 54, 0.1);
+    border-left: 4px solid var(--error-color);
+    color: var(--error-color);
+}
+
+/* === Responsive Design === */
+@media (max-width: 768px) {
+    .app-container {
+        flex-direction: column;
+    }
+    
+    .sidebar {
+        width: 100%;
+        height: auto;
+        position: relative;
+    }
+    
+    .content {
+        margin-left: 0;
+        width: 100%;
+    }
+    
+    .tool-content {
+        grid-template-columns: 1fr;
+    }
+    
+    .tools-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .ad-info {
+        grid-template-columns: 1fr;
+    }
+} 

static/js/main.js

@@ -0,0 +1,260 @@
+/**
+ * MegicAI - Main JavaScript
+ * Common functionality used across the application
+ */
+
+// Helper function to format numbers with commas
+function formatNumber(num) {
+    return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+
+// Update credit display with animation
+function updateCredits(newValue, animate = true) {
+    const creditDisplay = document.querySelector('.credit-value');
+    if (!creditDisplay) return;
+    
+    const currentValue = parseInt(creditDisplay.textContent.replace(/,/g, ''), 10);
+    
+    if (animate && !isNaN(currentValue)) {
+        const diff = newValue - currentValue;
+        const duration = 1000; // 1 second animation
+        const startTime = performance.now();
+        
+        function updateCounter(timestamp) {
+            const elapsed = timestamp - startTime;
+            const progress = Math.min(elapsed / duration, 1);
+            const currentCount = Math.floor(currentValue + (diff * progress));
+            
+            creditDisplay.textContent = formatNumber(currentCount);
+            
+            if (progress < 1) {
+                requestAnimationFrame(updateCounter);
+            } else {
+                creditDisplay.textContent = formatNumber(newValue);
+            }
+        }
+        
+        requestAnimationFrame(updateCounter);
+    } else {
+        creditDisplay.textContent = formatNumber(newValue);
+    }
+}
+
+// Copy text to clipboard
+function copyToClipboard(text, successCallback = null) {
+    navigator.clipboard.writeText(text)
+        .then(() => {
+            if (successCallback) successCallback();
+        })
+        .catch(err => {
+            console.error('Failed to copy text: ', err);
+        });
+}
+
+// Toggle visibility of an element
+function toggleVisibility(elementId) {
+    const element = document.getElementById(elementId);
+    if (element) {
+        element.style.display = element.style.display === 'none' ? 'block' : 'none';
+    }
+}
+
+// Add suggestions to a textarea
+function addSuggestionToPrompt(suggestion, elementId) {
+    const textarea = document.getElementById(elementId);
+    if (textarea) {
+        const currentText = textarea.value;
+        textarea.value = currentText ? `${currentText}\n${suggestion}` : suggestion;
+        textarea.focus();
+    }
+}
+
+// Form validation
+function validateForm(formId, errorElementId = null) {
+    const form = document.getElementById(formId);
+    if (!form) return true;
+    
+    let isValid = true;
+    const requiredInputs = form.querySelectorAll('[required]');
+    
+    // Clear previous error messages
+    form.querySelectorAll('.field-error').forEach(el => el.remove());
+    
+    requiredInputs.forEach(input => {
+        if (!input.value.trim()) {
+            isValid = false;
+            
+            // Create error message
+            const errorMsg = document.createElement('div');
+            errorMsg.className = 'field-error';
+            errorMsg.textContent = 'This field is required';
+            input.parentNode.appendChild(errorMsg);
+            
+            // Add error style to input
+            input.classList.add('input-error');
+        } else {
+            input.classList.remove('input-error');
+        }
+    });
+    
+    // If there's a global error element, update it
+    if (!isValid && errorElementId) {
+        const errorElement = document.getElementById(errorElementId);
+        if (errorElement) {
+            errorElement.textContent = 'Please fill in all required fields';
+            errorElement.style.display = 'block';
+        }
+    }
+    
+    return isValid;
+}
+
+// Handle form submission with AJAX
+function submitFormAsync(formId, successCallback, errorCallback) {
+    const form = document.getElementById(formId);
+    if (!form) return;
+    
+    form.addEventListener('submit', function(event) {
+        event.preventDefault();
+        
+        if (!validateForm(formId)) return;
+        
+        const formData = new FormData(form);
+        const submitButton = form.querySelector('button[type="submit"]');
+        
+        if (submitButton) {
+            const originalText = submitButton.innerHTML;
+            submitButton.disabled = true;
+            submitButton.innerHTML = '<i class="fas fa-spinner fa-spin"></i> Processing...';
+        }
+        
+        fetch(form.action, {
+            method: form.method,
+            body: formData
+        })
+        .then(response => {
+            // Check if the response is JSON or HTML
+            const contentType = response.headers.get('content-type');
+            if (!response.ok) {
+                if (contentType && contentType.includes('application/json')) {
+                    return response.json().then(data => {
+                        throw new Error(data.message || 'An error occurred');
+                    });
+                } else {
+                    // For non-JSON errors, just show the status text instead of trying to parse JSON
+                    throw new Error('Server error occurred: ' + response.statusText);
+                }
+            }
+            
+            // If response is HTML, handle it as a redirect
+            if (contentType && contentType.includes('text/html')) {
+                // This is an HTML response, likely a result page - redirect to it
+                window.location.href = response.url;
+                return { success: true, redirected: true };
+            }
+            
+            // Check if it's a redirect (e.g., 302, 303)
+            if (response.redirected) {
+                window.location.href = response.url;
+                return { success: true, redirected: true };
+            }
+            
+            // Otherwise process as JSON
+            if (contentType && contentType.includes('application/json')) {
+                return response.json();
+            } else {
+                // If it's not JSON and not HTML with a redirect, handle it as a success
+                return { success: true, message: "Operation completed successfully" };
+            }
+        })
+        .then(data => {
+            if (successCallback) successCallback(data);
+        })
+        .catch(error => {
+            console.error("Error during form submission:", error);
+            if (errorCallback) errorCallback(error.message);
+        })
+        .finally(() => {
+            if (submitButton) {
+                submitButton.disabled = false;
+                submitButton.innerHTML = originalText;
+            }
+        });
+    });
+}
+
+// Document ready event
+document.addEventListener('DOMContentLoaded', function() {
+    console.log('MegicAI application initialized');
+    
+    // Initialize any forms with async submission
+    const asyncForms = document.querySelectorAll('[data-async-submit]');
+    asyncForms.forEach(form => {
+        const formId = form.id;
+        const successTarget = form.getAttribute('data-success-target');
+        const errorTarget = form.getAttribute('data-error-target');
+        
+        // Check if the form is for HTML-based operations like process-request
+        const actionUrl = form.getAttribute('action');
+        if (actionUrl && (actionUrl.includes('/process-request') || actionUrl.includes('/watch-ad'))) {
+            // These endpoints return HTML, not JSON - use regular form submission
+            console.log('Form will use direct submission:', actionUrl);
+            form.removeAttribute('data-async-submit');
+            
+            // Add regular submit handler with validation
+            form.addEventListener('submit', function(event) {
+                if (!validateForm(formId)) {
+                    event.preventDefault();
+                    return false;
+                }
+                
+                const submitButton = form.querySelector('button[type="submit"]');
+                if (submitButton) {
+                    // Add loading indicator
+                    const originalText = submitButton.innerHTML;
+                    submitButton.disabled = true;
+                    submitButton.innerHTML = '<i class="fas fa-spinner fa-spin"></i> Processing...';
+                    
+                    // Make sure the form submits normally for HTML responses
+                    setTimeout(() => {
+                        if (submitButton.disabled) {
+                            // Re-enable after a timeout just in case
+                            submitButton.disabled = false;
+                            submitButton.innerHTML = originalText;
+                        }
+                    }, 10000); // 10 second timeout
+                }
+                
+                return true;
+            });
+        } else {
+            // Use async submission for JSON-based API endpoints
+            submitFormAsync(
+                formId,
+                data => {
+                    if (successTarget) {
+                        const targetElement = document.getElementById(successTarget);
+                        if (targetElement) {
+                            targetElement.textContent = data.message || 'Success!';
+                            targetElement.style.display = 'block';
+                        }
+                    }
+                    
+                    // If a redirect URL is provided in the response
+                    if (data.redirect) {
+                        window.location.href = data.redirect;
+                    }
+                },
+                error => {
+                    if (errorTarget) {
+                        const targetElement = document.getElementById(errorTarget);
+                        if (targetElement) {
+                            targetElement.textContent = error;
+                            targetElement.style.display = 'block';
+                        }
+                    }
+                }
+            );
+        }
+    });
+}); 

templates/ad.html

@@ -0,0 +1,160 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{ app_name }} - Watch Ad</title>
+    <link rel="stylesheet" href="{{ url_for('static', path='/css/styles.css') }}">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+</head>
+<body>
+    <div class="app-container">
+        <!-- Sidebar -->
+        <div class="sidebar">
+            <div class="sidebar-header">
+                <h1>{{ app_name }}</h1>
+                <div class="sidebar-subtitle">AI Toolkit</div>
+            </div>
+            
+            <!-- Credits Section -->
+            <div class="sidebar-section">
+                <div class="credit-display">
+                    <div class="credit-icon">
+                        <i class="fas fa-coins"></i>
+                    </div>
+                    <div>
+                        <div class="credit-label">Your Credits</div>
+                        <div class="credit-value">{{ user_credits }}</div>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- Navigation -->
+            <div class="sidebar-section">
+                <div class="sidebar-heading">Navigation</div>
+                <a href="/" class="nav-item">
+                    <div class="nav-icon"><i class="fas fa-home"></i></div>
+                    <div>Home</div>
+                </a>
+                <a href="#" class="nav-item">
+                    <div class="nav-icon"><i class="fas fa-history"></i></div>
+                    <div>History</div>
+                </a>
+                <a href="#" class="nav-item">
+                    <div class="nav-icon"><i class="fas fa-coins"></i></div>
+                    <div>Buy Credits</div>
+                </a>
+            </div>
+            
+            <!-- Tools -->
+            <div class="sidebar-section">
+                <div class="sidebar-heading">Tools</div>
+                {% for tool in tools %}
+                <a href="/tool/{{ tool.id }}" class="nav-item">
+                    <div class="nav-icon"><i class="{{ tool.icon }}"></i></div>
+                    <div>{{ tool.name }}</div>
+                </a>
+                {% endfor %}
+            </div>
+            
+            <div class="sidebar-footer">
+                &copy; {{ app_name }} 2023
+            </div>
+        </div>
+        
+        <!-- Content -->
+        <div class="content">
+            <div class="content-header">
+                <h1>Watch an Ad to Earn Credits</h1>
+                <p>Watch this ad to gain free credits for using AI tools.</p>
+            </div>
+            
+            <div class="ad-content">
+                <div class="ad-header">
+                    <h2>Ad Information</h2>
+                </div>
+                
+                <div class="ad-info">
+                    <div class="ad-reward">
+                        <div class="reward-icon">
+                            <i class="fas fa-coins"></i>
+                        </div>
+                        <div>
+                            <h3>Reward</h3>
+                            <p>{{ ad_reward }} credits</p>
+                        </div>
+                    </div>
+                    
+                    <div class="ad-duration">
+                        <div class="duration-icon">
+                            <i class="fas fa-clock"></i>
+                        </div>
+                        <div>
+                            <h3>Duration</h3>
+                            <p>{{ ad_duration }} seconds</p>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="ad-player">
+                    <div class="ad-container">
+                        <div class="mock-ad">
+                            <div class="mock-ad-content">
+                                <h2>Advertisement</h2>
+                                <p>This is a sample advertisement. In a real implementation, this would be an actual ad from an ad network.</p>
+                                <div class="mock-ad-image">
+                                    <i class="fas fa-image fa-4x"></i>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <div class="ad-timer-container">
+                        <div class="ad-timer">
+                            <span id="ad-countdown">{{ ad_duration }}</span> seconds remaining
+                        </div>
+                    </div>
+                </div>
+                
+                <form action="/complete-ad" method="post">
+                    <input type="hidden" name="tool_id" value="{{ tool_id }}">
+                    <input type="hidden" name="prompt" value="{{ prompt }}">
+                    <input type="hidden" name="provider" value="{{ provider }}">
+                    <input type="hidden" name="model" value="{{ model }}">
+                    
+                    <div class="ad-actions">
+                        <button id="complete-ad-btn" class="btn btn-primary" disabled>
+                            Please wait <span id="btn-countdown">{{ ad_duration }}</span>s
+                        </button>
+                        <a href="/" class="btn btn-secondary">Cancel</a>
+                    </div>
+                </form>
+            </div>
+        </div>
+    </div>
+    
+    <script>
+        document.addEventListener('DOMContentLoaded', function() {
+            const adDuration = {{ ad_duration }};
+            let timeRemaining = adDuration;
+            const countdownElement = document.getElementById('ad-countdown');
+            const btnCountdownElement = document.getElementById('btn-countdown');
+            const completeAdBtn = document.getElementById('complete-ad-btn');
+            
+            const countdownInterval = setInterval(function() {
+                timeRemaining -= 1;
+                
+                if (timeRemaining <= 0) {
+                    clearInterval(countdownInterval);
+                    countdownElement.textContent = '0';
+                    completeAdBtn.disabled = false;
+                    completeAdBtn.innerHTML = 'Complete and Get Credits <i class="fas fa-check"></i>';
+                } else {
+                    countdownElement.textContent = timeRemaining;
+                    btnCountdownElement.textContent = timeRemaining;
+                }
+            }, 1000);
+        });
+    </script>
+</body>
+</html> 

templates/ad_reward.html

@@ -0,0 +1,226 @@
+{% extends "base.html" %}
+
+{% block title %}Watch Ad & Earn Credits{% endblock %}
+
+{% block content %}
+<div class="max-w-4xl mx-auto py-8 px-4 sm:px-6 lg:px-8">
+    <div class="bg-white dark:bg-gray-800 shadow rounded-lg overflow-hidden">
+        <div class="px-6 py-5 border-b border-gray-200 dark:border-gray-700">
+            <h1 class="text-xl font-semibold text-gray-900 dark:text-white">
+                Watch Ad & Earn Credits
+            </h1>
+        </div>
+        
+        <div class="px-6 py-4">
+            <div class="flex flex-col lg:flex-row gap-6">
+                <div class="w-full lg:w-2/3">
+                    <div class="bg-gray-100 dark:bg-gray-700 rounded-lg p-4 mb-6">
+                        <h2 class="text-lg font-medium text-gray-900 dark:text-white mb-2">How it works</h2>
+                        <p class="text-gray-600 dark:text-gray-300 mb-4">
+                            Watch a short advertisement to earn credits that you can use to generate content with our AI tools.
+                        </p>
+                        <ul class="list-disc list-inside text-gray-600 dark:text-gray-300 mb-4">
+                            <li>Complete the ad to earn {{ tool.cost }} credits</li>
+                            <li>You will be redirected back to the tool automatically</li>
+                            <li>Your credits will be available immediately</li>
+                        </ul>
+                    </div>
+                    
+                    <!-- Ad Container -->
+                    <div id="ad-container" class="bg-gray-100 dark:bg-gray-700 rounded-lg overflow-hidden relative">
+                        <div id="ad-placeholder" class="flex flex-col items-center justify-center p-10 text-center">
+                            <div class="mb-4">
+                                <svg class="w-16 h-16 text-gray-400 dark:text-gray-500 mx-auto" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M14.752 11.168l-3.197-2.132A1 1 0 0010 9.87v4.263a1 1 0 001.555.832l3.197-2.132a1 1 0 000-1.664z"></path>
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 12a9 9 0 11-18 0 9 9 0 0118 0z"></path>
+                                </svg>
+                            </div>
+                            <p class="text-gray-600 dark:text-gray-300 mb-6">Loading advertisement...</p>
+                            <button id="start-ad-btn" class="px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2">
+                                Start Watching
+                            </button>
+                        </div>
+                        
+                        <div id="ad-content" class="hidden">
+                            <!-- This is where the actual ad will be displayed -->
+                            {% if reward_ad and reward_ad.success %}
+                                {{ reward_ad.ad_code|safe }}
+                            {% else %}
+                                <div class="p-6 text-center">
+                                    <p class="text-red-500">Sorry, no ads are available at the moment. Please try again later.</p>
+                                </div>
+                            {% endif %}
+                        </div>
+                        
+                        <div id="ad-completed" class="hidden flex flex-col items-center justify-center p-10 text-center">
+                            <div class="mb-4">
+                                <svg class="w-16 h-16 text-green-500 mx-auto" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"></path>
+                                </svg>
+                            </div>
+                            <h3 class="text-xl font-medium text-gray-900 dark:text-white mb-2">Thank You!</h3>
+                            <p class="text-gray-600 dark:text-gray-300 mb-6">
+                                You've earned <span class="font-bold text-green-500">{{ tool.cost }} credits</span>
+                            </p>
+                            <a href="{{ return_url }}" class="px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2">
+                                Return to Tool
+                            </a>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="w-full lg:w-1/3">
+                    <div class="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg p-4 mb-6">
+                        <h2 class="text-lg font-medium text-gray-900 dark:text-white mb-2">Your Balance</h2>
+                        <div class="flex items-center justify-between">
+                            <div class="flex items-center">
+                                <svg class="w-6 h-6 text-yellow-500 mr-2" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg">
+                                    <path d="M8.433 7.418c.155-.103.346-.196.567-.267v1.698a2.305 2.305 0 01-.567-.267C8.07 8.34 8 8.114 8 8c0-.114.07-.34.433-.582zM11 12.849v-1.698c.22.071.412.164.567.267.364.243.433.468.433.582 0 .114-.07.34-.433.582a2.305 2.305 0 01-.567.267z"></path>
+                                    <path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm1-13a1 1 0 10-2 0v.092a4.535 4.535 0 00-1.676.662C6.602 6.234 6 7.009 6 8c0 .99.602 1.765 1.324 2.246.48.32 1.054.545 1.676.662v1.941c-.391-.127-.68-.317-.843-.504a1 1 0 10-1.51 1.31c.562.649 1.413 1.076 2.353 1.253V15a1 1 0 102 0v-.092a4.535 4.535 0 001.676-.662C13.398 13.766 14 12.991 14 12c0-.99-.602-1.765-1.324-2.246A4.535 4.535 0 0011 9.092V7.151c.391.127.68.317.843.504a1 1 0 101.511-1.31c-.563-.649-1.413-1.076-2.354-1.253V5z" clip-rule="evenodd"></path>
+                                </svg>
+                                <span class="text-gray-900 dark:text-white font-semibold" id="current-credits">{{ user_credits }}</span>
+                            </div>
+                            <div>
+                                <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-blue-100 text-blue-800 dark:bg-blue-800 dark:text-blue-100">
+                                    Credits
+                                </span>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <!-- Tool info -->
+                    <div class="bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-lg p-4">
+                        <h2 class="text-lg font-medium text-gray-900 dark:text-white mb-2">Tool Information</h2>
+                        <div class="flex items-center mb-2">
+                            <span class="text-gray-600 dark:text-gray-300">{{ tool.name }}</span>
+                        </div>
+                        <div class="flex items-center mb-2">
+                            <span class="text-gray-600 dark:text-gray-300 mr-2">Cost:</span>
+                            <span class="font-semibold text-gray-900 dark:text-white">{{ tool.cost }} credits</span>
+                        </div>
+                        <p class="text-gray-600 dark:text-gray-300 text-sm">
+                            {{ tool.description }}
+                        </p>
+                    </div>
+                    
+                    <!-- Sidebar ad -->
+                    <div class="mt-6">
+                        {% if sidebar_ad and sidebar_ad.success %}
+                            {{ sidebar_ad.ad_code|safe }}
+                        {% endif %}
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+    // Set up variables from Jinja templates
+    var toolId = "{{ tool.id }}";
+    var returnUrl = "{{ return_url }}";
+    {% if reward_ad and reward_ad.success %}
+    var hasRewardAd = true;
+    var impressionId = "{{ reward_ad.impression_id }}";
+    {% else %}
+    var hasRewardAd = false;
+    var impressionId = null;
+    {% endif %}
+    
+    // Get DOM elements
+    var adContainer = document.getElementById('ad-container');
+    var adPlaceholder = document.getElementById('ad-placeholder');
+    var adContent = document.getElementById('ad-content');
+    var adCompleted = document.getElementById('ad-completed');
+    var startAdBtn = document.getElementById('start-ad-btn');
+    var currentCredits = document.getElementById('current-credits');
+    
+    // Set up event listener for ad start button
+    startAdBtn.addEventListener('click', function() {
+        adPlaceholder.classList.add('hidden');
+        adContent.classList.remove('hidden');
+        
+        // Simulate ad completion after a delay
+        var adDuration = hasRewardAd ? 5000 : 3000;
+        setTimeout(function() {
+            completeAd(impressionId);
+        }, adDuration);
+    });
+    
+    // Handle ad completion
+    function completeAd(adImpressionId) {
+        // Hide ad content
+        adContent.classList.add('hidden');
+        
+        // Show loading spinner
+        var loadingEl = document.createElement('div');
+        loadingEl.className = 'flex justify-center items-center p-10';
+        loadingEl.innerHTML = 
+            '<svg class="animate-spin h-10 w-10 text-blue-600" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">' +
+                '<circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>' +
+                '<path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>' +
+            '</svg>';
+        adContainer.appendChild(loadingEl);
+        
+        // Send completion to server
+        fetch('/api/ads/complete', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                ad_type: 'reward_video',
+                impression_id: adImpressionId,
+                tool_id: toolId
+            })
+        })
+        .then(function(response) { 
+            return response.json(); 
+        })
+        .then(function(data) {
+            // Remove loading spinner
+            adContainer.removeChild(loadingEl);
+            
+            if (data.success) {
+                // Update credits display
+                if (currentCredits) {
+                    currentCredits.textContent = data.current_credits;
+                }
+                
+                // Also update header credits if available
+                var headerCredits = document.getElementById('user-credits');
+                if (headerCredits) {
+                    headerCredits.textContent = data.current_credits;
+                }
+                
+                // Show completion message
+                adCompleted.classList.remove('hidden');
+                
+                // Show success toast
+                showToast('You earned ' + data.credits_earned + ' credits!', 'success');
+                
+                // Redirect after delay if auto-redirect is enabled
+                setTimeout(function() {
+                    window.location.href = returnUrl;
+                }, 3000);
+            } else {
+                // Show error message
+                showToast('Error: ' + data.error, 'error');
+                adPlaceholder.classList.remove('hidden');
+                startAdBtn.textContent = 'Try Again';
+            }
+        })
+        .catch(function(error) {
+            console.error('Error:', error);
+            // Remove loading spinner
+            adContainer.removeChild(loadingEl);
+            // Show error message
+            showToast('Network error, please try again', 'error');
+            adPlaceholder.classList.remove('hidden');
+            startAdBtn.textContent = 'Try Again';
+        });
+    }
+</script>
+{% endblock %} 

templates/admin_dashboard.html

@@ -0,0 +1,238 @@
+{% extends "base.html" %}
+
+{% block title %}Admin Dashboard{% endblock %}
+
+{% block content %}
+<div class="max-w-7xl mx-auto py-8 px-4 sm:px-6 lg:px-8">
+    <div class="mb-8">
+        <h1 class="text-2xl font-bold text-gray-900 dark:text-white">Admin Dashboard</h1>
+        <p class="text-gray-600 dark:text-gray-400">Manage users and credits</p>
+    </div>
+    
+    <div class="mb-8 grid grid-cols-1 md:grid-cols-3 gap-6">
+        <div class="bg-white dark:bg-gray-800 overflow-hidden shadow rounded-lg">
+            <div class="px-4 py-5 sm:px-6">
+                <h3 class="text-lg font-medium text-gray-900 dark:text-white">User Statistics</h3>
+            </div>
+            <div class="px-4 py-5 sm:p-6">
+                <dl>
+                    <div class="mb-4">
+                        <dt class="text-sm font-medium text-gray-500 dark:text-gray-400">Total Users</dt>
+                        <dd class="mt-1 text-3xl font-semibold text-gray-900 dark:text-white">{{ total_users }}</dd>
+                    </div>
+                    <div class="mb-4">
+                        <dt class="text-sm font-medium text-gray-500 dark:text-gray-400">Admin Users</dt>
+                        <dd class="mt-1 text-3xl font-semibold text-gray-900 dark:text-white">{{ admin_count }}</dd>
+                    </div>
+                    <div>
+                        <dt class="text-sm font-medium text-gray-500 dark:text-gray-400">Total Credits Issued</dt>
+                        <dd class="mt-1 text-3xl font-semibold text-gray-900 dark:text-white">{{ total_credits }}</dd>
+                    </div>
+                </dl>
+            </div>
+        </div>
+        
+        <div class="bg-white dark:bg-gray-800 overflow-hidden shadow rounded-lg md:col-span-2">
+            <div class="px-4 py-5 sm:px-6">
+                <h3 class="text-lg font-medium text-gray-900 dark:text-white">Quick Actions</h3>
+            </div>
+            <div class="px-4 py-5 sm:p-6">
+                <div class="grid grid-cols-1 gap-4 sm:grid-cols-2">
+                    <button id="addCreditsAllBtn" class="bg-blue-600 text-white px-4 py-2 rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2">
+                        Add Credits to All Users
+                    </button>
+                    <button id="addNewUserBtn" class="bg-green-600 text-white px-4 py-2 rounded-md hover:bg-green-700 focus:outline-none focus:ring-2 focus:ring-green-500 focus:ring-offset-2">
+                        Add New User
+                    </button>
+                    <button id="clearSessionsBtn" class="bg-yellow-600 text-white px-4 py-2 rounded-md hover:bg-yellow-700 focus:outline-none focus:ring-2 focus:ring-yellow-500 focus:ring-offset-2">
+                        Clear Expired Sessions
+                    </button>
+                    <button id="resetCreditsBtn" class="bg-red-600 text-white px-4 py-2 rounded-md hover:bg-red-700 focus:outline-none focus:ring-2 focus:ring-red-500 focus:ring-offset-2">
+                        Reset All Credits
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <div class="bg-white dark:bg-gray-800 shadow overflow-hidden sm:rounded-md">
+        <div class="px-4 py-5 sm:px-6 flex justify-between items-center">
+            <h3 class="text-lg font-medium text-gray-900 dark:text-white">User Management</h3>
+            <div class="relative">
+                <input type="text" id="userSearch" placeholder="Search users..." class="border border-gray-300 dark:border-gray-600 rounded-md px-4 py-2 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 dark:bg-gray-700 dark:text-white">
+            </div>
+        </div>
+        <div class="overflow-x-auto">
+            <table class="min-w-full divide-y divide-gray-200 dark:divide-gray-700">
+                <thead class="bg-gray-50 dark:bg-gray-700">
+                    <tr>
+                        <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">
+                            User
+                        </th>
+                        <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">
+                            Role
+                        </th>
+                        <th scope="col" class="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">
+                            Credits
+                        </th>
+                        <th scope="col" class="px-6 py-3 text-right text-xs font-medium text-gray-500 dark:text-gray-300 uppercase tracking-wider">
+                            Actions
+                        </th>
+                    </tr>
+                </thead>
+                <tbody class="bg-white dark:bg-gray-800 divide-y divide-gray-200 dark:divide-gray-700" id="userTable">
+                    {% for user in users %}
+                    <tr class="user-row" data-user-id="{{ user.id }}">
+                        <td class="px-6 py-4 whitespace-nowrap">
+                            <div>
+                                <div class="text-sm font-medium text-gray-900 dark:text-white">
+                                    {{ user.username }}
+                                </div>
+                                <div class="text-sm text-gray-500 dark:text-gray-400">
+                                    {{ user.email }}
+                                </div>
+                            </div>
+                        </td>
+                        <td class="px-6 py-4 whitespace-nowrap">
+                            <span class="px-2 inline-flex text-xs leading-5 font-semibold rounded-full {% if user.role == 'admin' %}bg-purple-100 text-purple-800 dark:bg-purple-800 dark:text-purple-100{% else %}bg-green-100 text-green-800 dark:bg-green-800 dark:text-green-100{% endif %}">
+                                {{ user.role }}
+                            </span>
+                        </td>
+                        <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500 dark:text-gray-400">
+                            <span class="credits-display">{{ user.credits }}</span>
+                            <div class="edit-credits hidden">
+                                <input type="number" class="credits-input w-20 border border-gray-300 dark:border-gray-600 rounded p-1 dark:bg-gray-700 dark:text-white" value="{{ user.credits }}">
+                                <button class="save-credits ml-2 text-xs bg-blue-600 text-white px-2 py-1 rounded">Save</button>
+                            </div>
+                        </td>
+                        <td class="px-6 py-4 whitespace-nowrap text-right text-sm font-medium">
+                            <button class="text-blue-600 dark:text-blue-400 hover:text-blue-900 dark:hover:text-blue-300 edit-credits-btn">
+                                Edit Credits
+                            </button>
+                            <span class="mx-2 text-gray-300 dark:text-gray-600">|</span>
+                            <button class="text-red-600 dark:text-red-400 hover:text-red-900 dark:hover:text-red-300 delete-user-btn" {% if user.role == 'admin' %}disabled{% endif %}>
+                                {% if user.role == 'admin' %}Admin{% else %}Delete{% endif %}
+                            </button>
+                        </td>
+                    </tr>
+                    {% endfor %}
+                </tbody>
+            </table>
+        </div>
+    </div>
+</div>
+
+<!-- Modal for adding credits to all users -->
+<div id="addCreditsModal" class="fixed inset-0 bg-black bg-opacity-50 hidden items-center justify-center z-50">
+    <div class="bg-white dark:bg-gray-800 rounded-lg p-6 max-w-md w-full mx-4">
+        <h3 class="text-xl font-semibold mb-4 text-gray-900 dark:text-white">Add Credits to All Users</h3>
+        <div class="mb-4">
+            <label for="creditsAmount" class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">Credits to add:</label>
+            <input type="number" id="creditsAmount" class="w-full border border-gray-300 dark:border-gray-600 rounded-md px-4 py-2 dark:bg-gray-700 dark:text-white" value="100">
+        </div>
+        <div class="flex justify-end space-x-4">
+            <button id="cancelAddCredits" class="text-gray-500 dark:text-gray-400 hover:text-gray-700 dark:hover:text-gray-200">
+                Cancel
+            </button>
+            <button id="confirmAddCredits" class="bg-blue-600 text-white px-4 py-2 rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2">
+                Add Credits
+            </button>
+        </div>
+    </div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+    // Search functionality
+    document.getElementById('userSearch').addEventListener('input', function(e) {
+        const searchTerm = e.target.value.toLowerCase();
+        const rows = document.querySelectorAll('.user-row');
+        
+        rows.forEach(row => {
+            const username = row.querySelector('.text-sm.font-medium').textContent.toLowerCase();
+            const email = row.querySelector('.text-sm.text-gray-500').textContent.toLowerCase();
+            
+            if (username.includes(searchTerm) || email.includes(searchTerm)) {
+                row.style.display = '';
+            } else {
+                row.style.display = 'none';
+            }
+        });
+    });
+    
+    // Edit credits functionality
+    document.querySelectorAll('.edit-credits-btn').forEach(btn => {
+        btn.addEventListener('click', function() {
+            const row = this.closest('tr');
+            const creditsDisplay = row.querySelector('.credits-display');
+            const editCredits = row.querySelector('.edit-credits');
+            
+            creditsDisplay.classList.toggle('hidden');
+            editCredits.classList.toggle('hidden');
+            
+            if (!editCredits.classList.contains('hidden')) {
+                editCredits.querySelector('input').focus();
+            }
+        });
+    });
+    
+    // Save credits functionality
+    document.querySelectorAll('.save-credits').forEach(btn => {
+        btn.addEventListener('click', function() {
+            const row = this.closest('tr');
+            const userId = row.dataset.userId;
+            const newCredits = parseFloat(row.querySelector('.credits-input').value);
+            const creditsDisplay = row.querySelector('.credits-display');
+            const editCredits = row.querySelector('.edit-credits');
+            
+            fetch('/api/admin/update-credits', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    user_id: userId,
+                    credits: newCredits
+                })
+            })
+            .then(response => response.json())
+            .then(data => {
+                if (data.success) {
+                    creditsDisplay.textContent = newCredits;
+                    creditsDisplay.classList.toggle('hidden');
+                    editCredits.classList.toggle('hidden');
+                    showToast(data.message, 'success');
+                } else {
+                    showToast('Error: ' + data.error, 'error');
+                }
+            })
+            .catch(error => {
+                console.error('Error:', error);
+                showToast('Failed to update credits', 'error');
+            });
+        });
+    });
+    
+    // Modal functionality
+    const addCreditsModal = document.getElementById('addCreditsModal');
+    
+    document.getElementById('addCreditsAllBtn').addEventListener('click', function() {
+        addCreditsModal.classList.remove('hidden');
+        addCreditsModal.classList.add('flex');
+    });
+    
+    document.getElementById('cancelAddCredits').addEventListener('click', function() {
+        addCreditsModal.classList.add('hidden');
+        addCreditsModal.classList.remove('flex');
+    });
+    
+    // Close modal when clicking outside
+    addCreditsModal.addEventListener('click', function(e) {
+        if (e.target === addCreditsModal) {
+            addCreditsModal.classList.add('hidden');
+            addCreditsModal.classList.remove('flex');
+        }
+    });
+</script>
+{% endblock %} 

templates/base.html

@@ -0,0 +1,217 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{ app_name }} - {% block title %}{% endblock %}</title>
+    
+    <!-- Tailwind CSS -->
+    <script src="https://cdn.tailwindcss.com"></script>
+    
+    <!-- Custom CSS -->
+    <style>
+        /* Dark mode styles */
+        @media (prefers-color-scheme: dark) {
+            body {
+                background-color: #1a1a1a;
+                color: #ffffff;
+            }
+        }
+        
+        /* Custom scrollbar */
+        ::-webkit-scrollbar {
+            width: 8px;
+            height: 8px;
+        }
+        
+        ::-webkit-scrollbar-track {
+            background: #f1f1f1;
+        }
+        
+        ::-webkit-scrollbar-thumb {
+            background: #888;
+            border-radius: 4px;
+        }
+        
+        ::-webkit-scrollbar-thumb:hover {
+            background: #555;
+        }
+        
+        /* Dark mode scrollbar */
+        @media (prefers-color-scheme: dark) {
+            ::-webkit-scrollbar-track {
+                background: #2d2d2d;
+            }
+            
+            ::-webkit-scrollbar-thumb {
+                background: #666;
+            }
+            
+            ::-webkit-scrollbar-thumb:hover {
+                background: #888;
+            }
+        }
+        
+        /* Toast notifications */
+        .toast {
+            position: fixed;
+            bottom: 20px;
+            right: 20px;
+            padding: 12px 24px;
+            border-radius: 4px;
+            color: white;
+            font-weight: 500;
+            z-index: 1000;
+            animation: slideIn 0.3s ease-out;
+        }
+        
+        .toast.success {
+            background-color: #10B981;
+        }
+        
+        .toast.error {
+            background-color: #EF4444;
+        }
+        
+        @keyframes slideIn {
+            from {
+                transform: translateX(100%);
+                opacity: 0;
+            }
+            to {
+                transform: translateX(0);
+                opacity: 1;
+            }
+        }
+    </style>
+</head>
+<body class="bg-gray-50 dark:bg-gray-900 min-h-screen">
+    <!-- Navigation -->
+    <nav class="bg-white dark:bg-gray-800 shadow-sm">
+        <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+            <div class="flex justify-between h-16">
+                <div class="flex">
+                    <!-- Logo -->
+                    <div class="flex-shrink-0 flex items-center">
+                        <a href="/" class="text-xl font-bold text-blue-600 dark:text-blue-400">
+                            {{ app_name }}
+                        </a>
+                    </div>
+                    
+                    <!-- Navigation Links -->
+                    <div class="hidden sm:ml-6 sm:flex sm:space-x-8">
+                        <a href="/" class="inline-flex items-center px-1 pt-1 text-sm font-medium text-gray-900 dark:text-white">
+                            Home
+                        </a>
+                        <a href="/tools" class="inline-flex items-center px-1 pt-1 text-sm font-medium text-gray-500 dark:text-gray-400 hover:text-gray-900 dark:hover:text-white">
+                            Tools
+                        </a>
+                        <a href="/credits" class="inline-flex items-center px-1 pt-1 text-sm font-medium text-gray-500 dark:text-gray-400 hover:text-gray-900 dark:hover:text-white">
+                            Credits
+                        </a>
+                    </div>
+                </div>
+                
+                <!-- User Menu -->
+                <div class="flex items-center">
+                    <div class="flex items-center space-x-4">
+                        {% if user %}
+                        <span class="text-sm text-gray-700 dark:text-gray-300">
+                            Credits: <span id="user-credits">{{ user_credits }}</span>
+                        </span>
+                        <div class="relative">
+                            <button id="user-menu-button" class="flex items-center text-sm text-gray-700 dark:text-gray-300 hover:text-gray-900 dark:hover:text-white">
+                                <span class="mr-2">{{ user.username }}</span>
+                                <svg class="h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"/>
+                                </svg>
+                            </button>
+                            <div id="user-dropdown" class="hidden absolute right-0 mt-2 w-48 bg-white dark:bg-gray-800 rounded-md shadow-lg py-1 z-10">
+                                <a href="/profile" class="block px-4 py-2 text-sm text-gray-700 dark:text-gray-300 hover:bg-gray-100 dark:hover:bg-gray-700">Profile</a>
+                                <a href="/credits" class="block px-4 py-2 text-sm text-gray-700 dark:text-gray-300 hover:bg-gray-100 dark:hover:bg-gray-700">Add Credits</a>
+                                <a href="/logout" class="block px-4 py-2 text-sm text-gray-700 dark:text-gray-300 hover:bg-gray-100 dark:hover:bg-gray-700">Logout</a>
+                            </div>
+                        </div>
+                        {% else %}
+                        <a href="/login" class="inline-flex items-center px-4 py-2 text-sm font-medium text-white bg-blue-600 border border-transparent rounded-md shadow-sm hover:bg-blue-700">
+                            Login
+                        </a>
+                        <a href="/register" class="inline-flex items-center px-4 py-2 text-sm font-medium text-blue-600 dark:text-blue-400 bg-white dark:bg-gray-800 border border-blue-600 dark:border-blue-400 rounded-md shadow-sm hover:bg-gray-50 dark:hover:bg-gray-700">
+                            Register
+                        </a>
+                        {% endif %}
+                    </div>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <!-- Main Content -->
+    <div class="flex">
+        <!-- Sidebar -->
+        <div class="w-64 bg-white dark:bg-gray-800 shadow-sm h-screen fixed">
+            <div class="p-4">
+                <h2 class="text-lg font-semibold text-gray-900 dark:text-white mb-4">Tools</h2>
+                <nav class="space-y-1">
+                    {% for tool in tools %}
+                    <a href="/tools/{{ tool.id }}" class="flex items-center px-4 py-2 text-sm font-medium text-gray-700 dark:text-gray-300 hover:bg-gray-100 dark:hover:bg-gray-700 rounded-lg">
+                        <span class="mr-3">{{ tool.icon }}</span>
+                        {{ tool.name }}
+                    </a>
+                    {% endfor %}
+                </nav>
+            </div>
+        </div>
+
+        <!-- Page Content -->
+        <div class="flex-1 ml-64">
+            {% block content %}{% endblock %}
+        </div>
+    </div>
+
+    <!-- Toast Container -->
+    <div id="toast-container"></div>
+
+    <!-- Common JavaScript -->
+    <script>
+        // Show toast notification
+        function showToast(message, type = 'success') {
+            const container = document.getElementById('toast-container');
+            const toast = document.createElement('div');
+            toast.className = `toast ${type}`;
+            toast.textContent = message;
+            container.appendChild(toast);
+
+            setTimeout(() => {
+                toast.remove();
+            }, 3000);
+        }
+
+        // User menu toggle
+        const userMenuButton = document.getElementById('user-menu-button');
+        const userDropdown = document.getElementById('user-dropdown');
+        
+        if (userMenuButton && userDropdown) {
+            userMenuButton.addEventListener('click', function() {
+                userDropdown.classList.toggle('hidden');
+            });
+            
+            // Close the dropdown when clicking outside
+            document.addEventListener('click', function(event) {
+                if (!userMenuButton.contains(event.target) && !userDropdown.contains(event.target)) {
+                    userDropdown.classList.add('hidden');
+                }
+            });
+        }
+
+        // Dark mode toggle
+        if (localStorage.theme === 'dark' || (!('theme' in localStorage) && window.matchMedia('(prefers-color-scheme: dark)').matches)) {
+            document.documentElement.classList.add('dark');
+        } else {
+            document.documentElement.classList.remove('dark');
+        }
+    </script>
+
+    {% block scripts %}{% endblock %}
+</body>
+</html> 

templates/credits.html

@@ -0,0 +1,296 @@
+{% extends "base.html" %}
+
+{% block title %}Credits{% endblock %}
+
+{% block content %}
+<div class="container mx-auto px-4 py-8">
+    <!-- Header -->
+    <div class="flex items-center justify-between mb-8">
+        <div>
+            <h1 class="text-3xl font-bold text-gray-900 dark:text-white">Credits</h1>
+            <p class="mt-2 text-gray-600 dark:text-gray-300">Manage your credits for using AI tools</p>
+        </div>
+        <div class="text-right">
+            <div class="text-2xl font-bold text-blue-600">{{ user_credits }}</div>
+            <div class="text-sm text-gray-500">credits available</div>
+        </div>
+    </div>
+
+    <div class="grid grid-cols-1 lg:grid-cols-2 gap-8">
+        <!-- Earn Credits -->
+        <div class="bg-white dark:bg-gray-800 rounded-lg shadow-lg p-6">
+            <h2 class="text-xl font-semibold text-gray-900 dark:text-white mb-4">Earn Credits</h2>
+            
+            <!-- Daily Rewards -->
+            <div class="mb-6">
+                <h3 class="text-lg font-medium text-gray-900 dark:text-white mb-2">Daily Rewards</h3>
+                <p class="text-gray-600 dark:text-gray-300 mb-4">
+                    Watch ads to earn up to 30 credits per day (3 rewards of 10 credits each)
+                </p>
+                <div class="flex items-center justify-between mb-4">
+                    <div class="text-sm text-gray-500 dark:text-gray-400">
+                        <span id="daily-count">0</span>/3 rewards claimed today
+                    </div>
+                    <div id="daily-cooldown" class="text-sm text-gray-500 dark:text-gray-400 hidden">
+                        Next reward in: <span id="cooldown-timer">5:00</span>
+                    </div>
+                </div>
+                <button id="daily-reward-btn"
+                        class="w-full py-3 px-4 text-sm font-medium text-white bg-blue-600 rounded-lg hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500 disabled:opacity-50 disabled:cursor-not-allowed">
+                    Watch Ad for 10 Credits
+                </button>
+            </div>
+
+            <!-- Special Reward -->
+            <div class="mb-6">
+                <h3 class="text-lg font-medium text-gray-900 dark:text-white mb-2">Special Reward</h3>
+                <p class="text-gray-600 dark:text-gray-300 mb-4">
+                    Watch a longer ad to earn 25 bonus credits (available once per day)
+                </p>
+                <button id="special-reward-btn"
+                        class="w-full py-3 px-4 text-sm font-medium text-white bg-purple-600 rounded-lg hover:bg-purple-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-purple-500 disabled:opacity-50 disabled:cursor-not-allowed">
+                    Watch Special Ad for 25 Credits
+                </button>
+            </div>
+
+            <!-- Referral Program -->
+            <div>
+                <h3 class="text-lg font-medium text-gray-900 dark:text-white mb-2">Referral Program</h3>
+                <p class="text-gray-600 dark:text-gray-300 mb-4">
+                    Invite friends to earn 50 credits for each referral
+                </p>
+                <div class="flex items-center space-x-4">
+                    <input type="text" id="referral-link" 
+                           value="{{ referral_link }}" 
+                           class="flex-1 px-4 py-2 text-gray-900 dark:text-white bg-white dark:bg-gray-800 border border-gray-300 dark:border-gray-600 rounded-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
+                           readonly>
+                    <button id="copy-referral" 
+                            class="px-4 py-2 text-sm font-medium text-white bg-green-600 rounded-lg hover:bg-green-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-green-500">
+                        Copy
+                    </button>
+                </div>
+            </div>
+        </div>
+
+        <!-- Purchase Credits -->
+        <div class="bg-white dark:bg-gray-800 rounded-lg shadow-lg p-6">
+            <h2 class="text-xl font-semibold text-gray-900 dark:text-white mb-4">Purchase Credits</h2>
+            
+            <!-- Credit Packages -->
+            <div class="space-y-4">
+                {% for package in credit_packages %}
+                <div class="border border-gray-200 dark:border-gray-700 rounded-lg p-4">
+                    <div class="flex items-center justify-between mb-2">
+                        <div>
+                            <h3 class="text-lg font-medium text-gray-900 dark:text-white">{{ package.name }}</h3>
+                            <p class="text-sm text-gray-500 dark:text-gray-400">{{ package.description }}</p>
+                        </div>
+                        <div class="text-right">
+                            <div class="text-xl font-bold text-blue-600">${{ package.price }}</div>
+                            <div class="text-sm text-gray-500">{{ package.credits }} credits</div>
+                        </div>
+                    </div>
+                    <button onclick="purchaseCredits('{{ package.id }}')"
+                            class="w-full py-2 px-4 text-sm font-medium text-white bg-blue-600 rounded-lg hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500">
+                        Purchase
+                    </button>
+                </div>
+                {% endfor %}
+            </div>
+
+            <!-- Payment Methods -->
+            <div class="mt-6">
+                <h3 class="text-sm font-medium text-gray-900 dark:text-white mb-2">Accepted Payment Methods</h3>
+                <div class="flex items-center space-x-4">
+                    <svg class="h-8 w-8 text-gray-400" fill="currentColor" viewBox="0 0 24 24">
+                        <path d="M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z"/>
+                    </svg>
+                    <svg class="h-8 w-8 text-gray-400" fill="currentColor" viewBox="0 0 24 24">
+                        <path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8z"/>
+                    </svg>
+                    <svg class="h-8 w-8 text-gray-400" fill="currentColor" viewBox="0 0 24 24">
+                        <path d="M20 4H4c-1.11 0-1.99.89-1.99 2L2 18c0 1.11.89 2 2 2h16c1.11 0 2-.89 2-2V6c0-1.11-.89-2-2-2zm0 14H4v-6h16v6zm0-10H4V6h16v2z"/>
+                    </svg>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Credit History -->
+    <div class="mt-8">
+        <h2 class="text-xl font-semibold text-gray-900 dark:text-white mb-4">Credit History</h2>
+        <div class="bg-white dark:bg-gray-800 rounded-lg shadow-lg overflow-hidden">
+            <div class="overflow-x-auto">
+                <table class="min-w-full divide-y divide-gray-200 dark:divide-gray-700">
+                    <thead class="bg-gray-50 dark:bg-gray-700">
+                        <tr>
+                            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">Date</th>
+                            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">Type</th>
+                            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">Amount</th>
+                            <th class="px-6 py-3 text-left text-xs font-medium text-gray-500 dark:text-gray-400 uppercase tracking-wider">Details</th>
+                        </tr>
+                    </thead>
+                    <tbody class="bg-white dark:bg-gray-800 divide-y divide-gray-200 dark:divide-gray-700">
+                        {% for transaction in credit_history %}
+                        <tr>
+                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-900 dark:text-white">
+                                {{ transaction.date }}
+                            </td>
+                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-900 dark:text-white">
+                                {{ transaction.type }}
+                            </td>
+                            <td class="px-6 py-4 whitespace-nowrap text-sm {% if transaction.amount > 0 %}text-green-600{% else %}text-red-600{% endif %}">
+                                {{ transaction.amount }}
+                            </td>
+                            <td class="px-6 py-4 whitespace-nowrap text-sm text-gray-500 dark:text-gray-400">
+                                {{ transaction.details }}
+                            </td>
+                        </tr>
+                        {% endfor %}
+                    </tbody>
+                </table>
+            </div>
+        </div>
+    </div>
+</div>
+
+<!-- Ad Modal -->
+<div id="ad-modal" class="fixed inset-0 bg-black bg-opacity-50 hidden items-center justify-center">
+    <div class="bg-white dark:bg-gray-800 rounded-lg p-6 max-w-lg w-full mx-4">
+        <div class="flex justify-between items-center mb-4">
+            <h2 class="text-xl font-semibold">Watch Ad</h2>
+            <button id="close-ad-modal" class="text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200">
+                <svg class="h-6 w-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"/>
+                </svg>
+            </button>
+        </div>
+
+        <!-- Ad Container -->
+        <div id="ad-container" class="aspect-video bg-gray-100 dark:bg-gray-700 rounded-lg mb-4 flex items-center justify-center">
+            <div class="text-center">
+                <div class="text-2xl font-bold text-gray-400 mb-2" id="ad-countdown">30</div>
+                <div class="text-sm text-gray-500">seconds remaining</div>
+            </div>
+        </div>
+
+        <!-- Progress Bar -->
+        <div class="w-full bg-gray-200 dark:bg-gray-700 rounded-full h-2.5 mb-4">
+            <div id="ad-progress" class="bg-blue-600 h-2.5 rounded-full" style="width: 0%"></div>
+        </div>
+
+        <!-- Status Message -->
+        <div id="ad-status" class="text-center text-sm text-gray-500 dark:text-gray-400">
+            Please watch the ad to earn your reward
+        </div>
+    </div>
+</div>
+
+<script>
+document.addEventListener('DOMContentLoaded', function() {
+    const dailyBtn = document.getElementById('daily-reward-btn');
+    const specialBtn = document.getElementById('special-reward-btn');
+    const adModal = document.getElementById('ad-modal');
+    const closeAdModal = document.getElementById('close-ad-modal');
+    const copyReferralBtn = document.getElementById('copy-referral');
+    const referralLink = document.getElementById('referral-link');
+
+    // Load reward status
+    loadRewardStatus();
+
+    // Set up event listeners
+    dailyBtn.addEventListener('click', () => showAdModal('daily'));
+    specialBtn.addEventListener('click', () => showAdModal('special'));
+    closeAdModal.addEventListener('click', hideAdModal);
+    copyReferralBtn.addEventListener('click', copyReferralLink);
+
+    // Load reward status
+    async function loadRewardStatus() {
+        try {
+            const response = await fetch('/api/ads/status');
+            const data = await response.json();
+
+            if (data.success) {
+                updateDailyRewardStatus(data.daily_rewards);
+                updateSpecialRewardStatus(data.special_reward);
+            }
+        } catch (error) {
+            console.error('Error loading reward status:', error);
+        }
+    }
+
+    // Update daily reward status
+    function updateDailyRewardStatus(status) {
+        const dailyCount = document.getElementById('daily-count');
+        const cooldownDiv = document.getElementById('daily-cooldown');
+        const cooldownTimer = document.getElementById('cooldown-timer');
+
+        dailyCount.textContent = status.count;
+
+        if (status.can_claim) {
+            dailyBtn.disabled = false;
+            cooldownDiv.classList.add('hidden');
+        } else {
+            dailyBtn.disabled = true;
+            cooldownDiv.classList.remove('hidden');
+            updateCooldownTimer(status.cooldown_remaining);
+        }
+    }
+
+    // Update special reward status
+    function updateSpecialRewardStatus(status) {
+        specialBtn.disabled = !status.can_claim;
+    }
+
+    // Show ad modal
+    function showAdModal(type) {
+        currentRewardType = type;
+        adModal.classList.remove('hidden');
+        adModal.classList.add('flex');
+        startAdTimer();
+    }
+
+    // Hide ad modal
+    function hideAdModal() {
+        adModal.classList.add('hidden');
+        adModal.classList.remove('flex');
+        stopAdTimer();
+        resetAdProgress();
+    }
+
+    // Copy referral link
+    function copyReferralLink() {
+        referralLink.select();
+        document.execCommand('copy');
+        showToast('Referral link copied to clipboard!', 'success');
+    }
+
+    // Purchase credits
+    window.purchaseCredits = async function(packageId) {
+        try {
+            const response = await fetch('/api/credits/purchase', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    package_id: packageId
+                })
+            });
+
+            const data = await response.json();
+
+            if (data.success) {
+                // Redirect to payment page
+                window.location.href = data.payment_url;
+            } else {
+                showToast(data.error || 'Failed to initiate purchase', 'error');
+            }
+        } catch (error) {
+            console.error('Error purchasing credits:', error);
+            showToast('Failed to initiate purchase', 'error');
+        }
+    };
+});
+</script>
+{% endblock %} 

templates/error.html

@@ -0,0 +1,87 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{ app_name }} - Error</title>
+    <link rel="stylesheet" href="{{ url_for('static', path='/css/styles.css') }}">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+</head>
+<body>
+    <div class="app-container">
+        <!-- Sidebar -->
+        <div class="sidebar">
+            <div class="sidebar-header">
+                <h1>{{ app_name }}</h1>
+                <div class="sidebar-subtitle">AI Toolkit</div>
+            </div>
+            
+            <!-- Credits Section -->
+            <div class="sidebar-section">
+                <div class="credit-display">
+                    <div class="credit-icon">
+                        <i class="fas fa-coins"></i>
+                    </div>
+                    <div>
+                        <div class="credit-label">Your Credits</div>
+                        <div class="credit-value">{{ user_credits }}</div>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- Navigation -->
+            <div class="sidebar-section">
+                <div class="sidebar-heading">Navigation</div>
+                <a href="/" class="nav-item">
+                    <div class="nav-icon"><i class="fas fa-home"></i></div>
+                    <div>Home</div>
+                </a>
+                <a href="#" class="nav-item">
+                    <div class="nav-icon"><i class="fas fa-history"></i></div>
+                    <div>History</div>
+                </a>
+                <a href="#" class="nav-item">
+                    <div class="nav-icon"><i class="fas fa-coins"></i></div>
+                    <div>Buy Credits</div>
+                </a>
+            </div>
+            
+            <!-- Tools -->
+            <div class="sidebar-section">
+                <div class="sidebar-heading">Tools</div>
+                {% for tool in tools %}
+                <a href="/tool/{{ tool.id }}" class="nav-item">
+                    <div class="nav-icon"><i class="{{ tool.icon }}"></i></div>
+                    <div>{{ tool.name }}</div>
+                </a>
+                {% endfor %}
+            </div>
+            
+            <div class="sidebar-footer">
+                &copy; {{ app_name }} 2023
+            </div>
+        </div>
+        
+        <!-- Content -->
+        <div class="content">
+            <div class="content-header">
+                <h1>Error</h1>
+                <p>Something went wrong with your request.</p>
+            </div>
+            
+            <div class="error-container">
+                <div class="error-icon">
+                    <i class="fas fa-exclamation-triangle"></i>
+                </div>
+                <h2>{{ error_title if error_title is defined else 'Error Occurred' }}</h2>
+                <p>{{ error_description if error_description is defined else 'An unexpected error occurred while processing your request.' }}</p>
+                
+                <div class="action-buttons">
+                    <a href="/" class="btn btn-primary">Return to Home</a>
+                    <button onclick="history.back()" class="btn btn-secondary">Go Back</button>
+                </div>
+            </div>
+        </div>
+    </div>
+</body>
+</html> 

templates/index.html

@@ -0,0 +1,211 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{ app_name }} - AI Tools Platform</title>
+    <link rel="stylesheet" href="{{ url_for('static', path='/css/styles.css') }}">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <script src="{{ url_for('static', path='/js/main.js') }}" defer></script>
+</head>
+<body>
+    <div class="app-container">
+        <!-- Sidebar -->
+        <div class="sidebar">
+            <div class="sidebar-header">
+                <h1>{{ app_name }}</h1>
+                <div class="sidebar-subtitle">AI Toolkit</div>
+            </div>
+            
+            <!-- User Authentication Section -->
+            <div class="sidebar-section">
+                {% if session_user %}
+                <div class="user-section">
+                    <div class="user-info">
+                        <div class="user-icon">
+                            <i class="fas fa-user-circle"></i>
+                        </div>
+                        <div>
+                            <div class="user-name">{{ session_user.username }}</div>
+                            <div class="user-role">{{ session_user.role }}</div>
+                        </div>
+                    </div>
+                    <div class="user-actions">
+                        <a href="/logout" class="btn btn-small">Logout</a>
+                        {% if session_user.role == "admin" %}
+                        <a href="/admin" class="btn btn-small btn-primary">Admin</a>
+                        {% endif %}
+                    </div>
+                </div>
+                {% else %}
+                <div class="auth-buttons">
+                    <a href="/login" class="btn btn-primary">Login</a>
+                    <a href="/register" class="btn btn-secondary">Register</a>
+                </div>
+                {% endif %}
+            </div>
+            
+            <!-- Credits Section -->
+            <div class="sidebar-section">
+                <div class="credit-display">
+                    <div class="credit-icon">
+                        <i class="fas fa-coins"></i>
+                    </div>
+                    <div>
+                        <div class="credit-label">Your Credits</div>
+                        <div class="credit-value">{{ user_credits }}</div>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- Navigation -->
+            <div class="sidebar-section">
+                <div class="sidebar-heading">Navigation</div>
+                <a href="/" class="nav-item active">
+                    <div class="nav-icon"><i class="fas fa-home"></i></div>
+                    <div>Home</div>
+                </a>
+                <a href="#" class="nav-item">
+                    <div class="nav-icon"><i class="fas fa-history"></i></div>
+                    <div>History</div>
+                </a>
+                <a href="#" class="nav-item">
+                    <div class="nav-icon"><i class="fas fa-coins"></i></div>
+                    <div>Buy Credits</div>
+                </a>
+            </div>
+            
+            <!-- Categories -->
+            <div class="sidebar-section">
+                <div class="sidebar-heading">Categories</div>
+                <a href="#text-tools" class="nav-item" onclick="filterTools('text'); return false;">
+                    <div class="nav-icon"><i class="fas fa-font"></i></div>
+                    <div>Text Generation</div>
+                </a>
+                <a href="#image-tools" class="nav-item" onclick="filterTools('image'); return false;">
+                    <div class="nav-icon"><i class="fas fa-image"></i></div>
+                    <div>Image Generation</div>
+                </a>
+                <a href="#audio-tools" class="nav-item" onclick="filterTools('audio'); return false;">
+                    <div class="nav-icon"><i class="fas fa-music"></i></div>
+                    <div>Audio Tools</div>
+                </a>
+                <a href="#video-tools" class="nav-item" onclick="filterTools('video'); return false;">
+                    <div class="nav-icon"><i class="fas fa-video"></i></div>
+                    <div>Video Tools</div>
+                </a>
+                <a href="#utility-tools" class="nav-item" onclick="filterTools('utility'); return false;">
+                    <div class="nav-icon"><i class="fas fa-tools"></i></div>
+                    <div>Utility Tools</div>
+                </a>
+            </div>
+            
+            <div class="sidebar-footer">
+                &copy; {{ app_name }} 2023
+            </div>
+        </div>
+        
+        <!-- Content -->
+        <div class="content">
+            <div class="content-header">
+                <h1>AI Tools Platform</h1>
+                <p>Select a tool to get started. Each tool requires credits which you can earn by watching ads.</p>
+                
+                <div class="search-container">
+                    <input type="text" id="tool-search" class="search-input" placeholder="Search for tools..." onkeyup="searchTools()">
+                </div>
+            </div>
+            
+            <!-- Tool Grid -->
+            <div class="tools-grid" id="tools-grid">
+                {% for tool in tools %}
+                <a href="/tool/{{ tool.id }}" class="tool-card" data-category="{{ tool.category }}">
+                    <div class="tool-icon">
+                        <i class="{{ tool.icon }}"></i>
+                    </div>
+                    <div class="tool-info">
+                        <h3 class="tool-name">{{ tool.name }}</h3>
+                        <p class="tool-description">{{ tool.description }}</p>
+                        <div class="tool-meta">
+                            <div class="tool-cost">{{ tool.credits }} credits</div>
+                        </div>
+                    </div>
+                </a>
+                {% endfor %}
+            </div>
+            
+            <!-- No Results Message -->
+            <div id="no-results" style="display: none; text-align: center; margin-top: 40px;">
+                <i class="fas fa-search fa-3x" style="opacity: 0.5; margin-bottom: 15px;"></i>
+                <h3>No tools found</h3>
+                <p>Try different search terms or browse all categories</p>
+                <button class="btn btn-secondary" onclick="resetSearch()">Show All Tools</button>
+            </div>
+        </div>
+    </div>
+    
+    <script>
+        // Filter tools by category
+        function filterTools(category) {
+            const toolCards = document.querySelectorAll('.tool-card');
+            const noResults = document.getElementById('no-results');
+            let visibleCount = 0;
+            
+            toolCards.forEach(card => {
+                if (category === 'all' || card.dataset.category === category) {
+                    card.style.display = 'flex';
+                    visibleCount++;
+                } else {
+                    card.style.display = 'none';
+                }
+            });
+            
+            // Update category nav items
+            document.querySelectorAll('.sidebar .nav-item').forEach(item => {
+                if (item.textContent.trim().toLowerCase().includes(category) || 
+                    (category === 'all' && item.textContent.trim() === 'Home')) {
+                    item.classList.add('active');
+                } else {
+                    item.classList.remove('active');
+                }
+            });
+            
+            noResults.style.display = visibleCount === 0 ? 'block' : 'none';
+        }
+        
+        // Search tools
+        function searchTools() {
+            const searchTerm = document.getElementById('tool-search').value.toLowerCase();
+            const toolCards = document.querySelectorAll('.tool-card');
+            const noResults = document.getElementById('no-results');
+            let visibleCount = 0;
+            
+            toolCards.forEach(card => {
+                const name = card.querySelector('.tool-name').textContent.toLowerCase();
+                const description = card.querySelector('.tool-description').textContent.toLowerCase();
+                
+                if (name.includes(searchTerm) || description.includes(searchTerm)) {
+                    card.style.display = 'flex';
+                    visibleCount++;
+                } else {
+                    card.style.display = 'none';
+                }
+            });
+            
+            noResults.style.display = visibleCount === 0 ? 'block' : 'none';
+        }
+        
+        // Reset search
+        function resetSearch() {
+            document.getElementById('tool-search').value = '';
+            filterTools('all');
+        }
+        
+        // Initialize
+        document.addEventListener('DOMContentLoaded', function() {
+            // Set initial active state
+            filterTools('all');
+        });
+    </script>
+</body>
+</html> 

templates/login.html

@@ -0,0 +1,104 @@
+{% extends "base.html" %}
+
+{% block content %}
+<div class="min-h-screen flex items-center justify-center bg-gray-50 dark:bg-gray-900 py-12 px-4 sm:px-6 lg:px-8">
+    <div class="max-w-md w-full space-y-8">
+        <div>
+            <h2 class="mt-6 text-center text-3xl font-extrabold text-gray-900 dark:text-white">
+                Sign in to your account
+            </h2>
+            <p class="mt-2 text-center text-sm text-gray-600 dark:text-gray-400">
+                Or
+                <a href="#" class="font-medium text-blue-600 hover:text-blue-500">
+                    create a new account
+                </a>
+            </p>
+        </div>
+        <form class="mt-8 space-y-6" action="/login" method="POST">
+            <div class="rounded-md shadow-sm -space-y-px">
+                <div>
+                    <label for="username" class="sr-only">Username</label>
+                    <input id="username" name="username" type="text" required
+                           class="appearance-none rounded-none relative block w-full px-3 py-2 border border-gray-300 dark:border-gray-600 placeholder-gray-500 dark:placeholder-gray-400 text-gray-900 dark:text-white rounded-t-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 sm:text-sm dark:bg-gray-700"
+                           placeholder="Username">
+                </div>
+                <div>
+                    <label for="password" class="sr-only">Password</label>
+                    <input id="password" name="password" type="password" required
+                           class="appearance-none rounded-none relative block w-full px-3 py-2 border border-gray-300 dark:border-gray-600 placeholder-gray-500 dark:placeholder-gray-400 text-gray-900 dark:text-white rounded-b-md focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 sm:text-sm dark:bg-gray-700"
+                           placeholder="Password">
+                </div>
+            </div>
+
+            <div class="flex items-center justify-between">
+                <div class="flex items-center">
+                    <input id="remember-me" name="remember-me" type="checkbox"
+                           class="h-4 w-4 text-blue-600 focus:ring-blue-500 border-gray-300 dark:border-gray-600 rounded">
+                    <label for="remember-me" class="ml-2 block text-sm text-gray-900 dark:text-gray-300">
+                        Remember me
+                    </label>
+                </div>
+
+                <div class="text-sm">
+                    <a href="#" class="font-medium text-blue-600 hover:text-blue-500">
+                        Forgot your password?
+                    </a>
+                </div>
+            </div>
+
+            <div>
+                <button type="submit"
+                        class="group relative w-full flex justify-center py-2 px-4 border border-transparent text-sm font-medium rounded-md text-white bg-blue-600 hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500">
+                    <span class="absolute left-0 inset-y-0 flex items-center pl-3">
+                        <svg class="h-5 w-5 text-blue-500 group-hover:text-blue-400" xmlns="http://www.w3.org/2000/svg"
+                             viewBox="0 0 20 20" fill="currentColor" aria-hidden="true">
+                            <path fill-rule="evenodd"
+                                  d="M5 9V7a5 5 0 0110 0v2a2 2 0 012 2v5a2 2 0 01-2 2H5a2 2 0 01-2-2v-5a2 2 0 012-2zm8-2v2H7V7a3 3 0 016 0z"
+                                  clip-rule="evenodd"/>
+                        </svg>
+                    </span>
+                    Sign in
+                </button>
+            </div>
+        </form>
+
+        <div class="mt-6">
+            <div class="relative">
+                <div class="absolute inset-0 flex items-center">
+                    <div class="w-full border-t border-gray-300 dark:border-gray-600"></div>
+                </div>
+                <div class="relative flex justify-center text-sm">
+                    <span class="px-2 bg-gray-50 dark:bg-gray-900 text-gray-500 dark:text-gray-400">
+                        Or continue with
+                    </span>
+                </div>
+            </div>
+
+            <div class="mt-6 grid grid-cols-2 gap-3">
+                <div>
+                    <a href="#"
+                       class="w-full inline-flex justify-center py-2 px-4 border border-gray-300 dark:border-gray-600 rounded-md shadow-sm bg-white dark:bg-gray-700 text-sm font-medium text-gray-500 dark:text-gray-400 hover:bg-gray-50 dark:hover:bg-gray-600">
+                        <span class="sr-only">Sign in with Google</span>
+                        <svg class="w-5 h-5" viewBox="0 0 24 24">
+                            <path fill="currentColor"
+                                  d="M12.545,10.239v3.821h5.445c-0.712,2.315-2.647,3.972-5.445,3.972c-3.332,0-6.033-2.701-6.033-6.032s2.701-6.032,6.033-6.032c1.498,0,2.866,0.549,3.921,1.453l2.814-2.814C17.503,2.988,15.139,2,12.545,2C7.021,2,2.543,6.477,2.543,12s4.478,10,10.002,10c8.396,0,10.249-7.85,9.426-11.748L12.545,10.239z"/>
+                        </svg>
+                    </a>
+                </div>
+
+                <div>
+                    <a href="#"
+                       class="w-full inline-flex justify-center py-2 px-4 border border-gray-300 dark:border-gray-600 rounded-md shadow-sm bg-white dark:bg-gray-700 text-sm font-medium text-gray-500 dark:text-gray-400 hover:bg-gray-50 dark:hover:bg-gray-600">
+                        <span class="sr-only">Sign in with GitHub</span>
+                        <svg class="w-5 h-5" fill="currentColor" viewBox="0 0 20 20">
+                            <path fill-rule="evenodd"
+                                  d="M10 0C4.477 0 0 4.484 0 10.017c0 4.425 2.865 8.18 6.839 9.504.5.092.682-.217.682-.483 0-.237-.008-.868-.013-1.703-2.782.605-3.369-1.343-3.369-1.343-.454-1.158-1.11-1.466-1.11-1.466-.908-.62.069-.608.069-.608 1.003.07 1.531 1.032 1.531 1.032.892 1.53 2.341 1.088 2.91.832.092-.647.35-1.088.636-1.338-2.22-.253-4.555-1.113-4.555-4.951 0-1.093.39-1.988 1.029-2.688-.103-.253-.446-1.272.098-2.65 0 0 .84-.27 2.75 1.026A9.564 9.564 0 0110 4.844c.85.004 1.705.115 2.504.337 1.909-1.296 2.747-1.027 2.747-1.027.546 1.379.203 2.398.1 2.651.64.7 1.028 1.595 1.028 2.688 0 3.848-2.339 4.695-4.566 4.942.359.31.678.921.678 1.856 0 1.338-.012 2.419-.012 2.747 0 .268.18.58.688.482A10.019 10.019 0 0020 10.017C20 4.484 15.522 0 10 0z"
+                                  clip-rule="evenodd"/>
+                        </svg>
+                    </a>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+{% endblock %} 

templates/marketplace.html

@@ -0,0 +1,287 @@
+{% extends "base.html" %}
+
+{% block content %}
+<div class="container mx-auto px-4 py-8">
+    <div class="max-w-7xl mx-auto">
+        <!-- Header -->
+        <div class="flex items-center justify-between mb-8">
+            <div>
+                <h1 class="text-3xl font-bold text-gray-900 dark:text-white">Prompt Marketplace</h1>
+                <p class="mt-2 text-gray-600 dark:text-gray-300">Discover and purchase high-quality prompts for various AI tools</p>
+            </div>
+            <div class="text-right">
+                <div class="text-2xl font-bold text-blue-600">{{ user_credits }}</div>
+                <div class="text-sm text-gray-500">credits available</div>
+            </div>
+        </div>
+
+        <!-- Filters and Search -->
+        <div class="bg-white dark:bg-gray-800 rounded-lg shadow-lg p-6 mb-8">
+            <div class="flex flex-col md:flex-row md:items-center md:justify-between gap-4">
+                <!-- Search -->
+                <div class="flex-1">
+                    <div class="relative">
+                        <input type="text" id="search-input"
+                               class="w-full rounded-lg border-gray-300 dark:border-gray-600 dark:bg-gray-700 pl-10 pr-4 py-2 focus:ring-blue-500 focus:border-blue-500"
+                               placeholder="Search prompts...">
+                        <div class="absolute inset-y-0 left-0 pl-3 flex items-center pointer-events-none">
+                            <svg class="h-5 w-5 text-gray-400" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 20 20"
+                                 fill="currentColor">
+                                <path fill-rule="evenodd"
+                                      d="M8 4a4 4 0 100 8 4 4 0 000-8zM2 8a6 6 0 1110.89 3.476l4.817 4.817a1 1 0 01-1.414 1.414l-4.816-4.816A6 6 0 012 8z"
+                                      clip-rule="evenodd"/>
+                            </svg>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Category Filter -->
+                <div class="flex-shrink-0">
+                    <select id="category-filter"
+                            class="rounded-lg border-gray-300 dark:border-gray-600 dark:bg-gray-700 focus:ring-blue-500 focus:border-blue-500">
+                        <option value="">All Categories</option>
+                        <option value="text" {% if category == 'text' %}selected{% endif %}>Text Generation</option>
+                        <option value="image" {% if category == 'image' %}selected{% endif %}>Image Generation</option>
+                        <option value="code" {% if category == 'code' %}selected{% endif %}>Code Generation</option>
+                    </select>
+                </div>
+
+                <!-- Sort By -->
+                <div class="flex-shrink-0">
+                    <select id="sort-by"
+                            class="rounded-lg border-gray-300 dark:border-gray-600 dark:bg-gray-700 focus:ring-blue-500 focus:border-blue-500">
+                        <option value="popular" {% if sort_by == 'popular' %}selected{% endif %}>Most Popular</option>
+                        <option value="newest" {% if sort_by == 'newest' %}selected{% endif %}>Newest First</option>
+                        <option value="rating" {% if sort_by == 'rating' %}selected{% endif %}>Highest Rated</option>
+                    </select>
+                </div>
+            </div>
+        </div>
+
+        <!-- Prompts Grid -->
+        <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
+            {% for prompt in prompts %}
+            <div class="bg-white dark:bg-gray-800 rounded-lg shadow-lg overflow-hidden prompt-card"
+                 data-category="{{ prompt.tool_id }}"
+                 data-title="{{ prompt.title|lower }}"
+                 data-rating="{{ prompt.avg_rating }}"
+                 data-usage="{{ prompt.usage_count }}"
+                 data-date="{{ prompt.created_at }}">
+                <!-- Prompt Header -->
+                <div class="p-6">
+                    <div class="flex items-start justify-between">
+                        <div>
+                            <h3 class="text-lg font-semibold text-gray-900 dark:text-white">{{ prompt.title }}</h3>
+                            <p class="mt-1 text-sm text-gray-500 dark:text-gray-400">{{ prompt.description }}</p>
+                        </div>
+                        <div class="flex items-center">
+                            <span class="text-yellow-500">★</span>
+                            <span class="ml-1 text-sm text-gray-600 dark:text-gray-300">{{ "%.1f"|format(prompt.avg_rating) }}</span>
+                        </div>
+                    </div>
+
+                    <!-- Tags -->
+                    <div class="mt-4 flex flex-wrap gap-2">
+                        {% for tag in prompt.tags %}
+                        <span class="px-2 py-1 text-xs font-medium bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-200 rounded-full">
+                            {{ tag }}
+                        </span>
+                        {% endfor %}
+                    </div>
+
+                    <!-- Usage Stats -->
+                    <div class="mt-4 flex items-center text-sm text-gray-500 dark:text-gray-400">
+                        <svg class="h-4 w-4 mr-1" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                                  d="M15 12a3 3 0 11-6 0 3 3 0 016 0z"/>
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                                  d="M2.458 12C3.732 7.943 7.523 5 12 5c4.478 0 8.268 2.943 9.542 7-1.274 4.057-5.064 7-9.542 7-4.477 0-8.268-2.943-9.542-7z"/>
+                        </svg>
+                        {{ prompt.usage_count }} uses
+                    </div>
+                </div>
+
+                <!-- Preview -->
+                <div class="px-6 py-4 bg-gray-50 dark:bg-gray-700">
+                    <div class="text-sm text-gray-600 dark:text-gray-300 line-clamp-3">
+                        {{ prompt.content }}
+                    </div>
+                </div>
+
+                <!-- Footer -->
+                <div class="px-6 py-4 bg-white dark:bg-gray-800 border-t border-gray-200 dark:border-gray-700">
+                    <div class="flex items-center justify-between">
+                        <div class="text-sm text-gray-500 dark:text-gray-400">
+                            Created by {{ prompt.creator_id }}
+                        </div>
+                        <button onclick="purchasePrompt('{{ prompt.id }}')"
+                                class="px-4 py-2 text-sm font-medium text-white bg-blue-600 rounded-lg hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500">
+                            Purchase
+                        </button>
+                    </div>
+                </div>
+            </div>
+            {% endfor %}
+        </div>
+
+        <!-- Empty State -->
+        <div id="empty-state" class="hidden text-center py-12">
+            <svg class="mx-auto h-12 w-12 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                      d="M9.172 16.172a4 4 0 015.656 0M9 10h.01M15 10h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"/>
+            </svg>
+            <h3 class="mt-2 text-sm font-medium text-gray-900 dark:text-white">No prompts found</h3>
+            <p class="mt-1 text-sm text-gray-500 dark:text-gray-400">
+                Try adjusting your search or filter criteria
+            </p>
+        </div>
+    </div>
+</div>
+
+<!-- Purchase Confirmation Modal -->
+<div id="purchase-modal" class="fixed inset-0 bg-black bg-opacity-50 hidden items-center justify-center">
+    <div class="bg-white dark:bg-gray-800 rounded-lg p-6 max-w-lg w-full mx-4">
+        <h2 class="text-xl font-semibold mb-4">Confirm Purchase</h2>
+        <p class="text-gray-600 dark:text-gray-300 mb-4">
+            Are you sure you want to purchase this prompt? This will cost 5 credits.
+        </p>
+        <div class="flex justify-end space-x-4">
+            <button id="cancel-purchase"
+                    class="px-4 py-2 text-sm font-medium text-gray-700 bg-gray-100 rounded-lg hover:bg-gray-200 dark:bg-gray-700 dark:text-gray-300 dark:hover:bg-gray-600">
+                Cancel
+            </button>
+            <button id="confirm-purchase"
+                    class="px-4 py-2 text-sm font-medium text-white bg-blue-600 rounded-lg hover:bg-blue-700">
+                Confirm Purchase
+            </button>
+        </div>
+    </div>
+</div>
+
+<script>
+let selectedPromptId = null;
+
+// Initialize the page
+document.addEventListener('DOMContentLoaded', function() {
+    setupEventListeners();
+    setupFilters();
+});
+
+// Set up event listeners
+function setupEventListeners() {
+    // Purchase modal
+    document.getElementById('cancel-purchase').addEventListener('click', hidePurchaseModal);
+    document.getElementById('confirm-purchase').addEventListener('click', handlePurchase);
+}
+
+// Set up filters
+function setupFilters() {
+    const searchInput = document.getElementById('search-input');
+    const categoryFilter = document.getElementById('category-filter');
+    const sortBy = document.getElementById('sort-by');
+
+    function filterPrompts() {
+        const searchTerm = searchInput.value.toLowerCase();
+        const category = categoryFilter.value;
+        const sortValue = sortBy.value;
+
+        const cards = document.querySelectorAll('.prompt-card');
+        let visibleCount = 0;
+
+        cards.forEach(card => {
+            const title = card.dataset.title;
+            const cardCategory = card.dataset.category;
+            const rating = parseFloat(card.dataset.rating);
+            const usage = parseInt(card.dataset.usage);
+            const date = new Date(card.dataset.date);
+
+            const matchesSearch = title.includes(searchTerm);
+            const matchesCategory = !category || cardCategory === category;
+
+            if (matchesSearch && matchesCategory) {
+                card.style.display = 'block';
+                visibleCount++;
+            } else {
+                card.style.display = 'none';
+            }
+        });
+
+        // Show/hide empty state
+        const emptyState = document.getElementById('empty-state');
+        emptyState.classList.toggle('hidden', visibleCount > 0);
+
+        // Sort visible cards
+        const container = document.querySelector('.grid');
+        const visibleCards = Array.from(cards).filter(card => card.style.display !== 'none');
+        
+        visibleCards.sort((a, b) => {
+            switch (sortValue) {
+                case 'rating':
+                    return parseFloat(b.dataset.rating) - parseFloat(a.dataset.rating);
+                case 'newest':
+                    return new Date(b.dataset.date) - new Date(a.dataset.date);
+                case 'popular':
+                default:
+                    return parseInt(b.dataset.usage) - parseInt(a.dataset.usage);
+            }
+        });
+
+        visibleCards.forEach(card => container.appendChild(card));
+    }
+
+    searchInput.addEventListener('input', filterPrompts);
+    categoryFilter.addEventListener('change', filterPrompts);
+    sortBy.addEventListener('change', filterPrompts);
+}
+
+// Purchase prompt
+function purchasePrompt(promptId) {
+    selectedPromptId = promptId;
+    showPurchaseModal();
+}
+
+// Show purchase modal
+function showPurchaseModal() {
+    document.getElementById('purchase-modal').classList.remove('hidden');
+    document.getElementById('purchase-modal').classList.add('flex');
+}
+
+// Hide purchase modal
+function hidePurchaseModal() {
+    document.getElementById('purchase-modal').classList.add('hidden');
+    document.getElementById('purchase-modal').classList.remove('flex');
+    selectedPromptId = null;
+}
+
+// Handle purchase
+async function handlePurchase() {
+    if (!selectedPromptId) return;
+
+    try {
+        const response = await fetch('/api/marketplace/purchase', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                prompt_id: selectedPromptId
+            })
+        });
+
+        const data = await response.json();
+
+        if (data.success) {
+            showToast('Prompt purchased successfully!', 'success');
+            hidePurchaseModal();
+            // Refresh the page to update credits
+            window.location.reload();
+        } else {
+            showToast(data.error || 'Failed to purchase prompt', 'error');
+        }
+    } catch (error) {
+        console.error('Error purchasing prompt:', error);
+        showToast('Failed to purchase prompt', 'error');
+    }
+}
+</script>
+{% endblock %} 

templates/register.html

@@ -0,0 +1,93 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Register | {{ app_name }}</title>
+    <link rel="stylesheet" href="{{ url_for('static', path='/css/styles.css') }}">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <script src="{{ url_for('static', path='/js/main.js') }}" defer></script>
+</head>
+<body>
+    <div class="auth-container">
+        <div class="auth-card">
+            <div class="auth-header">
+                <h1>{{ app_name }}</h1>
+                <div class="auth-subtitle">Create an Account</div>
+            </div>
+            
+            {% if error %}
+            <div class="alert alert-error">
+                <i class="fas fa-exclamation-triangle"></i>
+                {{ error }}
+            </div>
+            {% endif %}
+            
+            <form class="auth-form" action="/register" method="post">
+                <div class="form-group">
+                    <label for="username">Username</label>
+                    <div class="input-with-icon">
+                        <i class="fas fa-user"></i>
+                        <input type="text" id="username" name="username" required value="{{ request.form.username if request.form else '' }}">
+                    </div>
+                </div>
+                
+                <div class="form-group">
+                    <label for="email">Email</label>
+                    <div class="input-with-icon">
+                        <i class="fas fa-envelope"></i>
+                        <input type="email" id="email" name="email" required value="{{ request.form.email if request.form else '' }}">
+                    </div>
+                </div>
+                
+                <div class="form-group">
+                    <label for="password">Password</label>
+                    <div class="input-with-icon">
+                        <i class="fas fa-lock"></i>
+                        <input type="password" id="password" name="password" required>
+                    </div>
+                </div>
+                
+                <div class="form-group">
+                    <label for="confirm_password">Confirm Password</label>
+                    <div class="input-with-icon">
+                        <i class="fas fa-lock"></i>
+                        <input type="password" id="confirm_password" name="confirm_password" required>
+                    </div>
+                </div>
+                
+                <div class="form-group">
+                    <button type="submit" class="btn btn-primary btn-block">Create Account</button>
+                </div>
+                
+                <div class="auth-links">
+                    <a href="/login">Already have an account? Sign in</a>
+                </div>
+            </form>
+            
+            <div class="auth-separator">
+                <div class="line"></div>
+                <div class="text">or</div>
+                <div class="line"></div>
+            </div>
+            
+            <div class="social-login">
+                <button class="btn btn-google">
+                    <i class="fab fa-google"></i>
+                    Sign up with Google
+                </button>
+                <button class="btn btn-facebook">
+                    <i class="fab fa-facebook"></i>
+                    Sign up with Facebook
+                </button>
+            </div>
+            
+            <div class="auth-footer">
+                By creating an account, you agree to the
+                <a href="#">Terms of Service</a> and
+                <a href="#">Privacy Policy</a>
+            </div>
+        </div>
+    </div>
+</body>
+</html>