Update app.py

app.py

@@ -1,7 +1,7 @@
 """
 Sixfinger Backend API - FRONTEND UYUMLU VERSİYON
 Ultra-fast AI Chat Backend with Multi-Model Support
-Supports: Groq, LLM7.io
+Supports: Groq, LLM7.io, OpenRouter
 """
 
 import os
@@ -21,6 +21,9 @@ from openai import OpenAI
 # ========== CONFIGURATION ==========
 API_VERSION = "1.1.0"
 GROQ_API_KEY = os.getenv("GROQ_API_KEY", "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")
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY") or os.getenv("openrouter_api_key")
+OPENROUTER_SITE_URL = os.getenv("OPENROUTER_SITE_URL", "https://sfapi.pythonanywhere.com")
+OPENROUTER_SITE_NAME = os.getenv("OPENROUTER_SITE_NAME", "Sixfinger Backend")
 
 # ========== API PROVIDERS ==========
 PROVIDERS = {
@@ -35,6 +38,13 @@ PROVIDERS = {
         "base_url": "https://api.llm7.io/v1",
         "api_key": "unused",
         "requires_key": False
+    },
+    "openrouter": {
+        "name": "OpenRouter",
+        "type": "openai_compatible",
+        "base_url": "https://openrouter.ai/api/v1",
+        "api_key": OPENROUTER_API_KEY,
+        "requires_key": True
     }
 }
 
@@ -65,6 +75,28 @@ MODELS = {
         "plans": ["free", "starter", "pro", "plus"],
         "daily_limit": 300
     },
+    "stepfun/step-3.5-flash:free": {
+        "provider": "openrouter",
+        "model_id": "stepfun/step-3.5-flash:free",
+        "display_name": "Step 3.5 Flash (Free)",
+        "size": "Unknown",
+        "language": "Multilingual",
+        "speed": "⚡⚡⚡",
+        "description": "OpenRouter uzerinden hizli StepFun modeli",
+        "plans": ["free", "starter", "pro", "plus"],
+        "daily_limit": 1000
+    },
+    "nvidia/nemotron-3-super-120b-a12b:free": {
+        "provider": "openrouter",
+        "model_id": "nvidia/nemotron-3-super-120b-a12b:free",
+        "display_name": "Nemotron 3 Super 120B A12B (Free)",
+        "size": "120B",
+        "language": "Multilingual",
+        "speed": "⚡⚡",
+        "description": "OpenRouter uzerinden NVIDIA Nemotron modeli",
+        "plans": ["free", "starter", "pro", "plus"],
+        "daily_limit": 1000
+    },
     
     # ============ STARTER PLAN MODELS ============
     
@@ -137,6 +169,39 @@ MODELS = {
         "plans": ["starter", "pro", "plus"],
         "daily_limit": 1000
     },
+    "z-ai/glm-4.5-air:free": {
+        "provider": "openrouter",
+        "model_id": "z-ai/glm-4.5-air:free",
+        "display_name": "GLM 4.5 Air (Free)",
+        "size": "Unknown",
+        "language": "Multilingual",
+        "speed": "⚡⚡",
+        "description": "OpenRouter uzerinden GLM 4.5 Air modeli",
+        "plans": ["starter", "pro", "plus"],
+        "daily_limit": 1000
+    },
+    "qwen/qwen3-coder:free": {
+        "provider": "openrouter",
+        "model_id": "qwen/qwen3-coder:free",
+        "display_name": "Qwen3 Coder (Free)",
+        "size": "Unknown",
+        "language": "Multilingual",
+        "speed": "⚡⚡",
+        "description": "OpenRouter uzerinden kod odakli Qwen modeli",
+        "plans": ["starter", "pro", "plus"],
+        "daily_limit": 1000
+    },
+    "liquid/lfm-2.5-1.2b-thinking:free": {
+        "provider": "openrouter",
+        "model_id": "liquid/lfm-2.5-1.2b-thinking:free",
+        "display_name": "LFM 2.5 1.2B Thinking (Free)",
+        "size": "1.2B",
+        "language": "Multilingual",
+        "speed": "⚡⚡⚡",
+        "description": "OpenRouter uzerinden hizli dusunme odakli model",
+        "plans": ["starter", "pro", "plus"],
+        "daily_limit": 1000
+    },
     
     # ============ PRO PLAN MODELS ============
     
@@ -172,6 +237,14 @@ DEFAULT_MODELS = {
     "plus": "gpt-oss-120b"
 }
 
