Update app.py

app.py

@@ -1,28 +1,33 @@
 """
-SixFinger Code - Pollinations API Proxy Backend
+SixFingerDev Arena - Multi-Model Agentic Backend
+Supports: GPT-5.1-Codex, Claude Opus 4.5, o3, o3-mini
 Hugging Face Spaces üzerinde çalışır
 """
 
-from fastapi import FastAPI, HTTPException, Header
+from fastapi import FastAPI, HTTPException, Header, Request
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse, JSONResponse
 from pydantic import BaseModel
-from typing import List, Optional, Dict, Any
+from typing import List, Optional, Dict, Any, AsyncGenerator
 import requests
 import os
 import secrets
 from datetime import datetime
 import time
+import json
+import asyncio
+from collections import defaultdict
 
 app = FastAPI(
-    title="SixFinger AI Backend",
-    description="Pollinations API Proxy for PythonAnywhere",
-    version="1.0.0"
+    title="SixFingerDev Arena Backend",
+    description="Multi-Model AI Backend with Task Routing",
+    version="2.0.0"
 )
 
-# CORS - tüm originlere izin ver (production'da domain belirt)
+# CORS
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # Production'da: ["https://yourdomain.pythonanywhere.com"]
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
@@ -32,36 +37,73 @@ app.add_middleware(
 # CONFIGURATION
 # ============================================
 
-# API Keys - Space Secrets'tan al
+# Model configurations
+MODEL_CONFIGS = {
+    "gpt-5.1-codex": {
+        "provider": "pollinations",
+        "api_name": "openai",
+        "capabilities": ["code", "debug", "test"],
+        "max_tokens": 4096,
+        "temperature": 0.7
+    },
+    "claude-opus-4.5": {
+        "provider": "pollinations",
+        "api_name": "claude-opus-4",
+        "capabilities": ["plan", "modify", "test"],
+        "max_tokens": 4096,
+        "temperature": 0.7
+    },
+    "o3": {
+        "provider": "pollinations",
+        "api_name": "openai",
+        "capabilities": ["debug", "test"],
+        "max_tokens": 4096,
+        "temperature": 0.7
+    },
+    "o3-mini": {
+        "provider": "pollinations",
+        "api_name": "openai",
+        "capabilities": ["test"],
+        "max_tokens": 2048,
+        "temperature": 0.7
+    }
+}
+
+# Task to Model mapping (Elon Musk config)
+TASK_MODELS = {
+    "Planner": "claude-opus-4.5",
+    "Coder": "gpt-5.1-codex",
+    "Tester": "claude-opus-4.5",
+    "Debugger": "gpt-5.1-codex",
+    "Modifier": "claude-opus-4.5"
+}
+
+# API Keys
 API_KEYS_RAW = os.getenv('AI_API_KEYS', '')
+BACKEND_API_KEY = os.getenv('BACKEND_API_KEY', secrets.token_urlsafe(32))
 
 def parse_api_keys():
-    """AI_API_KEYS'i parse et"""
     if not API_KEYS_RAW:
-        # Fallback - public Pollinations (sınırlı)
         return []
-    
     if API_KEYS_RAW.startswith('['):
-        import json
         try:
             return json.loads(API_KEYS_RAW)
         except:
             pass
-    
     return [k.strip() for k in API_KEYS_RAW.split(',') if k.strip()]
 
 API_KEYS = parse_api_keys()
 
-# Backend API Key (güvenlik için)
-BACKEND_API_KEY = os.getenv('BACKEND_API_KEY', secrets.token_urlsafe(32))
-
 # Pollinations URL
 POLLINATIONS_URL = "https://gen.pollinations.ai/v1/chat/completions"
 
 # Rate limiting
-REQUEST_COUNTS = {}
+REQUEST_COUNTS = defaultdict(list)
 MAX_REQUESTS_PER_MINUTE = 60
 
+# Session storage (in-memory)
+SESSIONS = {}
+
 # ============================================
 # MODELS
 # ============================================
@@ -71,24 +113,23 @@ class Message(BaseModel):
     content: str
 
 class ChatRequest(BaseModel):
-    model: str
-    messages: List[Message]
-    stream: Optional[bool] = False
-    temperature: Optional[float] = 0.7
-    max_tokens: Optional[int] = 2000
-
-class ChatResponse(BaseModel):
-    id: str
-    object: str
-    created: int
-    model: str
-    choices: List[Dict[str, Any]]
-    usage: Dict[str, int]
+    session_id: str
+    message: str
+    model: Optional[str] = None  # Auto-detect if None
+    task_type: Optional[str] = None  # Planner, Coder, Tester, Debugger, Modifier
+    stream: Optional[bool] = True
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+
+class TaskDetectionRequest(BaseModel):
+    message: str
+    context: Optional[List[Message]] = []
 
 class HealthResponse(BaseModel):
     status: str
     timestamp: str
-    api_keys_count: int
+    available_models: List[str]
+    task_mappings: Dict[str, str]
     version: str
 
 # ============================================
@@ -97,14 +138,14 @@ class HealthResponse(BaseModel):
 
 class APIKeyManager:
     def __init__(self, keys: List[str]):
-        self.keys = keys if keys else [None]  # None = keyless mode
+        self.keys = keys if keys else [None]
         self.failed_keys = {}
         self.current_index = 0
         self.cooldown = 60
     
     def get_working_key(self) -> Optional[str]:
         if not self.keys or self.keys[0] is None:
-            return None  # Keyless mode
+            return None
         
         now = time.time()
         attempts = 0
@@ -122,7 +163,6 @@ class APIKeyManager:
             
             return key
         
-        # All keys failed - use oldest
         if self.failed_keys:
             oldest_key = min(self.failed_keys, key=self.failed_keys.get)
             del self.failed_keys[oldest_key]
@@ -141,6 +181,59 @@ class APIKeyManager:
 
 key_manager = APIKeyManager(API_KEYS)
 
+# ============================================
+# TASK DETECTION
+# ============================================
+
+def detect_task_type(message: str) -> str:
+    """Mesajdan task type'ı otomatik tespit et"""
+    message_lower = message.lower()
+    
+    # Keyword-based detection
+    if any(word in message_lower for word in ['plan', 'tasarla', 'mimari', 'architecture', 'design', 'roadmap']):
+        return "Planner"
+    
+    elif any(word in message_lower for word in ['kod yaz', 'implement', 'create', 'build', 'develop', 'function']):
+        return "Coder"
+    
+    elif any(word in message_lower for word in ['test', 'kontrol et', 'check', 'verify', 'validate']):
+        return "Tester"
+    
+    elif any(word in message_lower for word in ['hata', 'bug', 'debug', 'fix', 'error', 'düzelt']):
+        return "Debugger"
+    
+    elif any(word in message_lower for word in ['değiştir', 'modify', 'update', 'refactor', 'optimize']):
+        return "Modifier"
+    
+    # Default: Genel sohbet için Coder
+    return "Coder"
+
+# ============================================
+# SESSION MANAGEMENT
+# ============================================
+
+def get_or_create_session(session_id: str) -> Dict:
+    """Session al veya oluştur"""
+    if session_id not in SESSIONS:
+        SESSIONS[session_id] = {
+            "messages": [],
+            "created_at": datetime.utcnow().isoformat(),
+            "last_activity": datetime.utcnow().isoformat(),
+            "metadata": {}
+        }
+    
+    SESSIONS[session_id]["last_activity"] = datetime.utcnow().isoformat()
+    return SESSIONS[session_id]
+
+def add_message_to_session(session_id: str, role: str, content: str):
+    """Session'a mesaj ekle"""
+    session = get_or_create_session(session_id)
+    session["messages"].append({
+        "role": role,
+        "content": content,
+        "timestamp": datetime.utcnow().isoformat()
+    })
+
 # ============================================
 # MIDDLEWARE
 # ============================================
@@ -161,14 +254,10 @@ def verify_api_key(authorization: Optional[str] = Header(None)):
     return token
 
 def rate_limit_check(client_id: str):
-    """Basit rate limiting"""
+    """Rate limiting"""
     now = time.time()
     minute_ago = now - 60
     
-    if client_id not in REQUEST_COUNTS:
-        REQUEST_COUNTS[client_id] = []
-    
-    # Eski istekleri temizle
     REQUEST_COUNTS[client_id] = [
         req_time for req_time in REQUEST_COUNTS[client_id] 
         if req_time > minute_ago
@@ -180,72 +269,37 @@ def rate_limit_check(client_id: str):
     REQUEST_COUNTS[client_id].append(now)
 
 # ============================================
-# ROUTES
+# CORE API FUNCTIONS
 # ============================================
 
-@app.get("/", response_model=HealthResponse)
-async def health_check():
-    """Health check endpoint"""
-    return {
-        "status": "healthy",
-        "timestamp": datetime.utcnow().isoformat(),
-        "api_keys_count": len(API_KEYS) if API_KEYS and API_KEYS[0] is not None else 0,
-        "version": "1.0.0"
-    }
-
-@app.get("/health", response_model=HealthResponse)
-async def health():
-    """Alias for health check"""
-    return await health_check()
-
-@app.post("/v1/chat/completions")
-async def chat_completion(
-    request: ChatRequest,
-    authorization: str = Header(None)
-):
-    """
-    Pollinations API proxy endpoint
-    
-    Headers:
-        Authorization: Bearer YOUR_BACKEND_API_KEY
-    
-    Body:
-        {
-            "model": "openai",
-            "messages": [{"role": "user", "content": "Hello"}],
-            "stream": false
-        }
-    """
-    
-    # Verify backend API key
-    verify_api_key(authorization)
+async def call_model_api(
+    model: str,
+    messages: List[Dict],
+    stream: bool = False,
+    temperature: Optional[float] = None,
+    max_tokens: Optional[int] = None
+) -> Any:
+    """Model API'sini çağır"""
     
-    # Rate limiting (IP bazlı olabilir, şimdilik basit)
-    client_id = authorization  # veya request.client.host
-    rate_limit_check(client_id)
+    if model not in MODEL_CONFIGS:
+        raise HTTPException(status_code=400, detail=f"Unknown model: {model}")
     
-    # Get working API key
+    config = MODEL_CONFIGS[model]
     api_key = key_manager.get_working_key()
     
-    # Prepare headers
-    headers = {
-        "Content-Type": "application/json"
-    }
-    
+    headers = {"Content-Type": "application/json"}
     if api_key:
         headers["Authorization"] = f"Bearer {api_key}"
     
-    # Prepare payload
     payload = {
-        "model": request.model,
-        "messages": [{"role": m.role, "content": m.content} for m in request.messages],
-        "stream": request.stream,
-        "temperature": request.temperature,
-        "max_tokens": request.max_tokens
+        "model": config["api_name"],
+        "messages": messages,
+        "stream": stream,
+        "temperature": temperature or config["temperature"],
+        "max_tokens": max_tokens or config["max_tokens"]
     }
     
-    # Call Pollinations API
-    max_retries = len(API_KEYS) if API_KEYS and API_KEYS[0] is not None else 3
+    max_retries = 3
     last_error = None
     
     for attempt in range(max_retries):
@@ -254,24 +308,27 @@ async def chat_completion(
                 POLLINATIONS_URL,
                 json=payload,
                 headers=headers,
+                stream=stream,
                 timeout=120
             )
             
             if response.status_code == 200:
                 key_manager.mark_success(api_key)
-                return response.json()
+                
+                if stream:
+                    return response
+                else:
+                    return response.json()
             
-            elif response.status_code == 403:
-                # Rate limit - try next key
+            elif response.status_code in [403, 429]:
                 key_manager.mark_failed(api_key)
                 api_key = key_manager.get_working_key()
                 if api_key:
                     headers["Authorization"] = f"Bearer {api_key}"
-                time.sleep(1)
+                await asyncio.sleep(1)
                 continue
             
             elif response.status_code == 401:
-                # Invalid key - try next
                 key_manager.mark_failed(api_key)
                 api_key = key_manager.get_working_key()
                 if api_key:
@@ -279,44 +336,199 @@ async def chat_completion(
                 continue
             
             else:
-                # Other error
-                last_error = f"API error: {response.status_code} - {response.text[:200]}"
+                last_error = f"API error: {response.status_code}"
+                if attempt < max_retries - 1:
+                    await asyncio.sleep(2)
+                    continue
                 raise HTTPException(status_code=response.status_code, detail=last_error)
         
         except requests.exceptions.Timeout:
-            last_error = "Request timeout"
             if attempt < max_retries - 1:
-                time.sleep(2)
+                await asyncio.sleep(2)
                 continue
-            raise HTTPException(status_code=504, detail=last_error)
+            raise HTTPException(status_code=504, detail="Request timeout")
         
         except requests.exceptions.RequestException as e:
-            last_error = str(e)
             if attempt < max_retries - 1:
-                time.sleep(1)
+                await asyncio.sleep(1)
                 continue
-            raise HTTPException(status_code=500, detail=f"Request failed: {last_error}")
+            raise HTTPException(status_code=500, detail=f"Request failed: {str(e)}")
+    
+    raise HTTPException(status_code=503, detail="All retries failed")
+
+async def stream_generator(response) -> AsyncGenerator[str, None]:
+    """Stream response'u SSE formatına çevir"""
+    try:
+        for line in response.iter_lines():
+            if line:
+                line_decoded = line.decode('utf-8')
+                
+                if line_decoded.startswith("data: "):
+                    data_str = line_decoded[6:]
+                    
+                    if data_str.strip() == "[DONE]":
+                        yield f"data: {json.dumps({'done': True})}\n\n"
+                        break
+                    
+                    try:
+                        data = json.loads(data_str)
+                        
+                        if "choices" in data and len(data["choices"]) > 0:
+                            delta = data["choices"][0].get("delta", {})
+                            content = delta.get("content", "")
+                            
+                            if content:
+                                yield f"data: {json.dumps({'chunk': content})}\n\n"
+                    
+                    except json.JSONDecodeError:
+                        continue
+        
+        yield f"data: {json.dumps({'done': True})}\n\n"
+    
+    finally:
+        response.close()
+
+# ============================================
+# ROUTES
+# ============================================
+
+@app.get("/", response_model=HealthResponse)
+async def health_check():
+    """Health check"""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.utcnow().isoformat(),
+        "available_models": list(MODEL_CONFIGS.keys()),
+        "task_mappings": TASK_MODELS,
+        "version": "2.0.0"
+    }
+
+@app.post("/api/chat")
+async def chat(request: ChatRequest):
+    """
+    Ana chat endpoint - Task-based routing ile
+    
+    Body:
+        {
+            "session_id": "sf_xxx",
+            "message": "Kayra için tokenizer yaz",
+            "model": "gpt-5.1-codex",  // optional
+            "task_type": "Coder",       // optional
+            "stream": true
+        }
+    """
+    
+    # Rate limiting
+    rate_limit_check(request.session_id)
+    
+    # Session'ı al/oluştur
+    session = get_or_create_session(request.session_id)
+    
+    # User mesajını ekle
+    add_message_to_session(request.session_id, "user", request.message)
+    
+    # Task type'ı belirle
+    task_type = request.task_type or detect_task_type(request.message)
+    
+    # Model'i belirle
+    model = request.model or TASK_MODELS.get(task_type, "gpt-5.1-codex")
+    
+    # Messages'ı hazırla
+    messages = [
+        {"role": msg["role"], "content": msg["content"]}
+        for msg in session["messages"]
+    ]
+    
+    # System prompt ekle (task-specific)
+    system_prompts = {
+        "Planner": "Sen deneyimli bir yazılım mimarısın. Detaylı planlama ve tasarım yap.",
+        "Coder": "Sen expert bir kod geliştiricisisin. Temiz, okunabilir ve performanslı kod yaz.",
+        "Tester": "Sen titiz bir test mühendisisin. Comprehensive test senaryoları oluştur.",
+        "Debugger": "Sen yetenekli bir debugger'sın. Hataları kök nedenine inip çöz.",
+        "Modifier": "Sen dikkatli bir refactoring uzmanısın. Mevcut kodu bozmadan değiştir."
+    }
+    
+    if task_type in system_prompts:
+        messages.insert(0, {"role": "system", "content": system_prompts[task_type]})
+    
+    # API'yi çağır
+    if request.stream:
+        response = await call_model_api(
+            model=model,
+            messages=messages,
+            stream=True,
+            temperature=request.temperature,
+            max_tokens=request.max_tokens
+        )
+        
+        return StreamingResponse(
+            stream_generator(response),
+            media_type="text/event-stream"
+        )
+    else:
+        result = await call_model_api(
+            model=model,
+            messages=messages,
+            stream=False,
+            temperature=request.temperature,
+            max_tokens=request.max_tokens
+        )
+        
+        # Assistant yanıtını session'a ekle
+        assistant_message = result["choices"][0]["message"]["content"]
+        add_message_to_session(request.session_id, "assistant", assistant_message)
+        
+        return result
+
+@app.post("/api/detect-task")
+async def detect_task(request: TaskDetectionRequest):
+    """Task type'ı tespit et"""
+    task_type = detect_task_type(request.message)
+    recommended_model = TASK_MODELS.get(task_type)
     
-    # All retries failed
-    raise HTTPException(status_code=503, detail=f"All API keys failed: {last_error}")
+    return {
+        "task_type": task_type,
+        "recommended_model": recommended_model,
+        "model_config": MODEL_CONFIGS.get(recommended_model, {})
+    }
 
-@app.get("/stats")
-async def get_stats(authorization: str = Header(None)):
-    """Backend istatistikleri (admin only)"""
-    verify_api_key(authorization)
+@app.get("/api/session/{session_id}")
+async def get_session(session_id: str):
+    """Session bilgilerini getir"""
+    if session_id not in SESSIONS:
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    return SESSIONS[session_id]
+
+@app.delete("/api/session/{session_id}")
+async def delete_session(session_id: str):
+    """Session'ı sil"""
+    if session_id in SESSIONS:
+        del SESSIONS[session_id]
+        return {"status": "deleted"}
     
+    raise HTTPException(status_code=404, detail="Session not found")
+
+@app.get("/api/models")
+async def list_models():
+    """Kullanılabilir modelleri listele"""
+    return {
+        "models": MODEL_CONFIGS,
+        "task_mappings": TASK_MODELS
+    }
+
+@app.get("/api/stats")
+async def get_stats():
+    """İstatistikler"""
     return {
+        "total_sessions": len(SESSIONS),
         "total_keys": len(API_KEYS) if API_KEYS and API_KEYS[0] is not None else 0,
         "failed_keys": len(key_manager.failed_keys),
         "active_clients": len(REQUEST_COUNTS),
-        "requests_last_minute": sum(len(v) for v in REQUEST_COUNTS.values())
+        "requests_last_minute": sum(len(v) for v in REQUEST_COUNTS.values()),
+        "available_models": list(MODEL_CONFIGS.keys())
     }
 
-# ============================================
-# ERROR HANDLERS
-# ============================================
-from starlette.responses import JSONResponse  # En üste ekle, zaten FastAPI'den geliyor ama emin ol
-
 # ============================================
 # ERROR HANDLERS
 # ============================================
@@ -336,9 +548,7 @@ async def http_exception_handler(request, exc):
 
 @app.exception_handler(Exception)
 async def general_exception_handler(request, exc):
-    # Logla hatayı (production'da önemli)
     print(f"Unhandled exception: {exc}")
-    
     return JSONResponse(
         status_code=500,
         content={
@@ -348,21 +558,26 @@ async def general_exception_handler(request, exc):
                 "code": 500
             }
         }
-    )# ============================================
+    )
+
+# ============================================
 # STARTUP
 # ============================================
 
 @app.on_event("startup")
 async def startup_event():
     print("=" * 60)
-    print("🚀 SixFinger AI Backend Starting...")
+    print("🚀 SixFingerDev Arena Starting...")
     print("=" * 60)
-    print(f"📦 API Keys: {len(API_KEYS) if API_KEYS and API_KEYS[0] is not None else 0}")
-    print(f"🔑 Backend API Key: {BACKEND_API_KEY[:10]}...")
-    print(f"🌐 Pollinations URL: {POLLINATIONS_URL}")
+    print(f"📦 Available Models: {', '.join(MODEL_CONFIGS.keys())}")
+    print(f"🎯 Task Mappings:")
+    for task, model in TASK_MODELS.items():
+        print(f"   {task}: {model}")
+    print(f"🔑 API Keys: {len(API_KEYS) if API_KEYS and API_KEYS[0] is not None else 0}")
+    print(f"🔐 Backend Key: {BACKEND_API_KEY[:10]}...")
     print(f"⏱️  Rate Limit: {MAX_REQUESTS_PER_MINUTE} req/min")
     print("=" * 60)
-    print("✅ Ready to serve!")
+    print("✅ Arena Ready!")
     print("=" * 60)
 
 if __name__ == "__main__":