Update app.py

app.py

@@ -1,104 +1,187 @@
-# app.py - Sixfinger Multi-Model Backend with Thinking Models & Auto-Fallback
+# app.py - Sixfinger Groq Backend (Allam-2-7B Eklendi)
 import json
 import os
-import random
 from datetime import datetime
-from flask import Flask, request, jsonify, Response, render_template_string
-from huggingface_hub import InferenceClient
+from flask import Flask, request, jsonify, Response
+from groq import Groq
 import traceback
 
 app = Flask(__name__)
 app.config['JSON_AS_ASCII'] = False
 
 # ========== CONFIGURATION ==========
-HF_TOKEN = os.getenv("HF_TOKEN")
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 PORT = int(os.getenv("PORT", 7860))
-MAX_RETRIES = 5
+
+if not GROQ_API_KEY:
+    raise ValueError("❌ GROQ_API_KEY environment variable gerekli!")
+
+groq_client = Groq(api_key=GROQ_API_KEY)
 
 # ========== MODEL CATEGORIES ==========
 
-# THINKING MODELS
-THINKING_MODELS = {
-    'deepseek-r1': {
-        'id': 'deepseek-ai/DeepSeek-R1',
-        'description': 'DeepSeek Reasoning Model (Thinking Process)',
-        'size': '671B',
-        'supports_thinking': True
+# FREE PLAN MODELS (Yüksek limitli)
+FREE_MODELS = {
+    'llama-8b-instant': {
+        'id': 'llama-3.1-8b-instant',
+        'description': 'Llama 3.1 8B Instant (Ultra Fast)',
+        'rpm': 30,
+        'rpd': 14400,  # ⭐ EN YÜKSEK
+        'tpm': 14400,
+        'tpd': 6000000,
+        'size': '8B',
+        'speed': '⚡⚡⚡',
+        'plan_required': 'free',
+        'language': 'Multilingual'
     },
-    'qwen3-vl-235b-thinking': {
-        'id': 'Qwen/Qwen3-VL-235B-A22B-Thinking',
-        'description': 'Qwen3 VL Thinking (Multimodal Reasoning)',
-        'size': '235B (22B active)',
-        'supports_thinking': True
+    'allam-2-7b': {
+        'id': 'allam-2-7b',
+        'description': 'Allam 2 7B (Arabic/Turkish Optimized)',  # ✅ EKLENDI
+        'rpm': 30,
+        'rpd': 300,
+        'tpm': 7000,
+        'tpd': 60000,
+        'size': '7B',
+        'speed': '⚡⚡',
+        'plan_required': 'free',
+        'language': 'Arabic/Turkish'
+    }
+}
+
+# PAID PLAN MODELS (Güçlü ama düşük limit)
+PAID_MODELS = {
+    'llama-70b': {
+        'id': 'llama-3.3-70b-versatile',
+        'description': 'Llama 3.3 70B Versatile (Powerful)',
+        'rpm': 30,
+        'rpd': 1000,
+        'tpm': 1000,
+        'tpd': 12000000,
+        'size': '70B',
+        'speed': '⚡⚡',
+        'plan_required': 'starter',
+        'language': 'Multilingual'
     },
-    'qwen3-vl-32b-thinking': {
-        'id': 'Qwen/Qwen3-VL-32B-Thinking',
-        'description': 'Qwen3 VL Thinking (Compact)',
+    'qwen3-32b': {
+        'id': 'qwen/qwen3-32b',
+        'description': 'Qwen3 32B (Türkçe Optimized)',
+        'rpm': 60,
+        'rpd': 1000,
+        'tpm': 1000,
+        'tpd': 6000000,
         'size': '32B',
-        'supports_thinking': True
+        'speed': '⚡⚡',
+        'plan_required': 'starter',
+        'language': 'Turkish/Chinese'
     },
     'gpt-oss-120b': {
         'id': 'openai/gpt-oss-120b',
-        'description': 'GPT OSS 120B',
+        'description': 'GPT OSS 120B (Giant)',
+        'rpm': 30,
+        'rpd': 1000,
+        'tpm': 1000,
+        'tpd': 8000000,
         'size': '120B',
-        'supports_thinking': False
-    }
-}
-
-# NORMAL MODELS
-NORMAL_MODELS = {
-    'qwen-72b': {
-        'id': 'Qwen/Qwen2.5-72B-Instruct',
-        'description': 'Qwen 2.5 (Mükemmel Türkçe)',
-        'size': '72B'
+        'speed': '⚡⚡',
+        'plan_required': 'pro',
+        'language': 'Multilingual'
     },
-    'qwen-32b': {
-        'id': 'Qwen/Qwen2.5-32B-Instruct',
-        'description': 'Qwen 2.5 Compact',
-        'size': '32B'
+    'llama-maverick-17b': {
+        'id': 'meta-llama/llama-4-maverick-17b-128e-instruct',
+        'description': 'Llama 4 Maverick 17B (Latest)',
+        'rpm': 30,
+        'rpd': 1000,
+        'tpm': 1000,
+        'tpd': 6000000,
+        'size': '17B',
+        'speed': '⚡⚡',
+        'plan_required': 'starter',
+        'language': 'Multilingual'
     },
-    'qwen3-vl-235b-instruct': {
-        'id': 'Qwen/Qwen3-VL-235B-A22B-Instruct',
-        'description': 'Qwen3 VL Instruct (Multimodal)',
-        'size': '235B (22B active)'
-    },
-    'llama-70b': {
-        'id': 'meta-llama/Meta-Llama-3.1-70B-Instruct',
-        'description': 'Meta Llama 3.1',
-        'size': '70B'
+    'llama-scout-17b': {
+        'id': 'meta-llama/llama-4-scout-17b-16e-instruct',
+        'description': 'Llama 4 Scout 17B (Fast)',
+        'rpm': 30,
+        'rpd': 1000,
+        'tpm': 1000,
+        'tpd': 30000000,  # Çok yüksek token limit!
+        'size': '17B',
+        'speed': '⚡⚡⚡',
+        'plan_required': 'starter',
+        'language': 'Multilingual'
     },
-    'mixtral-8x7b': {
-        'id': 'mistralai/Mixtral-8x7B-Instruct-v0.1',
-        'description': 'Mixtral MoE',
-        'size': '8x7B'
+    'gpt-oss-20b': {
+        'id': 'openai/gpt-oss-20b',
+        'description': 'GPT OSS 20B (Compact)',
+        'rpm': 30,
+        'rpd': 1000,
+        'tpm': 1000,
+        'tpd': 8000000,
+        'size': '20B',
+        'speed': '⚡⚡',
+        'plan_required': 'starter',
+        'language': 'Multilingual'
     },
-    'gemma-27b': {
-        'id': 'google/gemma-2-27b-it',
-        'description': 'Google Gemma 2',
-        'size': '27B'
+    'kimi-k2': {
+        'id': 'moonshotai/kimi-k2-instruct',
+        'description': 'Kimi K2 Instruct (Chinese)',
+        'rpm': 60,
+        'rpd': 1000,
+        'tpm': 1000,
+        'tpd': 10000000,
+        'size': 'Unknown',
+        'speed': '⚡⚡',
+        'plan_required': 'pro',
+        'language': 'Chinese/Multilingual'
     }
 }
 
-# ========== SYSTEM PROMPTS ==========
-SYSTEM_PROMPTS = {
-    'sixfinger': """Sen Sixfinger'sın. 
-- İstanbul delikanlısı gibi konuşursun
-- Samimi, esprili ve sokak argosunu kullanırsın
-- Kısa ve net cevaplar verirsin
-- "Kanka", "lan", "abi", "reis", "kral" gibi kelimeler kullanırsın
-- Dozında küfür edebilirsin ama aşırıya kaçmazsın
-- Türkçe dışına çıkmazsın""",
-    
-    'assistant': """Sen yardımsever bir AI asistanısın.
-- Türkçe'yi mükemmel kullanırsın
-- Detaylı ve açıklayıcı cevaplar verirsin
-- Profesyonel ama samimi bir dil kullanırsın""",
+# TÜM MODELLER
+ALL_MODELS = {**FREE_MODELS, **PAID_MODELS}
+
+# DEFAULT MODEL PRIORITY (fallback için)
+MODEL_PRIORITY = [
+    # FREE (önce en yüksek limitli)
+    'llama-8b-instant',      # 14,400 RPD (FREE için ana)
+    'allam-2-7b',            # 300 RPD (FREE için yedek)
     
-    'thinking': """Sen derin düşünen bir AI'sın.
-- Adım adım düşünürsün (chain-of-thought)
-- Problemleri analiz edersin
-- Reasoning sürecini gösterirsin
-- Türkçe'de mükemmel açıklamalar yaparsın"""
+    # PAID (güçlüden zayıfa)
+    'llama-70b',             # 70B (en güçlü genel amaçlı)
+    'gpt-oss-120b',          # 120B (giant)
+    'qwen3-32b',             # 32B (Türkçe)
+    'llama-scout-17b',       # 17B (hızlı + yüksek token limit)
+    'llama-maverick-17b',    # 17B (son model)
+    'gpt-oss-20b',           # 20B
+    'kimi-k2'                # Chinese
+]
+
+# ========== PLAN - MODEL MAPPING ==========
+PLAN_ALLOWED_MODELS = {
+    'free': [
+        'llama-8b-instant',  # Ana model (14.4K/gün)
+        'allam-2-7b'         # Yedek/alternatif (300/gün)
+    ],
+    'starter': [
+        'llama-8b-instant',
+        'allam-2-7b',
+        'qwen3-32b',         # Türkçe için
+        'llama-70b',         # Güçlü model
+        'llama-maverick-17b',
+        'llama-scout-17b',
+        'gpt-oss-20b'
+    ],
+    'pro': [
+        'llama-8b-instant',
+        'allam-2-7b',
+        'qwen3-32b',
+        'llama-70b',
+        'llama-maverick-17b',
+        'llama-scout-17b',
+        'gpt-oss-20b',
+        'gpt-oss-120b',      # Giant model
+        'kimi-k2'            # Chinese model
+    ],
+    'plus': list(ALL_MODELS.keys())  # Tüm modeller
 }
 
 # ========== STATISTICS ==========
@@ -112,201 +195,221 @@ stats = {
     'start_time': datetime.utcnow()
 }
 
-model_clients = {}
-
 # ========== HELPER FUNCTIONS ==========
 
-def get_client(model_id):
-    """Get or create client for model"""
-    if model_id in model_clients:
-        return model_clients[model_id]
+def get_allowed_models(user_plan='free', preferred_model=None):
+    """Kullanıcının planına göre izinli modelleri döndür"""
+    allowed = PLAN_ALLOWED_MODELS.get(user_plan, ['llama-8b-instant'])
     
-    try:
-        client = InferenceClient(model=model_id, token=HF_TOKEN)
-        model_clients[model_id] = client
-        return client
-    except Exception as e:
-        print(f"❌ Failed to create client for {model_id}: {e}")
-        return None
-
-def select_random_model(use_thinking=False):
-    """Rastgele model seç"""
-    models = THINKING_MODELS if use_thinking else NORMAL_MODELS
-    model_keys = list(models.keys())
-    random.shuffle(model_keys)
-    return model_keys
+    # Preferred model varsa ve izinliyse öncelikli yap
+    if preferred_model and preferred_model in allowed:
+        models = [preferred_model] + [m for m in allowed if m != preferred_model]
+    else:
+        # MODEL_PRIORITY'ye göre sırala
+        models = [m for m in MODEL_PRIORITY if m in allowed]
+    
+    return models
 
 def try_model(model_key, messages, max_tokens, temperature, top_p, stream=False):
     """Bir model'i dene"""
-    if model_key in THINKING_MODELS:
-        model_info = THINKING_MODELS[model_key]
-    elif model_key in NORMAL_MODELS:
-        model_info = NORMAL_MODELS[model_key]
-    else:
+    if model_key not in ALL_MODELS:
         return None, f"Unknown model: {model_key}"
     
+    model_info = ALL_MODELS[model_key]
     model_id = model_info['id']
     
     try:
-        client = get_client(model_id)
-        if not client:
-            return None, "Client creation failed"
-        
         if stream:
-            return client.chat_completion(
-                messages=messages, max_tokens=max_tokens,
-                temperature=temperature, top_p=top_p, stream=True
-            ), None
+            response = groq_client.chat.completions.create(
+                model=model_id,
+                messages=messages,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                stream=True
+            )
+            
+            stats['model_usage'][model_key] = stats['model_usage'].get(model_key, 0) + 1
+            return response, None
         else:
-            response = client.chat_completion(
-                messages=messages, max_tokens=max_tokens,
-                temperature=temperature, top_p=top_p
+            response = groq_client.chat.completions.create(
+                model=model_id,
+                messages=messages,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                top_p=top_p
             )
+            
             stats['model_usage'][model_key] = stats['model_usage'].get(model_key, 0) + 1
             return response, None
     
     except Exception as e:
         error_msg = str(e)
         stats['model_failures'][model_key] = stats['model_failures'].get(model_key, 0) + 1
+        
         print(f"❌ Model {model_key} failed: {error_msg}")
         
-        if 'rate limit' in error_msg.lower() or 'quota' in error_msg.lower():
-            return None, f"Rate limit/Quota exceeded"
+        if 'rate_limit' in error_msg.lower() or 'rate limit' in error_msg.lower():
+            return None, "Rate limit exceeded"
+        elif 'quota' in error_msg.lower():
+            return None, "Quota exceeded"
         elif 'timeout' in error_msg.lower():
-            return None, f"Timeout"
+            return None, "Timeout"
         else:
-            return None, f"Error: {error_msg}"
+            return None, f"Error: {error_msg[:150]}"
 
-def format_messages(system_prompt, user_message, history=None):
+def format_messages(prompt, system_prompt=None, history=None):
     """Format messages"""
-    messages = [{"role": "system", "content": system_prompt}]
+    messages = []
+    
+    if system_prompt:
+        messages.append({"role": "system", "content": system_prompt})
+    else:
+        # Default system prompt
+        messages.append({
+            "role": "system",
+            "content": "Sen yardımsever ve bilgili bir AI asistanısın. Türkçe'yi mükemmel kullanırsın."
+        })
+    
     if history:
         messages.extend(history)
-    messages.append({"role": "user", "content": user_message})
-    return messages
-
-def extract_thinking_process(response_text):
-    """Extract thinking process"""
-    if '<think>' in response_text and '</think>' in response_text:
-        start = response_text.find('<think>') + 7
-        end = response_text.find('</think>')
-        thinking = response_text[start:end].strip()
-        answer = response_text[end+8:].strip()
-        return thinking, answer
     
-    if '<reasoning>' in response_text and '</reasoning>' in response_text:
-        start = response_text.find('<reasoning>') + 11
-        end = response_text.find('</reasoning>')
-        thinking = response_text[start:end].strip()
-        answer = response_text[end+12:].strip()
-        return thinking, answer
+    messages.append({"role": "user", "content": prompt})
     
-    return None, response_text
+    return messages
 
 # ========== ROUTES ==========
 
 @app.route('/')
 def index():
-    """Documentation Homepage"""
+    """API Documentation"""
     uptime = datetime.utcnow() - stats['start_time']
     uptime_str = str(uptime).split('.')[0]
     
-    success_rate = (stats['successful_requests'] / max(stats['total_requests'], 1) * 100)
-    
-    return render_template_string(DOCUMENTATION_HTML,
-                                 uptime=uptime_str,
-                                 total_requests=stats['total_requests'],
-                                 successful_requests=stats['successful_requests'],
-                                 failed_requests=stats['failed_requests'],
-                                 success_rate=f"{success_rate:.1f}",
-                                 fallback_count=stats['fallback_count'],
-                                 thinking_models=THINKING_MODELS,
-                                 normal_models=NORMAL_MODELS,
-                                 model_usage=stats['model_usage'],
-                                 model_failures=stats['model_failures'])
-
-@app.route('/api/info')
-def api_info():
-    """API Info (JSON)"""
-    uptime = datetime.utcnow() - stats['start_time']
-    
     return jsonify({
-        'name': 'Sixfinger Multi-Model Backend',
-        'version': '3.0.0',
+        'name': 'Sixfinger Groq Backend',
+        'version': '4.0.1',
         'status': 'online',
-        'uptime': str(uptime).split('.')[0],
-        'stats': stats,
-        'model_categories': {
-            'thinking_models': len(THINKING_MODELS),
-            'normal_models': len(NORMAL_MODELS)
+        'provider': 'Groq',
+        'uptime': uptime_str,
+        'models': {
+            'free': [
+                {'key': k, 'rpd': v['rpd'], 'language': v['language']} 
+                for k, v in FREE_MODELS.items()
+            ],
+            'paid': [
+                {'key': k, 'rpd': v['rpd'], 'plan': v['plan_required']} 
+                for k, v in PAID_MODELS.items()
+            ],
+            'total': len(ALL_MODELS)
+        },
+        'stats': {
+            'total_requests': stats['total_requests'],
+            'successful': stats['successful_requests'],
+            'failed': stats['failed_requests'],
+            'success_rate': f"{(stats['successful_requests'] / max(stats['total_requests'], 1) * 100):.2f}%",
+            'fallback_count': stats['fallback_count']
+        },
+        'endpoints': {
+            'chat': 'POST /api/chat',
+            'chat_stream': 'POST /api/chat/stream',
+            'models': 'GET /api/models',
+            'stats': 'GET /api/stats',
+            'health': 'GET /health'
+        },
+        'headers': {
+            'X-Model': 'Preferred model key (optional)',
+            'X-User-Plan': 'User plan: free, starter, pro, plus (default: free)'
         }
     })
 
 @app.route('/api/models')
 def list_models():
-    """List all models"""
+    """List all models with details"""
     return jsonify({
-        'thinking_models': [
+        'free_models': [
             {
                 'key': key,
                 'model_id': info['id'],
                 'description': info['description'],
                 'size': info['size'],
+                'speed': info['speed'],
+                'language': info['language'],
+                'limits': {
+                    'rpm': info['rpm'],
+                    'rpd': info['rpd'],
+                    'tpm': info['tpm'],
+                    'tpd': info['tpd']
+                },
                 'usage_count': stats['model_usage'].get(key, 0),
                 'failure_count': stats['model_failures'].get(key, 0)
             }
-            for key, info in THINKING_MODELS.items()
+            for key, info in FREE_MODELS.items()
         ],
-        'normal_models': [
+        'paid_models': [
             {
                 'key': key,
                 'model_id': info['id'],
                 'description': info['description'],
                 'size': info['size'],
+                'speed': info['speed'],
+                'language': info['language'],
+                'plan_required': info['plan_required'],
+                'limits': {
+                    'rpm': info['rpm'],
+                    'rpd': info['rpd'],
+                    'tpm': info['tpm'],
+                    'tpd': info['tpd']
+                },
                 'usage_count': stats['model_usage'].get(key, 0),
                 'failure_count': stats['model_failures'].get(key, 0)
             }
-            for key, info in NORMAL_MODELS.items()
-        ]
+            for key, info in PAID_MODELS.items()
+        ],
+        'plan_permissions': PLAN_ALLOWED_MODELS
     })
 
 @app.route('/api/chat', methods=['POST'])
 def chat():
-    """Chat with auto-fallback"""
+    """Chat endpoint (non-streaming)"""
     stats['total_requests'] += 1
     
     try:
         data = request.json
-        if not data:
-            stats['failed_requests'] += 1
-            return jsonify({'error': 'JSON body required'}), 400
-        
-        prompt = data.get('prompt') or data.get('message')
-        if not prompt:
+        if not data or 'prompt' not in data:
             stats['failed_requests'] += 1
             return jsonify({'error': 'prompt required'}), 400
         
-        use_thinking = data.get('thinking', False)
+        # Request parameters
+        prompt = data['prompt']
         max_tokens = min(data.get('max_tokens', 1000), 4000)
-        temperature = min(max(data.get('temperature', 0.7), 0.1), 2.0)
+        temperature = min(max(data.get('temperature', 0.7), 0.0), 2.0)
         top_p = min(max(data.get('top_p', 0.9), 0.1), 1.0)
+        system_prompt = data.get('system_prompt')
+        history = data.get('history', [])
         
-        personality = data.get('personality', 'thinking' if use_thinking else 'sixfinger')
-        system_prompt = SYSTEM_PROMPTS.get(personality, SYSTEM_PROMPTS['sixfinger'])
+        # Model selection
+        preferred_model = request.headers.get('X-Model') or data.get('model')
+        user_plan = request.headers.get('X-User-Plan', 'free').lower()
         
-        history = data.get('history', [])
-        messages = format_messages(system_prompt, prompt, history)
+        # Validate plan
+        if user_plan not in PLAN_ALLOWED_MODELS:
+            user_plan = 'free'
+        
+        # Get allowed models
+        models_to_try = get_allowed_models(user_plan, preferred_model)
         
-        model_keys_to_try = select_random_model(use_thinking)
+        # Format messages
+        messages = format_messages(prompt, system_prompt, history)
         
-        last_error = None
+        # Try models
         attempts = []
         
-        for i, model_key in enumerate(model_keys_to_try):
-            if i >= MAX_RETRIES:
+        for i, model_key in enumerate(models_to_try):
+            if i >= 5:  # Max 5 attempts
                 break
             
-            print(f"🔄 Trying model {i+1}/{min(MAX_RETRIES, len(model_keys_to_try))}: {model_key}")
+            print(f"🔄 Trying model {i+1}/{min(5, len(models_to_try))}: {model_key}")
             
             response, error = try_model(model_key, messages, max_tokens, temperature, top_p)
             
@@ -317,50 +420,38 @@ def chat():
             })
             
             if response:
-                response_text = response.choices[0].message.content
-                thinking_process, final_answer = extract_thinking_process(response_text)
-                
-                model_info = THINKING_MODELS.get(model_key) or NORMAL_MODELS.get(model_key)
+                content = response.choices[0].message.content
+                model_info = ALL_MODELS[model_key]
                 
                 stats['successful_requests'] += 1
                 if i > 0:
                     stats['fallback_count'] += 1
                 
-                prompt_tokens = sum(len(m['content'].split()) for m in messages)
-                completion_tokens = len(response_text.split())
-                
                 result = {
-                    'response': final_answer.strip(),
+                    'response': content,
                     'model': model_info['id'],
                     'model_key': model_key,
-                    'model_category': 'thinking' if use_thinking else 'normal',
+                    'model_size': model_info['size'],
+                    'model_language': model_info['language'],
                     'attempts': i + 1,
                     'usage': {
-                        'prompt_tokens': int(prompt_tokens * 1.3),
-                        'completion_tokens': int(completion_tokens * 1.3),
-                        'total_tokens': int((prompt_tokens + completion_tokens) * 1.3)
+                        'prompt_tokens': response.usage.prompt_tokens,
+                        'completion_tokens': response.usage.completion_tokens,
+                        'total_tokens': response.usage.total_tokens
                     },
                     'parameters': {
                         'max_tokens': max_tokens,
                         'temperature': temperature,
-                        'top_p': top_p,
-                        'thinking_enabled': use_thinking
+                        'top_p': top_p
                     }
                 }
                 
-                if thinking_process:
-                    result['thinking_process'] = thinking_process
-                    result['has_thinking'] = True
-                else:
-                    result['has_thinking'] = False
-                
                 if i > 0:
                     result['fallback_attempts'] = attempts
                 
                 return jsonify(result)
             
             else:
-                last_error = error
                 print(f"❌ {model_key} failed: {error}")
                 continue
         
@@ -368,45 +459,52 @@ def chat():
         
         return jsonify({
             'error': 'All models failed',
-            'last_error': last_error,
             'attempts': attempts,
-            'total_attempts': len(attempts)
+            'user_plan': user_plan,
+            'models_tried': [a['model'] for a in attempts]
         }), 503
     
     except Exception as e:
         stats['failed_requests'] += 1
-        return jsonify({'error': str(e), 'traceback': traceback.format_exc()}), 500
+        return jsonify({
+            'error': str(e),
+            'traceback': traceback.format_exc()
+        }), 500
 
 @app.route('/api/chat/stream', methods=['POST'])
 def chat_stream():
-    """Streaming chat with fallback"""
+    """Chat endpoint (streaming)"""
     stats['total_requests'] += 1
     
     try:
         data = request.json
-        if not data:
-            return jsonify({'error': 'JSON body required'}), 400
-        
-        prompt = data.get('prompt') or data.get('message')
-        if not prompt:
+        if not data or 'prompt' not in data:
             return jsonify({'error': 'prompt required'}), 400
         
-        use_thinking = data.get('thinking', False)
+        # Request parameters
+        prompt = data['prompt']
         max_tokens = min(data.get('max_tokens', 1000), 4000)
-        temperature = min(max(data.get('temperature', 0.7), 0.1), 2.0)
+        temperature = min(max(data.get('temperature', 0.7), 0.0), 2.0)
         top_p = min(max(data.get('top_p', 0.9), 0.1), 1.0)
+        system_prompt = data.get('system_prompt')
+        history = data.get('history', [])
         
-        personality = data.get('personality', 'thinking' if use_thinking else 'sixfinger')
-        system_prompt = SYSTEM_PROMPTS.get(personality, SYSTEM_PROMPTS['sixfinger'])
+        # Model selection
+        preferred_model = request.headers.get('X-Model') or data.get('model')
+        user_plan = request.headers.get('X-User-Plan', 'free').lower()
         
-        history = data.get('history', [])
-        messages = format_messages(system_prompt, prompt, history)
+        if user_plan not in PLAN_ALLOWED_MODELS:
+            user_plan = 'free'
         
-        model_keys_to_try = select_random_model(use_thinking)
+        # Get allowed models
+        models_to_try = get_allowed_models(user_plan, preferred_model)
+        
+        # Format messages
+        messages = format_messages(prompt, system_prompt, history)
         
         def generate():
-            for i, model_key in enumerate(model_keys_to_try):
-                if i >= MAX_RETRIES:
+            for i, model_key in enumerate(models_to_try):
+                if i >= 5:
                     break
                 
                 yield f"data: {json.dumps({'info': f'Trying model: {model_key}'}, ensure_ascii=False)}\n\n"
@@ -415,23 +513,21 @@ def chat_stream():
                 
                 if stream_response:
                     try:
-                        for message in stream_response:
-                            chunk = message.choices[0].delta.content
-                            if chunk:
-                                yield f"data: {json.dumps({'text': chunk}, ensure_ascii=False)}\n\n"
+                        for chunk in stream_response:
+                            if chunk.choices[0].delta.content:
+                                text = chunk.choices[0].delta.content
+                                yield f"data: {json.dumps({'text': text}, ensure_ascii=False)}\n\n"
                         
                         stats['successful_requests'] += 1
-                        stats['model_usage'][model_key] = stats['model_usage'].get(model_key, 0) + 1
-                        
                         if i > 0:
                             stats['fallback_count'] += 1
                         
-                        model_info = THINKING_MODELS.get(model_key) or NORMAL_MODELS.get(model_key)
+                        model_info = ALL_MODELS[model_key]
                         yield f"data: {json.dumps({'done': True, 'model': model_info['id'], 'model_key': model_key, 'attempts': i+1})}\n\n"
                         return
                     
                     except Exception as e:
-                        yield f"data: {json.dumps({'error': f'Stream error: {str(e)}'}, ensure_ascii=False)}\n\n"
+                        yield f"data: {json.dumps({'warning': f'Stream error: {str(e)}'}, ensure_ascii=False)}\n\n"
                         continue
                 
                 else:
@@ -490,718 +586,37 @@ def internal_error(e):
 @app.after_request
 def after_request(response):
     response.headers.add('Access-Control-Allow-Origin', '*')
-    response.headers.add('Access-Control-Allow-Headers', 'Content-Type,X-API-Key')
+    response.headers.add('Access-Control-Allow-Headers', 'Content-Type,X-API-Key,X-Model,X-User-Plan')
     response.headers.add('Access-Control-Allow-Methods', 'GET,POST,OPTIONS')
     return response
 
-# ========== HTML DOCUMENTATION ==========
-
-DOCUMENTATION_HTML = """
-<!DOCTYPE html>
-<html lang="tr">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Sixfinger Thinking Backend - API Documentation</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body {
-            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-            background: linear-gradient(135deg, #1e3c72 0%, #2a5298 50%, #7e22ce 100%);
-            color: #333;
-            line-height: 1.6;
-        }
-        .container { max-width: 1400px; margin: 0 auto; padding: 20px; }
-        
-        /* Header */
-        header {
-            background: rgba(255, 255, 255, 0.95);
-            backdrop-filter: blur(10px);
-            padding: 40px;
-            border-radius: 20px;
-            box-shadow: 0 20px 60px rgba(0,0,0,0.3);
-            margin-bottom: 30px;
-            text-align: center;
-        }
-        h1 {
-            color: #7e22ce;
-            font-size: 3em;
-            margin-bottom: 10px;
-            text-shadow: 2px 2px 4px rgba(0,0,0,0.1);
-        }
-        .subtitle {
-            color: #666;
-            font-size: 1.3em;
-            margin-bottom: 20px;
-        }
-        .badge {
-            display: inline-block;
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
-            padding: 8px 20px;
-            border-radius: 25px;
-            font-size: 0.9em;
-            margin: 5px;
-            font-weight: bold;
-        }
-        .badge.thinking { background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%); }
-        .badge.fallback { background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%); }
-        
-        /* Stats Grid */
-        .stats-grid {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-            gap: 20px;
-            margin: 30px 0;
-        }
-        .stat-box {
-            background: rgba(255, 255, 255, 0.95);
-            padding: 25px;
-            border-radius: 15px;
-            text-align: center;
-            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
-            transition: transform 0.3s;
-        }
-        .stat-box:hover { transform: translateY(-10px); }
-        .stat-box h3 {
-            font-size: 2.5em;
-            color: #7e22ce;
-            margin-bottom: 5px;
-        }
-        .stat-box p { color: #666; font-weight: 500; }
-        
-        /* Sections */
-        .section {
-            background: rgba(255, 255, 255, 0.95);
-            backdrop-filter: blur(10px);
-            padding: 40px;
-            border-radius: 20px;
-            box-shadow: 0 20px 60px rgba(0,0,0,0.3);
-            margin-bottom: 30px;
-        }
-        h2 {
-            color: #7e22ce;
-            margin-bottom: 25px;
-            padding-bottom: 15px;
-            border-bottom: 3px solid #f0f0f0;
-            font-size: 2em;
-        }
-        h3 {
-            color: #1e3c72;
-            margin: 25px 0 15px;
-            font-size: 1.5em;
-        }
-        
-        /* Code blocks */
-        code {
-            background: #f8f9fa;
-            padding: 3px 8px;
-            border-radius: 5px;
-            font-family: 'Courier New', monospace;
-            color: #e83e8c;
-            font-size: 0.95em;
-        }
-        pre {
-            background: #1e1e1e;
-            color: #d4d4d4;
-            padding: 25px;
-            border-radius: 12px;
-            overflow-x: auto;
-            margin: 20px 0;
-            border-left: 5px solid #7e22ce;
-            position: relative;
-        }
-        pre code {
-            background: none;
-            color: inherit;
-            padding: 0;
-            font-size: 0.9em;
-        }
-        
-        /* Model Cards */
-        .model-grid {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-            gap: 20px;
-            margin: 20px 0;
-        }
-        .model-card {
-            background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
-            padding: 20px;
-            border-radius: 12px;
-            border-left: 5px solid #7e22ce;
-            transition: all 0.3s;
-        }
-        .model-card:hover {
-            transform: translateX(10px);
-            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
-        }
-        .model-card.thinking {
-            border-left-color: #f5576c;
-            background: linear-gradient(135deg, #ffecd2 0%, #fcb69f 100%);
-        }
-        .model-card h4 {
-            color: #1e3c72;
-            margin-bottom: 10px;
-            font-size: 1.2em;
-        }
-        .model-card .model-id {
-            font-family: monospace;
-            font-size: 0.85em;
-            color: #666;
-            margin: 5px 0;
-        }
-        .model-card .stats {
-            display: flex;
-            justify-content: space-between;
-            margin-top: 10px;
-            font-size: 0.9em;
-        }
-        .model-card .stats span {
-            padding: 5px 10px;
-            background: rgba(255,255,255,0.5);
-            border-radius: 5px;
-        }
-        
-        /* Tables */
-        table {
-            width: 100%;
-            border-collapse: collapse;
-            margin: 20px 0;
-        }
-        th, td {
-            padding: 15px;
-            text-align: left;
-            border-bottom: 1px solid #e0e0e0;
-        }
-        th {
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
-            font-weight: 600;
-        }
-        tr:hover { background: #f8f9fa; }
-        
-        /* Info boxes */
-        .info-box {
-            background: #e7f3ff;
-            border-left: 5px solid #2196F3;
-            padding: 20px;
-            margin: 20px 0;
-            border-radius: 8px;
-        }
-        .success-box {
-            background: #d4edda;
-            border-left: 5px solid #28a745;
-            padding: 20px;
-            margin: 20px 0;
-            border-radius: 8px;
-        }
-        .warning-box {
-            background: #fff3cd;
-            border-left: 5px solid #ffc107;
-            padding: 20px;
-            margin: 20px 0;
-            border-radius: 8px;
-        }
-        
-        /* Tabs */
-        .tabs {
-            display: flex;
-            gap: 10px;
-            margin-bottom: 20px;
-        }
-        .tab {
-            padding: 12px 25px;
-            background: #f8f9fa;
-            border-radius: 8px;
-            cursor: pointer;
-            transition: all 0.3s;
-            border: 2px solid transparent;
-        }
-        .tab:hover, .tab.active {
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            color: white;
-            border-color: #764ba2;
-        }
-        
-        /* Footer */
-        footer {
-            text-align: center;
-            color: white;
-            padding: 30px;
-            margin-top: 40px;
-            font-size: 1.1em;
-        }
-        
-        /* Responsive */
-        @media (max-width: 768px) {
-            h1 { font-size: 2em; }
-            .stats-grid, .model-grid { grid-template-columns: 1fr; }
-            .section { padding: 20px; }
-        }
-        
-        /* Copy button */
-        .copy-btn {
-            position: absolute;
-            top: 10px;
-            right: 10px;
-            background: #7e22ce;
-            color: white;
-            border: none;
-            padding: 8px 15px;
-            border-radius: 6px;
-            cursor: pointer;
-            font-size: 0.85em;
-            transition: all 0.3s;
-        }
-        .copy-btn:hover {
-            background: #9333ea;
-            transform: scale(1.05);
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <header>
-            <h1>🧠 Sixfinger Thinking Backend</h1>
-            <p class="subtitle">Multi-Model AI with Auto-Fallback & Chain-of-Thought</p>
-            <div>
-                <span class="badge thinking">4 Thinking Models</span>
-                <span class="badge">6 Normal Models</span>
-                <span class="badge fallback">Auto-Fallback</span>
-                <span class="badge">∞ Unlimited</span>
-            </div>
-        </header>
-
-        <!-- Stats -->
-        <div class="stats-grid">
-            <div class="stat-box">
-                <h3>{{ uptime }}</h3>
-                <p>⏰ Uptime</p>
-            </div>
-            <div class="stat-box">
-                <h3>{{ total_requests }}</h3>
-                <p>📊 Total Requests</p>
-            </div>
-            <div class="stat-box">
-                <h3>{{ success_rate }}%</h3>
-                <p>✅ Success Rate</p>
-            </div>
-            <div class="stat-box">
-                <h3>{{ fallback_count }}</h3>
-                <p>🔄 Fallbacks</p>
-            </div>
-        </div>
-
-        <!-- Quick Start -->
-        <div class="section">
-            <h2>🚀 Quick Start</h2>
-            
-            <div class="success-box">
-                <strong>✅ No API Key Required!</strong><br>
-                Direkt kullanabilirsiniz. Rate limit yok, tamamen sınırsız!
-            </div>
-
-            <h3>1. Thinking Mode (Deep Reasoning)</h3>
-            <pre><button class="copy-btn" onclick="copyCode(this)">📋 Copy</button><code>curl -X POST https://yourusername-sixfinger-backend.hf.space/api/chat \
-  -H "Content-Type: application/json" \
-  -d '{
-    "prompt": "2+2 neden 4 eder? Matematiksel olarak açıkla.",
-    "thinking": true,
-    "max_tokens": 2000
-  }'</code></pre>
-
-            <h3>2. Normal Mode (Fast Response)</h3>
-            <pre><button class="copy-btn" onclick="copyCode(this)">📋 Copy</button><code>curl -X POST https://yourusername-sixfinger-backend.hf.space/api/chat \
-  -H "Content-Type: application/json" \
-  -d '{
-    "prompt": "Merhaba kanka!",
-    "thinking": false,
-    "personality": "sixfinger"
-  }'</code></pre>
-
-            <h3>3. Streaming Mode</h3>
-            <pre><button class="copy-btn" onclick="copyCode(this)">📋 Copy</button><code>curl -X POST https://yourusername-sixfinger-backend.hf.space/api/chat/stream \
-  -H "Content-Type: application/json" \
-  -d '{"prompt": "Python nedir?", "thinking": true}' \
-  --no-buffer</code></pre>
-        </div>
-
-        <!-- Thinking vs Normal -->
-        <div class="section">
-            <h2>🧠 Thinking vs Normal Models</h2>
-            
-            <table>
-                <tr>
-                    <th>Feature</th>
-                    <th>Thinking Models</th>
-                    <th>Normal Models</th>
-                </tr>
-                <tr>
-                    <td><strong>Use Case</strong></td>
-                    <td>Matematik, reasoning, problem çözme</td>
-                    <td>Genel sohbet, hızlı cevaplar</td>
-                </tr>
-                <tr>
-                    <td><strong>Response Time</strong></td>
-                    <td>⏱️ Yavaş (5-15 saniye)</td>
-                    <td>⚡ Hızlı (1-3 saniye)</td>
-                </tr>
-                <tr>
-                    <td><strong>Chain-of-Thought</strong></td>
-                    <td>✅ Evet (<code>&lt;think&gt;...&lt;/think&gt;</code>)</td>
-                    <td>❌ Hayır</td>
-                </tr>
-                <tr>
-                    <td><strong>Models</strong></td>
-                    <td>DeepSeek-R1, Qwen3-VL Thinking, GPT-OSS-120B</td>
-                    <td>Qwen2.5, Llama-3.1, Mixtral, Gemma</td>
-                </tr>
-                <tr>
-                    <td><strong>Token Limit</strong></td>
-                    <td>4000 max</td>
-                    <td>4000 max</td>
-                </tr>
-            </table>
-        </div>
-
-        <!-- Thinking Models -->
-        <div class="section">
-            <h2>🔥 Thinking Models (Reasoning)</h2>
-            
-            <div class="model-grid">
-                {% for key, info in thinking_models.items() %}
-                <div class="model-card thinking">
-                    <h4>{{ info['description'] }}</h4>
-                    <div class="model-id">{{ info['id'] }}</div>
-                    <p>📦 Size: <strong>{{ info['size'] }}</strong></p>
-                    <div class="stats">
-                        <span>✅ {{ model_usage.get(key, 0) }} kullanım</span>
-                        <span>❌ {{ model_failures.get(key, 0) }} hata</span>
-                    </div>
-                </div>
-                {% endfor %}
-            </div>
-        </div>
-
-        <!-- Normal Models -->
-        <div class="section">
-            <h2>⚡ Normal Models (Fast)</h2>
-            
-            <div class="model-grid">
-                {% for key, info in normal_models.items() %}
-                <div class="model-card">
-                    <h4>{{ info['description'] }}</h4>
-                    <div class="model-id">{{ info['id'] }}</div>
-                    <p>📦 Size: <strong>{{ info['size'] }}</strong></p>
-                    <div class="stats">
-                        <span>✅ {{ model_usage.get(key, 0) }} kullanım</span>
-                        <span>❌ {{ model_failures.get(key, 0) }} hata</span>
-                    </div>
-                </div>
-                {% endfor %}
-            </div>
-        </div>
-
-        <!-- API Endpoints -->
-        <div class="section">
-            <h2>🌐 API Endpoints</h2>
-
-            <h3>POST /api/chat</h3>
-            <p>Normal chat endpoint (JSON response)</p>
-            
-            <h4>Request Parameters:</h4>
-            <table>
-                <tr>
-                    <th>Parameter</th>
-                    <th>Type</th>
-                    <th>Required</th>
-                    <th>Default</th>
-                    <th>Description</th>
-                </tr>
-                <tr>
-                    <td><code>prompt</code></td>
-                    <td>string</td>
-                    <td>✅</td>
-                    <td>-</td>
-                    <td>User message</td>
-                </tr>
-                <tr>
-                    <td><code>thinking</code></td>
-                    <td>boolean</td>
-                    <td>❌</td>
-                    <td>false</td>
-                    <td>true = thinking models, false = normal models</td>
-                </tr>
-                <tr>
-                    <td><code>personality</code></td>
-                    <td>string</td>
-                    <td>❌</td>
-                    <td>sixfinger</td>
-                    <td>sixfinger | assistant | thinking</td>
-                </tr>
-                <tr>
-                    <td><code>max_tokens</code></td>
-                    <td>integer</td>
-                    <td>❌</td>
-                    <td>1000</td>
-                    <td>Max tokens (1-4000)</td>
-                </tr>
-                <tr>
-                    <td><code>temperature</code></td>
-                    <td>float</td>
-                    <td>❌</td>
-                    <td>0.7</td>
-                    <td>Creativity (0.1-2.0)</td>
-                </tr>
-                <tr>
-                    <td><code>history</code></td>
-                    <td>array</td>
-                    <td>❌</td>
-                    <td>[]</td>
-                    <td>Conversation history</td>
-                </tr>
-            </table>
-
-            <h4>Response Example:</h4>
-            <pre><code>{
-  "response": "Kanka bak şimdi 2+2=4 olur çünkü...",
-  "thinking_process": "Adım 1: 2 sayısı... Adım 2: Toplama işlemi...",
-  "has_thinking": true,
-  "model": "deepseek-ai/DeepSeek-R1",
-  "model_key": "deepseek-r1",
-  "model_category": "thinking",
-  "attempts": 1,
-  "usage": {
-    "prompt_tokens": 50,
-    "completion_tokens": 200,
-    "total_tokens": 250
-  }
-}</code></pre>
-
-            <div class="info-box">
-                <strong>💡 Auto-Fallback:</strong><br>
-                Eğer seçilen model hata verirse (rate limit, timeout, vb.) otomatik olarak başka bir model denenir.
-                Response'ta <code>attempts</code> field'ı kaç model denendiğini gösterir.
-            </div>
-        </div>
-
-        <!-- Code Examples -->
-        <div class="section">
-            <h2>💻 Code Examples</h2>
-
-            <h3>Python</h3>
-            <pre><button class="copy-btn" onclick="copyCode(this)">📋 Copy</button><code>import requests
-
-API_URL = "https://yourusername-sixfinger-backend.hf.space/api/chat"
-
-def chat(prompt, thinking=False, personality="sixfinger"):
-    response = requests.post(API_URL, json={
-        "prompt": prompt,
-        "thinking": thinking,
-        "personality": personality,
-        "max_tokens": 1500
-    })
-    
-    data = response.json()
-    
-    # Thinking process varsa göster
-    if data.get('has_thinking'):
-        print("🧠 Thinking Process:")
-        print(data['thinking_process'])
-        print("\n📝 Answer:")
-    
-    print(data['response'])
-    print(f"\n📊 Model: {data['model_key']} (Attempt: {data['attempts']})")
-
-# Thinking mode
-chat("3x + 7 = 22 denklemini çöz", thinking=True)
-
-# Normal mode
-chat("Merhaba kanka!", thinking=False)</code></pre>
-
-            <h3>JavaScript (Fetch)</h3>
-            <pre><button class="copy-btn" onclick="copyCode(this)">📋 Copy</button><code>const API_URL = "https://yourusername-sixfinger-backend.hf.space/api/chat";
-
-async function chat(prompt, thinking = false) {
-    const response = await fetch(API_URL, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-            prompt: prompt,
-            thinking: thinking,
-            max_tokens: 1500
-        })
-    });
-    
-    const data = await response.json();
-    
-    if (data.has_thinking) {
-        console.log("🧠 Thinking:", data.thinking_process);
-    }
-    
-    console.log("📝 Answer:", data.response);
-    console.log("📊 Model:", data.model_key);
-}
-
-// Usage
-chat("Python nedir?", true);</code></pre>
-
-            <h3>cURL (Streaming)</h3>
-            <pre><button class="copy-btn" onclick="copyCode(this)">📋 Copy</button><code>curl -X POST https://yourusername-sixfinger-backend.hf.space/api/chat/stream \
-  -H "Content-Type: application/json" \
-  -d '{
-    "prompt": "Yapay zeka nedir?",
-    "thinking": true,
-    "max_tokens": 2000
-  }' \
-  --no-buffer</code></pre>
-        </div>
-
-        <!-- Fallback Mechanism -->
-        <div class="section">
-            <h2>🔄 Auto-Fallback Mechanism</h2>
-            
-            <div class="warning-box">
-                <strong>⚠️ Nasıl Çalışır?</strong>
-                <ol style="margin: 15px 0 0 20px;">
-                    <li>Rastgele bir model seçilir (kategori: thinking/normal)</li>
-                    <li>Model'e istek atılır</li>
-                    <li><strong>Başarısız olursa:</strong> Otomatik başka model denenir</li>
-                    <li>Maksimum 5 model denenir</li>
-                    <li>Tüm modeller başarısız olursa <code>503 Service Unavailable</code> döner</li>
-                </ol>
-            </div>
-
-            <h3>Hata Tipleri:</h3>
-            <ul style="margin-left: 20px;">
-                <li><strong>Rate Limit Exceeded:</strong> Model kotası doldu → başka model dene</li>
-                <li><strong>Timeout:</strong> Model yanıt vermedi → başka model dene</li>
-                <li><strong>Model Error:</strong> Model hatası → başka model dene</li>
-            </ul>
-
-            <h3>Response'ta Fallback Bilgisi:</h3>
-            <pre><code>{
-  "response": "...",
-  "attempts": 3,  // 3 model denendi
-  "fallback_attempts": [
-    {"model": "deepseek-r1", "success": false, "error": "Rate limit"},
-    {"model": "qwen3-vl-235b-thinking", "success": false, "error": "Timeout"},
-    {"model": "qwen3-vl-32b-thinking", "success": true, "error": null}
-  ]
-}</code></pre>
-        </div>
-
-        <!-- Other Endpoints -->
-        <div class="section">
-            <h2>📡 Other Endpoints</h2>
-
-            <h3>GET /api/models</h3>
-            <p>Tüm modelleri ve istatistiklerini listele</p>
-            <pre><code>curl https://yourusername-sixfinger-backend.hf.space/api/models</code></pre>
-
-            <h3>GET /api/stats</h3>
-            <p>Detaylı kullanım istatistikleri</p>
-            <pre><code>curl https://yourusername-sixfinger-backend.hf.space/api/stats</code></pre>
-
-            <h3>GET /health</h3>
-            <p>Health check</p>
-            <pre><code>curl https://yourusername-sixfinger-backend.hf.space/health</code></pre>
-        </div>
-
-        <!-- Best Practices -->
-        <div class="section">
-            <h2>✅ Best Practices</h2>
-
-            <h3>1. Thinking Mode Kullanımı</h3>
-            <p><strong>✅ İyi:</strong> Matematik, reasoning, problem çözme, analiz</p>
-            <pre><code>{"prompt": "Bir araba 60 km/s hızla 3 saat giderse kaç km yol alır?", "thinking": true}</code></pre>
-
-            <p><strong>❌ Kötü:</strong> Basit sorular, selamlaşma</p>
-            <pre><code>{"prompt": "Merhaba", "thinking": true}  // Gereksiz, normal mode yeterli</code></pre>
-
-            <h3>2. Max Tokens Ayarı</h3>
-            <ul style="margin-left: 20px;">
-                <li>Kısa cevaplar: <code>max_tokens: 200-500</code></li>
-                <li>Orta cevaplar: <code>max_tokens: 500-1000</code></li>
-                <li>Uzun cevaplar/thinking: <code>max_tokens: 1500-4000</code></li>
-            </ul>
-
-            <h3>3. Error Handling</h3>
-            <pre><code>try {
-    const response = await fetch(API_URL, {...});
-    const data = await response.json();
-    
-    if (data.error) {
-        console.error('API Error:', data.error);
-        // Fallback logic
-    }
-} catch (error) {
-    console.error('Network Error:', error);
-}</code></pre>
-        </div>
-
-        <!-- Contact -->
-        <div class="section">
-            <h2>📞 İletişim & Destek</h2>
-            
-            <div class="success-box">
-                <p><strong>���� API URL:</strong> <code>https://yourusername-sixfinger-backend.hf.space</code></p>
-                <p><strong>📊 Status:</strong> <span style="color: #28a745;">● Online</span></p>
-                <p><strong>📧 Email:</strong> sixfingerdev@gmail.com</p>
-                <p><strong>🔗 GitHub:</strong> Hugging Face Spaces</p>
-            </div>
-        </div>
-
-        <footer>
-            <p>Made with ❤️ by Sixfinger Team</p>
-            <p>🧠 Thinking Models | 🔄 Auto-Fallback | ⚡ Unlimited API</p>
-            <p style="margin-top: 15px;">
-                <strong>Version:</strong> 3.0.0 | 
-                <strong>Models:</strong> {{ thinking_models|length + normal_models|length }} | 
-                <strong>Uptime:</strong> {{ uptime }}
-            </p>
-        </footer>
-    </div>
-
-    <script>
-        function copyCode(btn) {
-            const pre = btn.parentElement;
-            const code = pre.querySelector('code').textContent;
-            navigator.clipboard.writeText(code).then(() => {
-                const originalText = btn.textContent;
-                btn.textContent = '✅ Copied!';
-                setTimeout(() => {
-                    btn.textContent = originalText;
-                }, 2000);
-            });
-        }
-
-        console.log('%c🧠 Sixfinger Thinking Backend Ready!', 'font-size: 20px; color: #7e22ce; font-weight: bold;');
-        console.log('%cThinking Models: {{ thinking_models|length }} | Normal Models: {{ normal_models|length }}', 'font-size: 14px; color: #1e3c72;');
-    </script>
-</body>
-</html>
-"""
+# ========== MAIN ==========
 
 if __name__ == '__main__':
-    print("\n" + "=" * 60)
-    print("🚀 Sixfinger Multi-Model Backend (Thinking + Fallback)")
-    print("=" * 60)
+    print("\n" + "=" * 70)
+    print("🚀 SIXFINGER GROQ BACKEND v4.0.1")
+    print("=" * 70)
+    print(f"✅ Groq API Key: {GROQ_API_KEY[:20]}...")
     print(f"📡 Port: {PORT}")
-    print(f"🧠 Thinking Models: {len(THINKING_MODELS)}")
-    print(f"⚡ Normal Models: {len(NORMAL_MODELS)}")
-    print(f"🔄 Max Retries: {MAX_RETRIES}")
-    print("=" * 60)
-    print("Thinking Models:")
-    for key, info in THINKING_MODELS.items():
+    print("=" * 70)
+    
+    print("\n🆓 FREE PLAN MODELS:")
+    for key, info in FREE_MODELS.items():
         print(f"  • {key}: {info['description']}")
-    print("\nNormal Models:")
-    for key, info in NORMAL_MODELS.items():
+        print(f"    RPD: {info['rpd']:,} | TPD: {info['tpd']:,} | Language: {info['language']}")
+    
+    print("\n💎 PAID PLAN MODELS:")
+    for key, info in PAID_MODELS.items():
         print(f"  • {key}: {info['description']}")
-    print("=" * 60)
+        print(f"    Plan: {info['plan_required']}+ | RPD: {info['rpd']:,} | Language: {info['language']}")
+    
+    print("\n📊 PLAN PERMISSIONS:")
+    for plan, models in PLAN_ALLOWED_MODELS.items():
+        print(f"  • {plan.upper()}: {len(models)} modeller - {', '.join(models[:3])}...")
+    
+    print("\n" + "=" * 70)
     print("✅ Server ready!")
-    print("📖 Documentation: http://0.0.0.0:7860")
-    print("=" * 60 + "\n")
+    print("📖 API Docs: http://0.0.0.0:7860")
+    print("=" * 70 + "\n")
     
     app.run(host='0.0.0.0', port=PORT, debug=False, threaded=True)