+# Primary provider başarısız olursa kullanılacak fallback modeli
+# Key: birincil provider adı, Value: fallback olarak denenecek model key'i
+PROVIDER_FALLBACK = {
+    "groq": "gpt4-nano",       # Groq hata verirse → LLM7 üzerinden gpt4-nano
+    "llm7": "llama-8b-instant", # LLM7 hata verirse → Groq üzerinden llama-8b-instant
+    "openrouter": "llama-8b-instant"
+}
+
 # ========== LOGGING ==========
 logging.basicConfig(
     level=logging.INFO,
@@ -208,6 +281,12 @@ llm7_client = OpenAI(
     api_key=PROVIDERS["llm7"]["api_key"]
 )
 
+# OpenRouter Client
+openrouter_client = OpenAI(
+    base_url=PROVIDERS["openrouter"]["base_url"],
+    api_key=PROVIDERS["openrouter"]["api_key"]
+) if OPENROUTER_API_KEY else None
+
 # ========== PYDANTIC MODELS ==========
 class ChatRequest(BaseModel):
     prompt: str = Field(..., description="User's message")
@@ -258,9 +337,17 @@ def build_messages(prompt: str, system_prompt: Optional[str], history: Optional[
                 messages.append(msg)
     
     messages.append({"role": "user", "content": prompt})
-    
+
     return messages
 
+def _chat_candidates(primary_key: str, primary_config: dict):
+    """Primary provider'ı dene, başarısız olursa fallback'i yield et."""
+    yield primary_key, primary_config, False
+
+    fallback_key = PROVIDER_FALLBACK.get(primary_config["provider"])
+    if fallback_key and fallback_key != primary_key and fallback_key in MODELS:
+        yield fallback_key, MODELS[fallback_key], True
+
 # ========== PROVIDER-SPECIFIC API CALLS ==========
 
 def call_groq_api(
@@ -312,6 +399,36 @@ def call_llm7_api(
         logger.error(f"LLM7 API error: {e}")
         raise HTTPException(status_code=500, detail=f"LLM7 API error: {str(e)}")
 
+def call_openrouter_api(
+    model_id: str,
+    messages: list,
+    max_tokens: int,
+    temperature: float,
+    top_p: float,
+    stream: bool = False
+):
+    """OpenRouter API'ye istek at"""
+    if not openrouter_client:
+        raise HTTPException(status_code=500, detail="OpenRouter API key not configured")
+
+    try:
+        response = openrouter_client.chat.completions.create(
+            model=model_id,
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            stream=stream,
+            extra_headers={
+                "HTTP-Referer": OPENROUTER_SITE_URL,
+                "X-OpenRouter-Title": OPENROUTER_SITE_NAME
+            }
+        )
+        return response
+    except Exception as e:
+        logger.error(f"OpenRouter API error: {e}")
+        raise HTTPException(status_code=500, detail=f"OpenRouter API error: {str(e)}")
+
 def call_api(
     provider: str,
     model_id: str,
@@ -326,6 +443,8 @@ def call_api(
         return call_groq_api(model_id, messages, max_tokens, temperature, top_p, stream)
     elif provider == "llm7":
         return call_llm7_api(model_id, messages, max_tokens, temperature, top_p, stream)
+    elif provider == "openrouter":
+        return call_openrouter_api(model_id, messages, max_tokens, temperature, top_p, stream)
     else:
         raise HTTPException(status_code=400, detail=f"Unknown provider: {provider}")
 
@@ -340,7 +459,8 @@ def health_check():
         "timestamp": datetime.now().isoformat(),
         "providers": {
             "groq": bool(GROQ_API_KEY),
-            "llm7": True
+            "llm7": True,
+            "openrouter": bool(OPENROUTER_API_KEY)
         }
     }
 
@@ -371,48 +491,62 @@ def chat(
         request.history
     )
     
-    try:
-        response = call_api(
-            provider=provider,
-            model_id=model_id,
-            messages=messages,
-            max_tokens=request.max_tokens,
-            temperature=request.temperature,
-            top_p=request.top_p,
-            stream=False
-        )
+    attempts = 0
+    last_error = None
 
-        content = response.choices[0].message.content
-        usage = {
-            "prompt_tokens": getattr(response.usage, 'prompt_tokens', 0),
-            "completion_tokens": getattr(response.usage, 'completion_tokens', 0),
-            "total_tokens": getattr(response.usage, 'total_tokens', 0)
-        }
-        
-        elapsed = time.time() - start_time
-        logger.info(f"Chat completed: provider={provider}, tokens={usage['total_tokens']}, time={elapsed:.2f}s")
-        
-        return {
-            "response": content,
-            "model": model_id,
-            "model_key": model_key,
-            "model_size": model_config["size"],
-            "model_language": model_config["language"],
-            "provider": provider,
-            "attempts": 1,
-            "usage": usage,
-            "parameters": {
-                "max_tokens": request.max_tokens,
-                "temperature": request.temperature,
-                "top_p": request.top_p
+    for attempt_model_key, attempt_model_config, is_fallback in _chat_candidates(model_key, model_config):
+        attempts += 1
+        attempt_provider = attempt_model_config["provider"]
+        attempt_model_id = attempt_model_config["model_id"]
+
+        if is_fallback:
+            logger.warning(f"Primary provider failed, retrying with fallback: {attempt_model_key} via {attempt_provider}")
+
+        try:
+            response = call_api(
+                provider=attempt_provider,
+                model_id=attempt_model_id,
+                messages=messages,
+                max_tokens=request.max_tokens,
+                temperature=request.temperature,
+                top_p=request.top_p,
+                stream=False
+            )
+
+            content = response.choices[0].message.content
+            usage = {
+                "prompt_tokens": getattr(response.usage, 'prompt_tokens', 0),
+                "completion_tokens": getattr(response.usage, 'completion_tokens', 0),
+                "total_tokens": getattr(response.usage, 'total_tokens', 0)
+            }
+
+            elapsed = time.time() - start_time
+            logger.info(f"Chat completed: provider={attempt_provider}, model={attempt_model_key}, tokens={usage['total_tokens']}, time={elapsed:.2f}s, attempts={attempts}")
+
+            return {
+                "response": content,
+                "model": attempt_model_id,
+                "model_key": attempt_model_key,
+                "model_size": attempt_model_config["size"],
+                "model_language": attempt_model_config["language"],
+                "fallback_used": is_fallback,
+                "attempts": attempts,
+                "usage": usage,
+                "parameters": {
+                    "max_tokens": request.max_tokens,
+                    "temperature": request.temperature,
+                    "top_p": request.top_p
+                }
             }
-        }
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Chat error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+
+        except HTTPException as e:
+            last_error = e
+            logger.error(f"Provider {attempt_provider} failed (attempt {attempts}): {e.detail}")
+        except Exception as e:
+            last_error = HTTPException(status_code=500, detail=str(e))
+            logger.error(f"Provider {attempt_provider} error (attempt {attempts}): {e}")
+
+    raise last_error or HTTPException(status_code=500, detail="All providers failed")
 
 @app.post("/api/chat/stream")
 def chat_stream(
@@ -499,12 +633,42 @@ def chat_stream(
         except Exception as e:
             logger.error(f"LLM7 stream error: {e}")
             yield f"data: {json.dumps({'error': str(e)})}\n\n"
+
+    def generate_openrouter():
+        """OpenRouter streaming generator"""
+        try:
+            yield f"data: {json.dumps({'info': f'Using {model_key} via OpenRouter'})}\n\n"
+
+            stream = call_openrouter_api(
+                model_id=model_id,
+                messages=messages,
+                max_tokens=request.max_tokens,
+                temperature=request.temperature,
+                top_p=request.top_p,
+                stream=True
+            )
+
+            total_completion_tokens = 0
+
+            for chunk in stream:
+                if chunk.choices and chunk.choices[0].delta and chunk.choices[0].delta.content:
+                    text = chunk.choices[0].delta.content
+                    yield f"data: {json.dumps({'text': text})}\n\n"
+                    total_completion_tokens += 1
+
+            yield f"data: {json.dumps({'done': True, 'model_key': model_key, 'provider': 'openrouter', 'attempts': 1, 'usage': {'prompt_tokens': 0, 'completion_tokens': total_completion_tokens, 'total_tokens': total_completion_tokens}})}\n\n"
+
+        except Exception as e:
+            logger.error(f"OpenRouter stream error: {e}")
+            yield f"data: {json.dumps({'error': str(e)})}\n\n"
     
     # Provider'a göre generator seç
     if provider == "groq":
         generator = generate_groq()
     elif provider == "llm7":
         generator = generate_llm7()
+    elif provider == "openrouter":
+        generator = generate_openrouter()
     else:
         raise HTTPException(status_code=400, detail=f"Unknown provider: {provider}")