Create app.py

app.py

@@ -0,0 +1,1805 @@
+from flask import Flask, jsonify, request, redirect, session, Response
+import json
+import requests
+import os
+import hashlib
+import time
+import psycopg2
+from psycopg2.extras import RealDictCursor
+from datetime import datetime, timedelta
+import threading
+import atexit
+import uuid
+from collections import defaultdict
+
+app = Flask(__name__)
+app.secret_key = 'your-secret-key-here'
+DISCORD_CLIENT_ID = '1426015278499627058'
+DISCORD_CLIENT_SECRET = 'YfTZg5JZA-y3GU1wDyoO3IPilwz9jXmL'
+DATABASE_URL = 'postgres://avnadmin:AVNS_o0LDhRmORJQ7lh7ULQS@goapi-hacktv.b.aivencloud.com:11426/defaultdb?sslmode=require'
+ADMIN_PASSWORD = "GoodGuys!Funn1"
+# Global variables for batching credit deductions
+pending_deductions = defaultdict(int)  # username -> total_credits_to_deduct
+credit_cache = {}  # username -> last_known_credits_balance
+deduction_lock = threading.Lock()
+batch_timer = None
+
+MODEL_MULTIPLIERS = {
+    'gpt-5-nano': 1.0,
+    'gpt-5-chat': 1.5,
+    'gpt-4.1': 1.0,
+    'claude-4-sonnet': 3.0,
+    'claude-4-opus': 5.0,
+    'claude-3.5-sonnet': 3.0,
+    'claude-3.7-sonnet': 3.0,
+    'claude-3.5-haiku': 2.0
+}
+
+def init_db():
+    conn = psycopg2.connect(DATABASE_URL)
+    c = conn.cursor()
+    c.execute('''CREATE TABLE IF NOT EXISTS users
+                 (username TEXT PRIMARY KEY,
+                  plan TEXT DEFAULT 'free',
+                  credits INTEGER DEFAULT 500000,
+                  last_reset TEXT)''')
+    conn.commit()
+    conn.close()
+
+def get_user(username):
+    conn = psycopg2.connect(DATABASE_URL)
+    c = conn.cursor(cursor_factory=RealDictCursor)
+    c.execute('SELECT plan, credits, last_reset FROM users WHERE username = %s', (username,))
+    result = c.fetchone()
+    conn.close()
+
+    if result:
+        return dict(result)
+    return None
+
+def create_or_update_user(username, plan='free'):
+    conn = psycopg2.connect(DATABASE_URL)
+    c = conn.cursor()
+    now = datetime.now().isoformat()
+
+    c.execute('''INSERT INTO users (username, plan, credits, last_reset)
+                 VALUES (%s, %s, 500000, %s)
+                 ON CONFLICT (username)
+                 DO UPDATE SET plan = EXCLUDED.plan, credits = EXCLUDED.credits, last_reset = EXCLUDED.last_reset''',
+                 (username, plan, now))
+    conn.commit()
+    conn.close()
+
+def reset_credits_if_needed(username):
+    user = get_user(username)
+    if not user:
+        return
+
+    last_reset = user['last_reset']
+    if last_reset:
+        last_reset_date = datetime.fromisoformat(last_reset).date()
+        today = datetime.now().date()
+
+        if last_reset_date < today:
+            conn = psycopg2.connect(DATABASE_URL)
+            c = conn.cursor()
+            now = datetime.now().isoformat()
+            c.execute('UPDATE users SET credits = 500000, last_reset = %s WHERE username = %s',
+                     (now, username))
+            conn.commit()
+            conn.close()
+
+def deduct_credits(username, amount):
+    conn = psycopg2.connect(DATABASE_URL)
+    c = conn.cursor()
+    c.execute('UPDATE users SET credits = credits - %s WHERE username = %s AND credits >= %s',
+             (amount, username, amount))
+    success = c.rowcount > 0
+    conn.commit()
+    conn.close()
+    return success
+
+def get_user_credits(username):
+    user = get_user(username)
+    if user:
+        reset_credits_if_needed(username)
+        user = get_user(username)
+        return user['credits'] if user else 0
+    return 0
+
+def get_cached_credits(username):
+    """Get cached credits balance for a user (estimated: cached_balance - pending_deductions)"""
+    with deduction_lock:
+        cached_balance = credit_cache.get(username, 0)
+        pending_for_user = pending_deductions.get(username, 0)
+        return cached_balance - pending_for_user
+
+def update_credit_cache(username, new_balance):
+    """Update the cached credit balance for a user"""
+    with deduction_lock:
+        credit_cache[username] = new_balance
+        print(f"Updated credit cache for {username}: {new_balance} credits")
+
+def clear_cache_entry(username):
+    """Clear cache entry for a user (called when they run out of credits)"""
+    with deduction_lock:
+        credit_cache.pop(username, None)
+        print(f"Cleared credit cache for {username}")
+
+def add_pending_deduction(username, amount):
+    """Add a credit deduction to the pending queue"""
+    with deduction_lock:
+        pending_deductions[username] += amount
+
+def process_pending_deductions():
+    """Process all pending credit deductions in a single batch (runs in background thread)"""
+    try:
+        with deduction_lock:
+            if not pending_deductions:
+                return
+
+            # Create a copy of pending deductions to process
+            deductions_to_process = dict(pending_deductions)
+            pending_deductions.clear()
+
+        # Process deductions in database
+        if deductions_to_process:
+            conn = psycopg2.connect(DATABASE_URL)
+            c = conn.cursor()
+
+            for username, amount in deductions_to_process.items():
+                c.execute('UPDATE users SET credits = credits - %s WHERE username = %s AND credits >= %s',
+                         (amount, username, amount))
+
+            # Get updated balances for all affected users
+            usernames = list(deductions_to_process.keys())
+            if usernames:
+                placeholders = ','.join(['%s'] * len(usernames))
+                c.execute(f'SELECT username, credits FROM users WHERE username IN ({placeholders})', usernames)
+
+                for row in c.fetchall():
+                    username, new_balance = row
+                    update_credit_cache(username, new_balance)
+
+            conn.commit()
+            conn.close()
+            print(f"Processed {len(deductions_to_process)} credit deductions")
+    except Exception as e:
+        print(f"Error processing credit deductions: {e}")
+        # Put deductions back in queue if there was an error
+        with deduction_lock:
+            for username, amount in deductions_to_process.items():
+                pending_deductions[username] += amount
+
+def start_batch_timer():
+    """Start or restart the 3-minute batch timer"""
+    global batch_timer
+
+    if batch_timer:
+        batch_timer.cancel()
+
+    batch_timer = threading.Timer(180.0, lambda: threading.Thread(target=process_pending_deductions, daemon=True).start())  # 3 minutes = 180 seconds
+    batch_timer.daemon = True
+    batch_timer.start()
+
+def verify_admin_password(password):
+    """Verify admin password"""
+    return password == ADMIN_PASSWORD
+
+def export_database():
+    """Export current database to JSON"""
+    try:
+        conn = psycopg2.connect(DATABASE_URL)
+        c = conn.cursor(cursor_factory=RealDictCursor)
+
+        # Get all users
+        c.execute('SELECT * FROM users')
+        users = c.fetchall()
+
+        # Convert to list of dicts for JSON serialization
+        users_data = [dict(user) for user in users]
+
+        conn.close()
+        return {"users": users_data, "exported_at": datetime.now().isoformat()}
+
+    except Exception as e:
+        return {"error": f"Failed to export database: {str(e)}"}
+
+def import_database(data):
+    """Import database from JSON data"""
+    try:
+        if "users" not in data:
+            return {"error": "Invalid data format: missing 'users' key"}
+
+        conn = psycopg2.connect(DATABASE_URL)
+        c = conn.cursor()
+
+        # Clear existing data
+        c.execute('DELETE FROM users')
+
+        # Insert new data
+        for user_data in data["users"]:
+            c.execute('''INSERT INTO users (username, plan, credits, last_reset)
+                        VALUES (%s, %s, %s, %s)''',
+                     (user_data['username'], user_data.get('plan', 'free'),
+                      user_data.get('credits', 500000), user_data.get('last_reset')))
+
+        conn.commit()
+        conn.close()
+
+        # Update credit cache for all imported users
+        for user_data in data["users"]:
+            update_credit_cache(user_data['username'], user_data.get('credits', 500000))
+
+        return {"success": f"Imported {len(data['users'])} users"}
+
+    except Exception as e:
+        return {"error": f"Failed to import database: {str(e)}"}
+
+init_db()
+
+def get_all_users():
+    """Get all users from database"""
+    try:
+        conn = psycopg2.connect(DATABASE_URL)
+        c = conn.cursor(cursor_factory=RealDictCursor)
+        c.execute('SELECT * FROM users ORDER BY username')
+        users = c.fetchall()
+        conn.close()
+        return [dict(user) for user in users]
+    except Exception as e:
+        return []
+
+@app.route('/db/admin', methods=['GET', 'POST'])
+def db_admin():
+    """Database admin interface"""
+    if request.method == 'GET':
+        users = get_all_users()
+
+        # Generate user management table
+        users_html = ""
+        for user in users:
+            users_html += f'''
+            <tr>
+                <td>{user['username']}</td>
+                <td>
+                    <div class="plan-container">
+                        <select class="plan-select" data-username="{user['username']}">
+                            <option value="free" {'selected' if user['plan'] == 'free' else ''}>Free</option>
+                            <option value="premium" {'selected' if user['plan'] == 'premium' else ''}>Premium</option>
+                            <option value="pro" {'selected' if user['plan'] == 'pro' else ''}>Pro</option>
+                            <option value="custom">Custom...</option>
+                        </select>
+                        <input type="text" class="plan-custom-input" data-username="{user['username']}"
+                               placeholder="Enter custom plan" style="display: none; margin-top: 5px;">
+                    </div>
+                </td>
+                <td>{user['credits']:,}</td>
+                <td>
+                    <input type="number" class="tokens-input" data-username="{user['username']}"
+                           value="{user['credits']}" min="0" max="10000000" step="1000">
+                </td>
+                <td>
+                    <button class="update-btn" data-username="{user['username']}">Update</button>
+                </td>
+            </tr>
+            '''
+
+        return f'''
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>Database Admin</title>
+            <style>
+                body {{ font-family: Arial, sans-serif; max-width: 1200px; margin: 50px auto; padding: 20px; }}
+                .form-group {{ margin-bottom: 20px; }}
+                label {{ display: block; margin-bottom: 5px; font-weight: bold; }}
+                input[type="password"], input[type="file"] {{ width: 100%; padding: 8px; border: 1px solid #ddd; border-radius: 4px; }}
+                input[type="text"] {{ width: 300px; padding: 8px; border: 1px solid #ddd; border-radius: 4px; }}
+                button {{ background: #007bff; color: white; padding: 10px 20px; border: none; border-radius: 4px; cursor: pointer; margin: 2px; }}
+                button:hover {{ background: #0056b3; }}
+                button.update-btn {{ background: #28a745; }}
+                button.update-btn:hover {{ background: #218838; }}
+                .error {{ color: red; margin-top: 10px; }}
+                .success {{ color: green; margin-top: 10px; }}
+                .section {{ margin-bottom: 40px; padding: 20px; border: 1px solid #ddd; border-radius: 8px; }}
+                .user-table {{ width: 100%; border-collapse: collapse; margin-top: 20px; }}
+                .user-table th, .user-table td {{ border: 1px solid #ddd; padding: 12px; text-align: left; }}
+                .user-table th {{ background-color: #f2f2f2; }}
+                .user-table input {{ width: 120px; }}
+                .plan-container {{ display: flex; flex-direction: column; gap: 5px; }}
+                .plan-custom-input {{ width: 100%; padding: 6px; border: 1px solid #ddd; border-radius: 4px; }}
+                .search-box {{ margin-bottom: 20px; }}
+                .status {{ margin-top: 10px; padding: 10px; border-radius: 4px; }}
+                .status.success {{ background-color: #d4edda; color: #155724; }}
+                .status.error {{ background-color: #f8d7da; color: #721c24; }}
+            </style>
+        </head>
+        <body>
+            <h1>Database Administration</h1>
+
+            <div class="section">
+                <h2>User Management</h2>
+                <div class="search-box">
+                    <input type="text" id="searchInput" placeholder="Search users..." onkeyup="filterUsers()">
+                </div>
+                <table class="user-table" id="usersTable">
+                    <thead>
+                        <tr>
+                            <th>Username</th>
+                            <th>Plan</th>
+                            <th>Credits</th>
+                            <th>Set Tokens/Day</th>
+                            <th>Actions</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        {users_html}
+                    </tbody>
+                </table>
+                <div id="status" class="status" style="display: none;"></div>
+            </div>
+
+            <div class="section">
+                <h2>Export Database</h2>
+                <p>Download the current database as a JSON file.</p>
+                <form method="post" action="/db/admin/export">
+                    <div class="form-group">
+                        <label for="password">Admin Password:</label>
+                        <input type="password" id="password" name="password" required>
+                    </div>
+                    <button type="submit">Export Database</button>
+                </form>
+            </div>
+
+            <div class="section">
+                <h2>Import Database</h2>
+                <p>Upload a JSON file to replace the current database.</p>
+                <form method="post" action="/db/admin/import" enctype="multipart/form-data">
+                    <div class="form-group">
+                        <label for="password">Admin Password:</label>
+                        <input type="password" id="password" name="password" required>
+                    </div>
+                    <div class="form-group">
+                        <label for="db_file">Database File (JSON):</label>
+                        <input type="file" id="db_file" name="db_file" accept=".json" required>
+                    </div>
+                    <button type="submit">Import Database</button>
+                </form>
+            </div>
+
+            <script>
+                function filterUsers() {{
+                    const input = document.getElementById('searchInput');
+                    const filter = input.value.toLowerCase();
+                    const table = document.getElementById('usersTable');
+                    const rows = table.getElementsByTagName('tr');
+
+                    for (let i = 1; i < rows.length; i++) {{
+                        const cells = rows[i].getElementsByTagName('td');
+                        if (cells.length > 0) {{
+                            const username = cells[0].textContent.toLowerCase();
+                            if (username.indexOf(filter) > -1) {{
+                                rows[i].style.display = '';
+                            }} else {{
+                                rows[i].style.display = 'none';
+                            }}
+                        }}
+                    }}
+                }}
+
+                function toggleCustomPlan(username) {{
+                    const planSelect = document.querySelector(`.plan-select[data-username="${{username}}"]`);
+                    const customInput = document.querySelector(`.plan-custom-input[data-username="${{username}}"]`);
+
+                    if (planSelect.value === 'custom') {{
+                        customInput.style.display = 'block';
+                        customInput.focus();
+                    }} else {{
+                        customInput.style.display = 'none';
+                        customInput.value = '';
+                    }}
+                }}
+
+                async function updateUser(username) {{
+                    const planSelect = document.querySelector(`.plan-select[data-username="${{username}}"]`);
+                    const customInput = document.querySelector(`.plan-custom-input[data-username="${{username}}"]`);
+                    const tokensInput = document.querySelector(`.tokens-input[data-username="${{username}}"]`);
+
+                    let plan = planSelect.value;
+                    if (plan === 'custom') {{
+                        plan = customInput.value.trim();
+                        if (!plan) {{
+                            alert('Please enter a custom plan name');
+                            return;
+                        }}
+                    }}
+                    const tokens = parseInt(tokensInput.value);
+
+                    try {{
+                        const response = await fetch('/db/admin/update-user', {{
+                            method: 'POST',
+                            headers: {{
+                                'Content-Type': 'application/json',
+                            }},
+                            body: JSON.stringify({{
+                                username: username,
+                                plan: plan,
+                                credits: tokens,
+                                password: prompt('Enter admin password:')
+                            }})
+                        }});
+
+                        const result = await response.json();
+                        const statusDiv = document.getElementById('status');
+
+                        if (response.ok) {{
+                            statusDiv.textContent = result.success;
+                            statusDiv.className = 'status success';
+                            // Update the credits column
+                            const creditsCell = document.querySelector(`.tokens-input[data-username="${{username}}"]`).parentElement.previousElementSibling;
+                            creditsCell.textContent = tokens.toLocaleString();
+                        }} else {{
+                            statusDiv.textContent = result.error;
+                            statusDiv.className = 'status error';
+                        }}
+
+                        statusDiv.style.display = 'block';
+                        setTimeout(() => statusDiv.style.display = 'none', 3000);
+
+                    }} catch (error) {{
+                        console.error('Error updating user:', error);
+                        const statusDiv = document.getElementById('status');
+                        statusDiv.textContent = 'Error updating user';
+                        statusDiv.className = 'status error';
+                        statusDiv.style.display = 'block';
+                        setTimeout(() => statusDiv.style.display = 'none', 3000);
+                    }}
+                }}
+
+                // Add event listeners and initialize custom plans
+                document.addEventListener('DOMContentLoaded', function() {{
+                    // Handle plan selection changes
+                    const planSelects = document.querySelectorAll('.plan-select');
+                    planSelects.forEach(select => {{
+                        select.addEventListener('change', function() {{
+                            const username = this.getAttribute('data-username');
+                            toggleCustomPlan(username);
+                        }});
+                    }});
+
+                    // Initialize custom plan inputs for existing custom plans
+                    const usersData = {json.dumps(users)};
+                    usersData.forEach(user => {{
+                        if (!['free', 'premium', 'pro'].includes(user.plan)) {{
+                            // This is a custom plan
+                            const select = document.querySelector(`.plan-select[data-username="${{user.username}}"]`);
+                            const customInput = document.querySelector(`.plan-custom-input[data-username="${{user.username}}"]`);
+                            if (select && customInput) {{
+                                select.value = 'custom';
+                                customInput.value = user.plan;
+                                customInput.style.display = 'block';
+                            }}
+                        }}
+                    }});
+
+                    // Handle update buttons
+                    const updateBtns = document.querySelectorAll('.update-btn');
+                    updateBtns.forEach(btn => {{
+                        btn.addEventListener('click', function() {{
+                            const username = this.getAttribute('data-username');
+                            updateUser(username);
+                        }});
+                    }});
+                }});
+            </script>
+        </body>
+        </html>
+        '''
+
+    return redirect('/db/admin')
+
+@app.route('/db/admin/export', methods=['POST'])
+def db_admin_export():
+    """Export database as JSON file"""
+    password = request.form.get('password')
+
+    if not verify_admin_password(password):
+        return jsonify({"error": "Invalid admin password"}), 401
+
+    data = export_database()
+
+    if "error" in data:
+        return jsonify(data), 500
+
+    # Create response with JSON data
+    response = Response(
+        json.dumps(data, indent=2),
+        mimetype='application/json',
+        headers={'Content-disposition': 'attachment; filename=database_export.json'}
+    )
+    return response
+
+@app.route('/db/admin/import', methods=['POST'])
+def db_admin_import():
+    """Import database from JSON file"""
+    password = request.form.get('password')
+
+    if not verify_admin_password(password):
+        return jsonify({"error": "Invalid admin password"}), 401
+
+    if 'db_file' not in request.files:
+        return jsonify({"error": "No file provided"}), 400
+
+    file = request.files['db_file']
+    if file.filename == '':
+        return jsonify({"error": "No file selected"}), 400
+
+    if not file.filename.endswith('.json'):
+        return jsonify({"error": "File must be a JSON file"}), 400
+
+    try:
+        file_content = file.read().decode('utf-8')
+        data = json.loads(file_content)
+
+        result = import_database(data)
+
+        if "error" in result:
+            return jsonify(result), 500
+
+        return jsonify(result)
+
+    except json.JSONDecodeError:
+        return jsonify({"error": "Invalid JSON file"}), 400
+    except Exception as e:
+        return jsonify({"error": f"Import failed: {str(e)}"}), 500
+
+@app.route('/db/admin/update-user', methods=['POST'])
+def db_admin_update_user():
+    """Update user plan and credits"""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "No data provided"}), 400
+
+        password = data.get('password')
+        if not verify_admin_password(password):
+            return jsonify({"error": "Invalid admin password"}), 401
+
+        username = data.get('username')
+        plan = data.get('plan')
+        credits = data.get('credits')
+
+        if not username or not plan or credits is None:
+            return jsonify({"error": "Missing required fields"}), 400
+
+        # Update user in database
+        conn = psycopg2.connect(DATABASE_URL)
+        c = conn.cursor()
+
+        # Update plan and credits, reset last_reset to today
+        now = datetime.now().isoformat()
+        c.execute('''UPDATE users
+                    SET plan = %s, credits = %s, last_reset = %s
+                    WHERE username = %s''',
+                 (plan, credits, now, username))
+
+        if c.rowcount == 0:
+            conn.close()
+            return jsonify({"error": "User not found"}), 404
+
+        conn.commit()
+        conn.close()
+
+        # Update credit cache
+        update_credit_cache(username, credits)
+
+        return jsonify({"success": f"Updated {username}: {plan} plan, {credits:,} credits"})
+
+    except Exception as e:
+        return jsonify({"error": f"Update failed: {str(e)}"}), 500
+
+@app.route('/test_stream')
+def test_stream():
+    """Test endpoint to check upstream API streaming behavior with longer prompt"""
+    import time
+
+    # Longer test message for better streaming analysis
+    test_data = {
+        "model": "gpt-5",
+        "messages": [{"role": "user", "content": "Write a short novel about a detective solving a mystery in Victorian London. Include dialogue, suspense, and a surprising twist ending."}],
+        "stream": True,
+        "max_tokens": 500
+    }
+
+    headers = {
+        'Content-Type': 'application/json',
+        'Authorization': 'Bearer test-key'  # This might not work, but for testing
+    }
+
+    try:
+        start_time = time.time()
+        print(f"Starting test stream request at {start_time}")
+
+        response = requests.post(
+            'https://ch.at/v1/chat/completions',
+            json=test_data,
+            headers=headers,
+            stream=True,
+            timeout=60  # Longer timeout for novel generation
+        )
+
+        if response.status_code != 200:
+            return jsonify({
+                "error": f"HTTP {response.status_code}",
+                "message": response.text,
+                "total_time": time.time() - start_time
+            }), response.status_code
+
+        chunk_count = 0
+        first_chunk_time = None
+        last_chunk_time = None
+        total_response = ""
+
+        for chunk in response.iter_content(chunk_size=8192):
+            if chunk:
+                chunk_count += 1
+                current_time = time.time()
+
+                if first_chunk_time is None:
+                    first_chunk_time = current_time
+                    print(f"First chunk received at {current_time} ({current_time - start_time:.2f}s after start)")
+
+                last_chunk_time = current_time
+                chunk_str = chunk.decode('utf-8')
+                total_response += chunk_str
+
+                print(f"Chunk {chunk_count} at {current_time} ({current_time - start_time:.2f}s): {len(chunk_str)} chars")
+
+        end_time = time.time()
+        total_time = end_time - start_time
+        streaming_duration = last_chunk_time - first_chunk_time if first_chunk_time and last_chunk_time else 0
+
+        result = {
+            "total_time": round(total_time, 2),
+            "streaming_duration": round(streaming_duration, 2),
+            "chunk_count": chunk_count,
+            "response_length": len(total_response),
+            "average_chunk_interval": round(streaming_duration / max(chunk_count - 1, 1), 2) if chunk_count > 1 else 0,
+            "chunks_per_second": round(chunk_count / max(streaming_duration, 0.01), 2),
+            "streaming_efficiency": "Good" if streaming_duration > 1.0 else "Poor (likely buffered)",
+            "status": "success"
+        }
+
+        print(f"Stream test completed: {result}")
+
+        return jsonify(result)
+
+    except Exception as e:
+        end_time = time.time()
+        return jsonify({
+            "error": "Test failed",
+            "message": str(e),
+            "total_time": round(end_time - start_time, 2),
+            "status": "error"
+        }), 500
+
+@app.route('/v1/models')
+def models():
+    models_data = {
+        "object": "list",
+        "data": [
+            {
+                "id": "gpt-5-nano",
+                "object": "model",
+                "created": 1677610602,
+                "owned_by": "openai"
+            },
+            {
+                "id": "gpt-5-chat",
+                "object": "model",
+                "created": 1677610602,
+                "owned_by": "openai"
+            },
+            {
+                "id": "gpt-4.1",
+                "object": "model",
+                "created": 1677610602,
+                "owned_by": "openai"
+            },
+            {
+                "id": "claude-4-sonnet",
+                "object": "model",
+                "created": 1677610602,
+                "owned_by": "anthropic"
+            },
+            {
+                "id": "claude-4-opus",
+                "object": "model",
+                "created": 1677610602,
+                "owned_by": "anthropic"
+            },
+            {
+                "id": "claude-3.5-sonnet",
+                "object": "model",
+                "created": 1677610602,
+                "owned_by": "anthropic"
+            },
+            {
+                "id": "claude-3.7-sonnet",
+                "object": "model",
+                "created": 1677610602,
+                "owned_by": "anthropic"
+            },
+            {
+                "id": "claude-3.5-haiku",
+                "object": "model",
+                "created": 1677610602,
+                "owned_by": "anthropic"
+            }
+        ]
+    }
+    return jsonify(models_data)
+
+@app.route('/v1/chat/completions', methods=['POST'])
+def chat_completions():
+    try:
+        auth_header = request.headers.get('Authorization')
+        if not auth_header or not auth_header.startswith('Bearer '):
+            return jsonify({"error": "Missing or invalid Bearer token"}), 401
+
+        token = auth_header.split(' ')[1]
+
+        conn = psycopg2.connect(DATABASE_URL)
+        c = conn.cursor()
+        c.execute('SELECT username FROM users')
+        all_users = c.fetchall()
+        conn.close()
+
+        username = None
+        for (user,) in all_users:
+            expected_key = f"sk-{hashlib.sha256(user.encode()).hexdigest()[:32]}"
+            if token == expected_key:
+                username = user
+                break
+
+        if not username:
+            return jsonify({"error": "Invalid API key"}), 401
+
+        # Get cached credits (no database call)
+        cached_credits = get_cached_credits(username)
+
+        # If user has no cached credits, try to load from database once
+        if username not in credit_cache:
+            try:
+                real_credits = get_user_credits(username)
+                update_credit_cache(username, real_credits)
+                cached_credits = real_credits
+            except:
+                # If database fails, reject request
+                return jsonify({"error": "Unable to verify credits"}), 402
+
+        # Reject if no credits available (cached or real)
+        if cached_credits <= 0:
+            clear_cache_entry(username)  # Clear cache since they're out of credits
+            return jsonify({"error": "Insufficient credits"}), 402
+
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "No JSON data provided"}), 400
+
+        model = data.get('model')
+        if not model:
+            return jsonify({"error": "No model specified"}), 400
+
+        original_model = model
+        if model == 'gpt-5-nano':
+            target_model = 'gpt-5-nano'
+        elif model == 'gpt-5-chat':
+            target_model = 'gpt-5'
+        elif model == 'gpt-4.1':
+            target_model = 'gpt-41'
+        elif model == 'claude-4-sonnet':
+            target_model = 'claude-4-sonnet'
+        elif model == 'claude-4-opus':
+            target_model = 'claude-4-opus'
+        elif model == 'claude-3.5-sonnet':
+            target_model = 'claude-3.5-sonnet'
+        elif model == 'claude-3.7-sonnet':
+            target_model = 'claude-3.7-sonnet'
+        elif model == 'claude-3.5-haiku':
+            target_model = 'claude-3.5-haiku'
+        else:
+            return jsonify({"error": f"Unsupported model: {model}"}), 400
+
+        data['model'] = target_model
+
+        messages = data.get('messages', [])
+
+        # Count total words in all messages (input and assistant)
+        input_words = sum(len(str(msg.get('content', '')).split()) for msg in messages)
+
+        # Estimate output words (roughly half the input length, min 100 words)
+        estimated_output_words = max(100, input_words // 2)
+
+        total_words = input_words + estimated_output_words
+
+        multiplier = MODEL_MULTIPLIERS.get(model, 1.0)
+        estimated_cost = int(total_words * multiplier)
+
+        # Check against cached credits (no database call)
+        if estimated_cost > cached_credits:
+            clear_cache_entry(username)  # Clear cache since insufficient credits detected
+            return jsonify({"error": "Insufficient credits for this request"}), 402
+
+        # Add to pending deductions instead of immediate database update
+        add_pending_deduction(username, estimated_cost)
+        start_batch_timer()  # Start/restart the 3-minute timer
+
+        if 'claude' in model.lower() and messages:
+            messages = data['messages']
+            if messages and messages[0]['role'] == 'system':
+                system_content = messages[0]['content']
+                data['messages'] = [
+                    {'role': 'user', 'content': system_content},
+                    {'role': 'assistant', 'content': system_content}
+                ] + messages[1:]
+
+        auth_header = request.headers.get('Authorization')
+        if not auth_header or not auth_header.startswith('Bearer '):
+            return jsonify({"error": "Missing or invalid Bearer token"}), 401
+
+        headers = {
+            'Content-Type': 'application/json',
+            'Authorization': auth_header
+        }
+
+        max_retries = 3
+        retry_delay = 1
+
+        for attempt in range(max_retries):
+            response = requests.post(
+                'https://ch.at/v1/chat/completions',
+                json=data,
+                headers=headers,
+                stream=True
+            )
+
+            if response.status_code == 200:
+                break
+
+            if attempt < max_retries - 1:
+                time.sleep(retry_delay)
+            else:
+                return
+
+        # Ensure we have a valid streaming response
+        if not response:
+            return jsonify({"error": "Failed to get response from upstream API"}), 502
+
+        def generate():
+            # Generate a UUID for this chat completion
+            completion_id = f"chatcmpl-{uuid.uuid4().hex[:16]}"
+
+            try:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        chunk_str = chunk.decode('utf-8', errors='replace')
+
+                        # Replace the chat completion ID with our UUID
+                        chunk_str = chunk_str.replace('"id":"chatcmpl-', f'"id":"{completion_id}"')
+
+                        # Replace model IDs in the response to match the original request
+                        if original_model == 'gpt-5-chat':
+                            chunk_str = chunk_str.replace('"model":"gpt-5"', '"model":"gpt-5-chat"')
+                        elif original_model == 'gpt-4.1':
+                            chunk_str = chunk_str.replace('"model":"gpt-41"', '"model":"gpt-4.1"')
+
+                        # Check if this chunk contains [DONE] - handle edge case where [DONE] might be split across chunks
+                        if 'data: [DONE]' in chunk_str:
+                            print("Stream ended with [DONE], triggering retry...")
+                            # Return a special response that indicates retry is needed
+                            return Response('data: [RETRY_REQUEST]\n\n', content_type='text/plain')
+
+                        # Ensure proper SSE formatting and only yield non-empty chunks
+                        if chunk_str.strip():
+                            yield f"{chunk_str}\n\n".encode('utf-8')
+
+            except Exception as e:
+                print(f"Error in streaming: {e}")
+                yield b'data: {"error": "Streaming error"}\n\n'
+
+        response_obj = Response(
+            generate(),
+            content_type='text/event-stream; charset=utf-8',
+            status=response.status_code
+        )
+
+        return response_obj
+
+    except Exception as e:
+        return jsonify({"error": f"Internal server error: {str(e)}"}), 500
+
+@app.route('/auth')
+def auth():
+    redirect_uri = f"{request.scheme}://{request.host}/auth/callback"
+    discord_auth_url = f"https://discord.com/api/oauth2/authorize?client_id={DISCORD_CLIENT_ID}&redirect_uri={redirect_uri}&response_type=code&scope=identify"
+    return redirect(discord_auth_url)
+
+@app.route('/auth/callback')
+def auth_callback():
+    code = request.args.get('code')
+    if not code:
+        return "Error: No authorization code provided"
+
+    redirect_uri = f"{request.scheme}://{request.host}/auth/callback"
+    data = {
+        'client_id': DISCORD_CLIENT_ID,
+        'client_secret': DISCORD_CLIENT_SECRET,
+        'grant_type': 'authorization_code',
+        'code': code,
+        'redirect_uri': redirect_uri
+    }
+    headers = {'Content-Type': 'application/x-www-form-urlencoded'}
+    token_response = requests.post('https://discord.com/api/oauth2/token', data=data, headers=headers)
+    token_json = token_response.json()
+
+    if 'access_token' not in token_json:
+        return "Error: Failed to get access token"
+
+    access_token = token_json['access_token']
+    user_response = requests.get('https://discord.com/api/users/@me', headers={'Authorization': f'Bearer {access_token}'})
+    user_json = user_response.json()
+
+    username = user_json.get('username', 'Unknown')
+    session['username'] = username
+    create_or_update_user(username)
+
+    # Initialize credit cache for this user
+    try:
+        initial_credits = get_user_credits(username)
+        update_credit_cache(username, initial_credits)
+    except:
+        # If database fails during auth, user will need to refresh credits later
+        pass
+
+    return redirect('/dashboard')
+
+@app.route('/logout')
+def logout():
+    # Clear credit cache for this user
+    if 'username' in session:
+        username = session.get('username')
+        with deduction_lock:
+            credit_cache.pop(username, None)
+            pending_deductions.pop(username, None)
+    session.clear()
+    return redirect('/')
+
+@app.route('/api/user/credits')
+def get_user_credits_api():
+    """API endpoint to get user credits and plan asynchronously"""
+    if 'username' not in session:
+        return jsonify({"error": "Unauthorized"}), 401
+
+    username = session.get('username', 'Unknown')
+
+    # Get user data from database
+    user = get_user(username)
+    if not user:
+        return jsonify({"error": "User not found"}), 404
+
+    # Return cached credits if available, otherwise use database value
+    cached_credits = get_cached_credits(username)
+    if username in credit_cache:
+        credits = cached_credits
+    else:
+        credits = user['credits']
+        update_credit_cache(username, credits)
+
+    return jsonify({
+        "credits": credits,
+        "plan": user['plan']
+    })
+
+@app.route('/dashboard')
+def dashboard():
+    if 'username' not in session:
+        return redirect('/')
+
+    username = session.get('username', 'Unknown')
+    key = f"sk-{hashlib.sha256(username.encode()).hexdigest()[:32]}"
+
+    # Get user data from database
+    user = get_user(username)
+    plan = user['plan'] if user else 'Free'
+
+    try:
+        response = app.test_client().get('/v1/models')
+        models_data = json.loads(response.data.decode('utf-8'))
+        models = models_data['data']
+    except Exception as e:
+        models = []
+
+    return f'''
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <title>Dashboard - GoAPI</title>
+    <style>
+        body {{
+            font-family: 'Inter', sans-serif;
+            max-width: 600px;
+            margin: 50px auto;
+            padding: 30px;
+            text-align: center;
+            background: #f8f9fa;
+            border-radius: 15px;
+            border: 2px solid #000;
+        }}
+        .username {{
+            font-size: 28px;
+            font-weight: 600;
+            color: #333;
+            margin-bottom: 10px;
+        }}
+        .plan-info {{
+            font-size: 16px;
+            color: #666;
+            margin-bottom: 10px;
+            font-weight: 500;
+        }}
+        .credits-info {{
+            font-size: 16px;
+            color: #28a745;
+            margin-bottom: 20px;
+            font-weight: 500;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }}
+        .refresh-btn {{
+            background: none;
+            border: 1px solid #28a745;
+            color: #28a745;
+            width: 24px;
+            height: 24px;
+            border-radius: 50%;
+            cursor: pointer;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 12px;
+            transition: all 0.3s ease;
+        }}
+        .refresh-btn:hover {{
+            background: #28a745;
+            color: white;
+        }}
+        .key-container {{
+            display: flex;
+            align-items: center;
+            margin-bottom: 30px;
+            gap: 10px;
+        }}
+        .key {{
+            font-family: monospace;
+            font-size: 16px;
+            color: #666;
+            background: #fff;
+            padding: 10px;
+            border-radius: 5px;
+            border: 1px solid #ddd;
+            flex: 1;
+            word-break: break-all;
+        }}
+        .copy-btn {{
+            background: #007bff;
+            color: white;
+            border: none;
+            padding: 10px 15px;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 14px;
+            transition: background 0.3s ease;
+        }}
+        .copy-btn:hover {{
+            background: #0056b3;
+        }}
+        .copy-btn.copied {{
+            background: #28a745;
+        }}
+        .logout-btn {{
+            background: #dc3545;
+            color: white;
+            border: none;
+            padding: 12px 30px;
+            border-radius: 8px;
+            font-size: 16px;
+            cursor: pointer;
+            text-decoration: none;
+            display: inline-block;
+            transition: background 0.3s ease;
+        }}
+        .logout-btn i {{
+            margin-right: 8px;
+        }}
+        .chat-btn {{
+            background: #28a745;
+            color: white;
+            border: none;
+            padding: 12px 30px;
+            border-radius: 8px;
+            font-size: 16px;
+            cursor: pointer;
+            text-decoration: none;
+            display: inline-block;
+            transition: background 0.3s ease;
+            margin-right: 15px;
+        }}
+        .chat-btn:hover {{
+            background: #218838;
+        }}
+        .chat-btn i {{
+            margin-right: 8px;
+        }}
+        .chat-modal {{
+            display: none;
+            position: fixed;
+            z-index: 1000;
+            left: 0;
+            top: 0;
+            width: 100%;
+            height: 100%;
+            background-color: rgba(0,0,0,0.8);
+        }}
+        .chat-modal-content {{
+            background-color: #fff;
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            width: 90%;
+            max-width: 800px;
+            height: 80%;
+            border-radius: 12px;
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+        }}
+        .chat-header {{
+            padding: 20px;
+            border-bottom: 1px solid #e9ecef;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+        }}
+        .chat-header h3 {{
+            margin: 0;
+            color: #333;
+        }}
+        .close-chat {{
+            background: none;
+            border: none;
+            font-size: 24px;
+            cursor: pointer;
+            color: #666;
+            padding: 0;
+            width: 30px;
+            height: 30px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }}
+        .chat-controls {{
+            padding: 15px 20px;
+            border-bottom: 1px solid #e9ecef;
+            display: flex;
+            gap: 15px;
+            align-items: center;
+        }}
+        .model-select {{
+            padding: 8px 12px;
+            border: 1px solid #ddd;
+            border-radius: 6px;
+            font-size: 14px;
+            min-width: 200px;
+        }}
+        .chat-messages {{
+            flex: 1;
+            overflow-y: auto;
+            padding: 20px;
+            background: #f8f9fa;
+        }}
+        .message {{
+            margin-bottom: 15px;
+            padding: 12px 16px;
+            border-radius: 8px;
+            max-width: 70%;
+            word-wrap: break-word;
+        }}
+        .message.user {{
+            background: #007bff;
+            color: white;
+        }}
+        .message.assistant {{
+            background: #e9ecef;
+            color: #333;
+        }}
+        .chat-input-area {{
+            padding: 20px;
+            border-top: 1px solid #e9ecef;
+            display: flex;
+            gap: 10px;
+        }}
+        .chat-input {{
+            flex: 1;
+            padding: 12px;
+            border: 1px solid #ddd;
+            border-radius: 6px;
+            font-size: 16px;
+            font-family: 'Inter', sans-serif;
+            resize: none;
+        }}
+        .send-btn {{
+            background: #007bff;
+            color: white;
+            border: none;
+            padding: 12px 20px;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 16px;
+            transition: background 0.3s ease;
+        }}
+        .send-btn:hover {{
+            background: #0056b3;
+        }}
+        .send-btn:disabled {{
+            background: #ccc;
+            cursor: not-allowed;
+        }}
+        .modal {{
+            display: none;
+            position: fixed;
+            z-index: 1000;
+            left: 0;
+            top: 0;
+            width: 100%;
+            height: 100%;
+            background-color: rgba(0,0,0,0.5);
+        }}
+        .modal-content {{
+            background-color: #fff;
+            margin: 15% auto;
+            padding: 30px;
+            border-radius: 10px;
+            width: 90%;
+            max-width: 400px;
+            text-align: center;
+            box-shadow: 0 5px 15px rgba(0,0,0,0.3);
+        }}
+        .modal h3 {{
+            margin-top: 0;
+            color: #333;
+        }}
+        .modal-buttons {{
+            display: flex;
+            gap: 15px;
+            justify-content: center;
+            margin-top: 25px;
+        }}
+        .modal-btn {{
+            padding: 10px 20px;
+            border: none;
+            border-radius: 5px;
+            cursor: pointer;
+            font-size: 16px;
+            transition: background 0.3s ease;
+        }}
+        .confirm-btn {{
+            background: #dc3545;
+            color: white;
+        }}
+        .confirm-btn:hover {{
+            background: #c82333;
+        }}
+        .cancel-btn {{
+            background: #6c757d;
+            color: white;
+        }}
+        .cancel-btn:hover {{
+            background: #5a6268;
+        }}
+        .models-section {{
+            margin-top: 40px;
+            text-align: left;
+        }}
+        .models-section h3 {{
+            color: #333;
+            margin-bottom: 20px;
+            font-size: 24px;
+        }}
+        .search-container {{
+            margin-bottom: 20px;
+        }}
+        .search-input {{
+            width: 100%;
+            padding: 12px;
+            border: 2px solid #ddd;
+            border-radius: 8px;
+            font-size: 16px;
+            font-family: 'Inter', sans-serif;
+        }}
+        .search-input:focus {{
+            outline: none;
+            border-color: #007bff;
+        }}
+        .models-list {{
+            list-style: none;
+            padding: 0;
+            margin: 0;
+        }}
+        .model-item {{
+            background: #f8f9fa;
+            border: 1px solid #e9ecef;
+            border-radius: 8px;
+            padding: 15px;
+            margin-bottom: 10px;
+            transition: background 0.3s ease;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }}
+        .model-item:hover {{
+            background: #e9ecef;
+        }}
+        .model-info {{
+            flex: 1;
+        }}
+        .model-name {{
+            font-weight: 600;
+            color: #333;
+            margin-bottom: 5px;
+        }}
+        .model-id {{
+            color: #666;
+            font-family: monospace;
+            font-size: 14px;
+        }}
+        .model-multiplier {{
+            font-weight: 600;
+            color: #007bff;
+            font-size: 14px;
+            background: #e7f3ff;
+            padding: 4px 8px;
+            border-radius: 4px;
+        }}
+        .no-models {{
+            text-align: center;
+            color: #666;
+            padding: 40px;
+            font-style: italic;
+        }}
+    </style>
+</head>
+<body>
+    <div class="username">{username}</div>
+    <div class="plan-info">Plan: {plan.title()}</div>
+    <div class="credits-info" id="creditsDisplay">
+        Credits: <span id="creditsValue">Loading...</span>
+        <button onclick="loadCredits()" class="refresh-btn" title="Refresh Credits">
+            <i class="fas fa-sync-alt"></i>
+        </button>
+    </div>
+    <div class="key-container">
+        <div class="key" id="api-key">{key}</div>
+        <button class="copy-btn" onclick="copyToClipboard()"><i class="fas fa-copy"></i></button>
+    </div>
+
+    <div class="models-section">
+        <h3>Available Models</h3>
+        <div class="search-container">
+            <input type="text" class="search-input" id="searchInput" placeholder="Search models..." onkeyup="filterModels()">
+        </div>
+        <ul class="models-list" id="modelsList">
+            {"".join([f'<li class="model-item"><div class="model-info"><div class="model-name">{model["id"].replace("-", " ").title().replace("Gpt", "GPT")}</div><div class="model-id">{model["id"]}</div></div><div class="model-multiplier">{MODEL_MULTIPLIERS.get(model["id"], 1.0):.1f}x</div></li>' for model in models])}
+        </ul>
+        {"<div class='no-models'>No models found</div>" if not models else ""}
+    </div>
+
+    <button onclick="showChatModal()" class="chat-btn"><i class="fas fa-comments"></i> Chat</button>
+    <button onclick="showLogoutModal()" class="logout-btn"><i class="fas fa-sign-out-alt"></i> Logout</button>
+
+    <div id="logoutModal" class="modal">
+        <div class="modal-content">
+            <h3>Confirm Logout</h3>
+            <p>Are you sure you want to logout?</p>
+            <div class="modal-buttons">
+                <button onclick="confirmLogout()" class="modal-btn confirm-btn">Logout</button>
+                <button onclick="hideLogoutModal()" class="modal-btn cancel-btn">Cancel</button>
+            </div>
+        </div>
+    </div>
+
+    <div id="chatModal" class="chat-modal">
+        <div class="chat-modal-content">
+            <div class="chat-header">
+                <h3>Chat with AI</h3>
+                <button onclick="hideChatModal()" class="close-chat">&times;</button>
+            </div>
+            <div class="chat-controls">
+                <select class="model-select" id="modelSelect">
+                    {"".join([f'<option value="{model["id"]}">{model["id"].replace("-", " ").title().replace("Gpt", "GPT")}</option>' for model in models])}
+                </select>
+            </div>
+            <div class="chat-messages" id="chatMessages"></div>
+            <div class="chat-input-area">
+                <textarea class="chat-input" id="chatInput" placeholder="Type your message..." rows="1" onkeypress="handleKeyPress(event)"></textarea>
+                <button onclick="sendMessage()" class="send-btn" id="sendBtn">Send</button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        function copyToClipboard() {{
+            const keyElement = document.getElementById('api-key');
+            const keyText = keyElement.textContent;
+            navigator.clipboard.writeText(keyText).then(() => {{
+                const copyBtn = document.querySelector('.copy-btn');
+                copyBtn.innerHTML = '<i class="fas fa-check"></i>';
+                copyBtn.classList.add('copied');
+                setTimeout(() => {{
+                    copyBtn.innerHTML = '<i class="fas fa-copy"></i>';
+                    copyBtn.classList.remove('copied');
+                }}, 2000);
+            }});
+        }}
+
+        function showLogoutModal() {{
+            document.getElementById('logoutModal').style.display = 'block';
+        }}
+
+        function hideLogoutModal() {{
+            document.getElementById('logoutModal').style.display = 'none';
+        }}
+
+        function confirmLogout() {{
+            window.location.href = '/logout';
+        }}
+
+        window.onclick = function(event) {{
+            const modal = document.getElementById('logoutModal');
+            if (event.target == modal) {{
+                hideLogoutModal();
+            }}
+        }}
+
+        async function loadCredits() {{
+            try {{
+                const response = await fetch('/api/user/credits');
+                if (response.ok) {{
+                    const data = await response.json();
+                    document.getElementById('creditsValue').textContent = data.credits.toLocaleString();
+                }} else {{
+                    document.getElementById('creditsValue').textContent = 'Error loading credits';
+                }}
+            }} catch (error) {{
+                console.error('Error loading credits:', error);
+                document.getElementById('creditsValue').textContent = 'Error loading credits';
+            }}
+        }}
+
+        // Load credits when page loads
+        document.addEventListener('DOMContentLoaded', loadCredits);
+
+        function filterModels() {{
+            const input = document.getElementById('searchInput');
+            const filter = input.value.toLowerCase();
+            const modelsList = document.getElementById('modelsList');
+            const models = modelsList.getElementsByTagName('li');
+
+            for (let i = 0; i < models.length; i++) {{
+                const modelName = models[i].getElementsByClassName('model-name')[0];
+                const modelId = models[i].getElementsByClassName('model-id')[0];
+                const nameText = modelName.textContent || modelName.innerText;
+                const idText = modelId.textContent || modelId.innerText;
+
+                if (nameText.toLowerCase().indexOf(filter) > -1 || idText.toLowerCase().indexOf(filter) > -1) {{
+                    models[i].style.display = '';
+                }} else {{
+                    models[i].style.display = 'none';
+                }}
+            }}
+        }}
+
+        let messages = [];
+
+        function showChatModal() {{
+            document.getElementById('chatModal').style.display = 'block';
+            document.getElementById('chatInput').focus();
+        }}
+
+        function hideChatModal() {{
+            document.getElementById('chatModal').style.display = 'none';
+        }}
+
+        function handleKeyPress(event) {{
+            if (event.key === 'Enter' && !event.shiftKey) {{
+                event.preventDefault();
+                sendMessage();
+            }}
+        }}
+
+        async function sendMessage(retryCount = 0) {{
+            const input = document.getElementById('chatInput');
+            const message = input.value.trim();
+            if (!message && retryCount === 0) return; // Only check for empty message on first attempt
+
+            const modelSelect = document.getElementById('modelSelect');
+            const model = modelSelect.value;
+            const apiKey = document.getElementById('api-key').textContent;
+
+            const sendBtn = document.getElementById('sendBtn');
+            const originalText = sendBtn.textContent;
+            sendBtn.disabled = true;
+            sendBtn.textContent = 'Sending...';
+
+            // Add user message to conversation (only on first attempt)
+            if (retryCount === 0) {{
+                messages.push({{role: 'user', content: message}});
+                addMessage(message, 'user');
+                input.value = '';
+            }}
+
+            try {{
+                const messagesData = messages.map(msg => ({{
+                    role: msg.role,
+                    content: msg.content
+                }}));
+
+                const response = await fetch('/v1/chat/completions', {{
+                    method: 'POST',
+                    headers: {{
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${{apiKey}}`
+                    }},
+                    body: JSON.stringify({{
+                        model: model,
+                        messages: messagesData,
+                        stream: true
+                    }})
+                }});
+
+                if (!response.ok) {{
+                    throw new Error(`HTTP error! status: ${{response.status}}`);
+                }}
+
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let assistantMessage = '';
+
+                while (true) {{
+                    const {{done, value}} = await reader.read();
+                    if (done) break;
+
+                    const chunk = decoder.decode(value);
+                    const lines = chunk.split('\\n');
+
+                    for (const line of lines) {{
+                        if (line.startsWith('data: ')) {{
+                            const data = line.slice(6);
+                            if (data === '[DONE]') {{
+                                // Check if we got actual content or just [DONE]
+                                if (!assistantMessage.trim()) {{
+                                    console.log('Received empty response with [DONE], retrying...');
+                                    if (retryCount < 3) {{
+                                        console.log(`Retry attempt ${{retryCount + 1}}/3`);
+                                        // Wait a bit before retrying
+                                        await new Promise(resolve => setTimeout(resolve, 1000));
+                                        return sendMessage(retryCount + 1);
+                                    }} else {{
+                                        console.log('Max retries reached, showing error');
+                                        addMessage('Request failed after multiple retries. Please try again.', 'assistant');
+                                        messages.push({{role: 'assistant', content: 'Request failed after multiple retries. Please try again.'}});
+                                        return;
+                                    }}
+                                }}
+                                // Add complete assistant message to conversation
+                                messages.push({{role: 'assistant', content: assistantMessage}});
+                                break;
+                            }}
+
+                            try {{
+                                const parsed = JSON.parse(data);
+                                const content = parsed.choices[0]?.delta?.content;
+                                if (content) {{
+                                    assistantMessage += content;
+                                    updateLastMessage(assistantMessage, 'assistant');
+                                }}
+                            }} catch (e) {{
+                                console.log('Parse error:', e);
+                            }}
+                        }}
+                    }}
+                }}
+            }} catch (error) {{
+                console.error('Error:', error);
+                const errorMsg = 'Sorry, there was an error processing your request.';
+                addMessage(errorMsg, 'assistant');
+                messages.push({{role: 'assistant', content: errorMsg}});
+            }} finally {{
+                sendBtn.disabled = false;
+                sendBtn.textContent = originalText;
+            }}
+        }}
+
+        function addMessage(content, type) {{
+            const messagesDiv = document.getElementById('chatMessages');
+            const messageDiv = document.createElement('div');
+            messageDiv.className = `message ${{type}}`;
+            messageDiv.textContent = content;
+            messagesDiv.appendChild(messageDiv);
+            messagesDiv.scrollTop = messagesDiv.scrollHeight;
+        }}
+
+        function updateLastMessage(content, type) {{
+            const messagesDiv = document.getElementById('chatMessages');
+            let lastMessage = messagesDiv.lastElementChild;
+
+            if (!lastMessage || !lastMessage.classList.contains(type)) {{
+                lastMessage = document.createElement('div');
+                lastMessage.className = `message ${{type}}`;
+                messagesDiv.appendChild(lastMessage);
+            }}
+
+            lastMessage.textContent = content;
+            messagesDiv.scrollTop = messagesDiv.scrollHeight;
+        }}
+    </script>
+</body>
+</html>
+'''
+
+@app.route('/')
+def hello_world():
+    try:
+        response = app.test_client().get('/v1/models')
+        models_data = json.loads(response.data.decode('utf-8'))
+
+        model_items = []
+        for model in models_data['data']:
+            display_name = model['id'].replace('-', ' ').title().replace('Gpt', 'GPT')
+            model_items.append(f'<li>{display_name}</li>')
+
+        models_html = '\n        '.join(model_items)
+
+    except Exception as e:
+        models_html = '<li>Error loading models</li>'
+
+    return f'''
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" rel="stylesheet">
+    <title>GoAPI</title>
+    <style>
+        body {{
+            max-width: 800px;
+            margin: 50px auto 0 auto;
+            padding: 20px;
+            border: 2px solid #000;
+            border-radius: 10px;
+            text-align: center;
+            font-family: 'Inter', sans-serif;
+        }}
+        .pricing {{
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin: 30px 0;
+            text-align: center;
+        }}
+        .plan {{
+            padding: 20px;
+            border: 1px solid #ccc;
+            border-radius: 5px;
+        }}
+        .plan h3 {{
+            margin: 0 0 10px 0;
+        }}
+        .price {{
+            font-size: 24px;
+            font-weight: bold;
+            margin: 10px 0;
+        }}
+        .features {{
+            font-size: 14px;
+            color: #666;
+            margin: 10px 0;
+        }}
+        ul {{
+            border: 1px solid #ccc;
+            border-radius: 5px;
+            padding: 10px;
+            list-style-type: none;
+            display: inline-block;
+        }}
+        li {{
+            border-bottom: 1px solid #eee;
+            padding: 5px 0;
+        }}
+        li:last-child {{
+            border-bottom: none;
+        }}
+        a:hover {{
+            background-color: #333;
+            color: white;
+        }}
+    </style>
+</head>
+<body>
+    <h1>GoAPI</h1>
+
+
+      
+    </div>
+
+    <a href="/auth" style="background-color: transparent; color: #333; border: 2px solid #333; padding: 10px 20px; border-radius: 0; font-size: 16px; cursor: pointer; margin: 20px 0; transition: all 0.2s ease; text-decoration: none; display: inline-block;">Get Started</a>
+    <h2>Model List</h2>
+    <ul>
+        {models_html}
+    </ul>
+        <div class="pricing">
+        <div class="plan">
+            <h3>Free</h3>
+            <div class="price">$0/month</div>
+            <div class="features">500,000 daily tokens</div>
+            <a href="/auth" style="background-color: transparent; color: #333; border: 2px solid #333; padding: 10px 20px; border-radius: 15px; font-size: 16px; cursor: pointer; margin: 20px 0; transition: all 0.2s ease; text-decoration: none; display: inline-block;">Get Started</a>
+        </div>
+        <div class="plan">
+            <h3>Explorer</h3>
+            <div class="price">$4.99/month</div>
+            <div class="features">5 million daily tokens</div>
+            <button style="background-color: transparent; color: #666; border: 2px solid #ccc; padding: 10px 20px; border-radius: 15px; font-size: 16px; cursor: not-allowed; margin: 20px 0; text-decoration: none; display: inline-block;" disabled>Coming Soon</button>
+        </div>
+        <div class="plan">
+            <h3>Voyager</h3>
+            <div class="price">$19.99/month</div>
+            <div class="features">50 million daily tokens</div>
+            <button style="background-color: transparent; color: #666; border: 2px solid #ccc; padding: 10px 20px; border-radius: 15px; font-size: 16px; cursor: not-allowed; margin: 20px 0; text-decoration: none; display: inline-block;" disabled>Coming Soon</button>
+        </div>
+</body>
+
+</html>
+'''
+
+@app.route('/admin/process-pending-deductions')
+def process_deductions_now():
+    """Admin endpoint to manually process pending deductions"""
+    if request.remote_addr != '127.0.0.1':  # Only allow from localhost
+        return jsonify({"error": "Unauthorized"}), 403
+
+    # Run in background thread to avoid blocking the response
+    threading.Thread(target=process_pending_deductions, daemon=True).start()
+    return jsonify({"message": "Pending deductions processing started"})
+
+@atexit.register
+def cleanup_pending_deductions():
+    """Process any remaining pending deductions when the app shuts down"""
+    if pending_deductions:
+        print("Processing remaining pending deductions on shutdown...")
+        # Run in a separate thread to avoid blocking shutdown
+        cleanup_thread = threading.Thread(target=process_pending_deductions, daemon=True)
+        cleanup_thread.start()
+        cleanup_thread.join(timeout=5)  # Wait up to 5 seconds for completion
+
+if __name__ == '__main__':
+    # Start the background timer when the app starts
+    start_batch_timer()
+    app.run(debug=True)