Provider API Configuration
| Provider | Key A | Key B | Models |
|---|
| Loading… |
"""
# ── Auth Dependency ───────────────────────────────────────────────────────────
async def require_auth(request: Request):
key = request.headers.get("X-API-Key", "").strip()
if not VALID_KEYS:
raise HTTPException(status_code=500, detail="MOHAN_API_KEY not configured on server.")
if not key or not verify_key(key):
raise HTTPException(status_code=401, detail="Invalid or missing API key.")
return key
# ── Routes ────────────────────────────────────────────────────────────────────
@app.get("/", response_class=HTMLResponse)
def home(): return HTML_UI
@app.get("/dashboard", response_class=HTMLResponse)
def dashboard(): return DASHBOARD_HTML
@app.post("/auth/verify")
async def auth_verify(request: Request):
key = request.headers.get("X-API-Key", "").strip()
if not VALID_KEYS:
raise HTTPException(status_code=500, detail="MOHAN_API_KEY not configured on server.")
if key and verify_key(key):
return {"ok": True}
raise HTTPException(status_code=401, detail="Invalid key. Access denied.")
@app.get("/models")
def get_models(key: str = Depends(require_auth)):
return {"models": ALL_MODELS, "total": len(ALL_MODELS)}
@app.get("/debug")
def debug(key: str = Depends(require_auth)):
return {
"openrouter": {"key_loaded": bool(OPENROUTER_API_KEY)},
"openrouter_b": {"key_loaded": bool(OPENROUTER_API_KEY_B)},
"gemini": {"key_loaded": bool(GEMINI_API_KEY)},
"gemini_b": {"key_loaded": bool(GEMINI_API_KEY_B)},
"groq": {"key_loaded": bool(GROQ_API_KEY)},
"groq_b": {"key_loaded": bool(GROQ_API_KEY_B)},
"cerebras": {"key_loaded": bool(CEREBRAS_API_KEY)},
"cerebras_b": {"key_loaded": bool(CEREBRAS_API_KEY_B)},
"mistral": {"key_loaded": bool(MISTRAL_API_KEY)},
"mistral_b": {"key_loaded": bool(MISTRAL_API_KEY_B)},
"nvidia": {"key_loaded": bool(NVIDIA_API_KEY)},
"nvidia_b": {"key_loaded": bool(NVIDIA_API_KEY_B)},
}
@app.post("/chat/completions")
async def chat(request: Request, key: str = Depends(require_auth)):
body = await request.json()
model_id: str = body.get("model", "")
try:
# ── Gemini A (with auto B fallback) ──
if is_gemini(model_id):
if not GEMINI_API_KEY and not GEMINI_API_KEY_B:
return JSONResponse({"error": "GEMINI_API_KEY not configured."}, status_code=500)
return await call_gemini(strip_prefix(model_id), GEMINI_API_KEY, GEMINI_API_KEY_B, body, model_id)
# ── Gemini B (direct) ──
if is_gemini_b(model_id):
if not GEMINI_API_KEY_B:
return JSONResponse({"error": "GEMINI_API_KEY_B not configured."}, status_code=500)
return await call_gemini(strip_prefix(model_id), GEMINI_API_KEY_B, "", body, model_id)
# ── Groq A (with auto B fallback) ──
if is_groq(model_id):
if not GROQ_API_KEY and not GROQ_API_KEY_B:
return JSONResponse({"error": "GROQ_API_KEY not configured."}, status_code=500)
return await call_openai_compat(GROQ_BASE, GROQ_API_KEY, GROQ_API_KEY_B, strip_prefix(model_id), body)
# ── Groq B (direct) ──
if is_groq_b(model_id):
if not GROQ_API_KEY_B:
return JSONResponse({"error": "GROQ_API_KEY_B not configured."}, status_code=500)
return await call_openai_compat(GROQ_BASE, GROQ_API_KEY_B, "", strip_prefix(model_id), body)
# ── Cerebras A (with auto B fallback) ──
if is_cerebras(model_id):
if not CEREBRAS_API_KEY and not CEREBRAS_API_KEY_B:
return JSONResponse({"error": "CEREBRAS_API_KEY not configured."}, status_code=500)
return await call_openai_compat(CEREBRAS_BASE, CEREBRAS_API_KEY, CEREBRAS_API_KEY_B, strip_prefix(model_id), body)
# ── Cerebras B (direct) ──
if is_cerebras_b(model_id):
if not CEREBRAS_API_KEY_B:
return JSONResponse({"error": "CEREBRAS_API_KEY_B not configured."}, status_code=500)
return await call_openai_compat(CEREBRAS_BASE, CEREBRAS_API_KEY_B, "", strip_prefix(model_id), body)
# ── Mistral A (with auto B fallback) ──
if is_mistral(model_id):
if not MISTRAL_API_KEY and not MISTRAL_API_KEY_B:
return JSONResponse({"error": "MISTRAL_API_KEY not configured."}, status_code=500)
return await call_openai_compat(MISTRAL_BASE, MISTRAL_API_KEY, MISTRAL_API_KEY_B, strip_prefix(model_id), body)
# ── Mistral B (direct) ──
if is_mistral_b(model_id):
if not MISTRAL_API_KEY_B:
return JSONResponse({"error": "MISTRAL_API_KEY_B not configured."}, status_code=500)
return await call_openai_compat(MISTRAL_BASE, MISTRAL_API_KEY_B, "", strip_prefix(model_id), body)
# ── NVIDIA A (with auto B fallback) ──
if is_nvidia(model_id):
if not NVIDIA_API_KEY and not NVIDIA_API_KEY_B:
return JSONResponse({"error": "NVIDIA_API_KEY not configured."}, status_code=500)
return await call_openai_compat(NVIDIA_BASE, NVIDIA_API_KEY, NVIDIA_API_KEY_B, strip_prefix(model_id), body)
# ── NVIDIA B (direct) ──
if is_nvidia_b(model_id):
if not NVIDIA_API_KEY_B:
return JSONResponse({"error": "NVIDIA_API_KEY_B not configured."}, status_code=500)
return await call_openai_compat(NVIDIA_BASE, NVIDIA_API_KEY_B, "", strip_prefix(model_id), body)
# ── OpenRouter B (direct) ──
if is_openrouter_b(model_id):
if not OPENROUTER_API_KEY_B:
return JSONResponse({"error": "OPENROUTER_API_KEY_B not configured."}, status_code=500)
async with httpx.AsyncClient(timeout=60) as client:
real_model = strip_prefix(model_id)
resp = await client.post(
f"{OPENROUTER_BASE}/chat/completions",
headers={
"Authorization": f"Bearer {OPENROUTER_API_KEY_B}",
"Content-Type": "application/json",
"HTTP-Referer": "https://senpai315-mohan-ai.hf.space",
"X-Title": "Mohan-AI Playground",
},
json={**body, "model": real_model}
)
return JSONResponse(content=resp.json(), status_code=resp.status_code)
# ── OpenRouter A (with auto B fallback) — default fallback ──
if not OPENROUTER_API_KEY and not OPENROUTER_API_KEY_B:
return JSONResponse({"error": "OPENROUTER_API_KEY not configured."}, status_code=500)
async with httpx.AsyncClient(timeout=60) as client:
headers_a = {
"Authorization": f"Bearer {OPENROUTER_API_KEY}",
"Content-Type": "application/json",
"HTTP-Referer": "https://senpai315-mohan-ai.hf.space",
"X-Title": "Mohan-AI Playground",
}
if OPENROUTER_API_KEY:
resp = await client.post(f"{OPENROUTER_BASE}/chat/completions", headers=headers_a, json=body)
data = resp.json()
if not is_quota_error(resp.status_code, data):
return JSONResponse(content=data, status_code=resp.status_code)
# Fallback to B
if OPENROUTER_API_KEY_B:
headers_b = {**headers_a, "Authorization": f"Bearer {OPENROUTER_API_KEY_B}"}
resp = await client.post(f"{OPENROUTER_BASE}/chat/completions", headers=headers_b, json=body)
return JSONResponse(content=resp.json(), status_code=resp.status_code)
return JSONResponse({"error": "All OpenRouter keys exhausted."}, status_code=429)
except Exception as e:
return JSONResponse({"error": str(e)}, status_code=500)