app.py

import gradio as gr
from fastapi import FastAPI, Request, HTTPException
from fastapi.responses import StreamingResponse
import random
import asyncio
import aiohttp
import uvicorn

from src.config import get_api_keys
from src.model_tester import ModelTester
from src.scheduler import Scheduler


model_tester = ModelTester()
scheduler = Scheduler(task_callback=lambda: model_tester.scan_all_models())

fastapi_app = FastAPI(title="OpenRouter Free API")


@fastapi_app.on_event("startup")
async def startup_event():
    scheduler.start()


@fastapi_app.get("/v1/models")
async def list_models():
    available = model_tester.get_available_models(free_only=False)
    available_free = model_tester.get_available_models(free_only=True)

    models = []
    for model_id in available:
        is_free = model_id in available_free
        models.append({
            "id": model_id,
            "object": "model",
            "created": 1677610602,
            "owned_by": "openrouter",
            "free": is_free
        })

    return {"object": "list", "data": models}


async def _select_candidates(model_hint: str) -> list[str]:
    """获取候选模型列表（带排序：free 优先）"""
    await model_tester.refresh_model_list_async()
    all_free = model_tester.get_all_free_models()
    all_models = model_tester._all_models

    if not model_hint:
        return all_free[:10]

    hint = model_hint.lower()

    # free 候选（精确优先）
    free_exact = []
    free_fuzzy = []
    for m in all_free:
        name = m.replace(":free", "").split("/")[-1].lower()
        if name == hint:
            free_exact.append(m)
        elif name.startswith(hint) or hint in name:
            free_fuzzy.append(m)

    # 付费候选
    free_set = set(all_free)
    paid_fuzzy = []
    for m in all_models:
        if m in free_set:
            continue
        name = m.replace(":free", "").split("/")[-1].lower()
        if name == hint or hint in name or hint in m.lower():
            paid_fuzzy.append(m)

    return (free_exact + free_fuzzy + paid_fuzzy)[:15]


def _is_definitive_error(error: str) -> bool:
    """不可重试的错误（模型不存在/无权访问）"""
    keywords = ("HTTP 400", "HTTP 403", "HTTP 404",
                "model_not_found", "not found", "not_found")
    return any(k in error for k in keywords)


async def _proxy_with_retry(body: dict, candidates: list[str]) -> dict:
    """

    带重试的代理请求。



    遍历候选模型，对每个模型：

    - 遇到限流/超时/5xx → 换 key + 退避重试

    - 遇到 400/403/404 → 跳到下一个候选

    - 所有候选全失败 → 返回 400

    """
    api_keys = get_api_keys()
    max_retries = 3          # 每个模型最多重试次数
    retry_delay = 5          # 退避基数（秒）

    for candidate in candidates:
        failed_keys: set = set()

        for attempt in range(max_retries):
            # 从可用 key 中选一个
            available = [k for k in api_keys if k not in failed_keys]
            if not available:
                print(f"[proxy] All keys exhausted for {candidate}")
                break
            api_key = random.choice(available)

            body["model"] = candidate

            url = "https://openrouter.ai/api/v1/chat/completions"
            headers = {
                "Authorization": f"Bearer {api_key}",
                "Content-Type": "application/json"
            }

            try:
                async with aiohttp.ClientSession() as session:
                    async with session.post(url, json=body, headers=headers,
                                            timeout=aiohttp.ClientTimeout(total=120)) as response:
                        data = await response.json()

                        if "error" in data:
                            error_detail = str(data["error"])
                            print(f"[proxy] {candidate} → {error_detail[:100]}")

                            # 不可重试 → 跳下一个候选
                            if _is_definitive_error(error_detail):
                                break

                            # 401 → 换 key
                            if "401" in error_detail or "unauthorized" in error_detail.lower():
                                failed_keys.add(api_key)
                                continue

                            # 429 / 5xx / 其他 → 退避重试
                            sleep_s = retry_delay * (attempt + 1)
                            print(f"[proxy] {candidate} retry {attempt + 1}/{max_retries} in {sleep_s}s")
                            await asyncio.sleep(sleep_s)
                            continue

                        return data

            except (asyncio.TimeoutError, aiohttp.ClientError) as e:
                print(f"[proxy] {candidate} error: {e}")
                sleep_s = retry_delay * (attempt + 1)
                await asyncio.sleep(sleep_s)
                continue

            except Exception as e:
                print(f"[proxy] {candidate} unexpected error: {e}")
                sleep_s = retry_delay * (attempt + 1)
                await asyncio.sleep(sleep_s)
                continue

        # 当前候选所有重试用完，换下一个

    raise HTTPException(status_code=400, detail="No available model responded")


async def _proxy_streaming(body: dict, candidates: list[str]):
    """流式代理 — 逐个尝试候选模型"""
    api_keys = get_api_keys()

    url = "https://openrouter.ai/api/v1/chat/completions"
    body["stream"] = True

    for candidate in candidates:
        api_key = random.choice(api_keys)
        body["model"] = candidate

        headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

        try:
            async with aiohttp.ClientSession() as session:
                async with session.post(url, json=body, headers=headers,
                                        timeout=aiohttp.ClientTimeout(total=120)) as response:
                    if response.status != 200:
                        print(f"[proxy:stream] {candidate} → HTTP {response.status}, trying next")
                        continue

                    async for chunk in response.content:
                        yield chunk
                    return
        except Exception as e:
            print(f"[proxy:stream] {candidate} error: {e}, trying next")
            continue

    raise HTTPException(status_code=400, detail="No available model for streaming")


@fastapi_app.post("/v1/chat/completions")
async def chat_completions(request: Request):
    body = await request.json()
    model_hint = body.get("model")

    candidates = await _select_candidates(model_hint)
    if not candidates:
        raise HTTPException(status_code=400, detail="No available model")

    if body.get("stream"):
        return StreamingResponse(
            _proxy_streaming(body, candidates),
            media_type="text/event-stream"
        )

    return await _proxy_with_retry(body, candidates)


@fastapi_app.get("/health")
async def health():
    return {"status": "ok"}


def get_scan_status():
    scan_result = model_tester.scan_result
    total = scan_result.get("total_available", 0)
    free = scan_result.get("free_available", 0)
    return f"Free: {free} | Total: {total}"


def format_model_list(models):
    return "\n".join(models) if models else "No models available"


with gr.Blocks(title="OpenRouter Free API") as demo:
    gr.Markdown("# OpenRouter Free API")
    gr.Markdown("Standard OpenAI-compatible API with free model support")
    gr.Markdown(f"**Status: {get_scan_status()}**")
    gr.Markdown("## Available Free Models")
    gr.Textbox(value=format_model_list(model_tester.get_available_models(free_only=True)), lines=15, interactive=False)


app = gr.mount_gradio_app(fastapi_app, demo, path="/")


if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=7860)