Remove from hf space

Dockerfile

@@ -1,15 +0,0 @@
-FROM python:3.13-slim
-
-RUN apt-get update && apt-get install -y --no-install-recommends git \
-    && rm -rf /var/lib/apt/lists/*
-
-RUN useradd -m -u 1000 user
-USER user
-ENV PATH="/home/user/.local/bin:$PATH"
-
-WORKDIR /app
-
-COPY --chown=user start.sh /app/start.sh
-RUN chmod +x /app/start.sh
-
-CMD ["/app/start.sh"]

app.py

@@ -1,863 +0,0 @@
-import os
-import time
-import hashlib
-import hmac
-from fastapi import WebSocket, WebSocketDisconnect
-from collections import defaultdict, deque
-import json
-from fastapi import FastAPI, Request, HTTPException, status, Header
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import (
-    Response,
-    JSONResponse,
-    StreamingResponse,
-    RedirectResponse,
-)
-import httpx
-from bs4 import BeautifulSoup
-from typing import List, Dict, Any
-import asyncio
-import re
-import random
-from urllib.parse import quote
-import base64
-from pathlib import Path
-from helper.subscriptions import (
-    fetch_subscription,
-    normalize_plan_key,
-    TIER_CONFIG,
-    PLAN_ORDER,
-    resolve_token_identity,
-)
-from typing import Optional
-from helper.keywords import *
-from helper.assets import asset_router
-
-from helper.ratelimit import (
-    enforce_rate_limit,
-    resolve_rate_limit_identity,
-    check_audio_rate_limit,
-    check_video_rate_limit,
-    check_image_rate_limit,
-    MAX_CHAT_PROMPT_BYTES,
-    MAX_CHAT_PROMPT_CHARS,
-    MAX_GROQ_PROMPT_BYTES,
-    MAX_GROQ_PROMPT_CHARS,
-    MAX_MEDIA_PROMPT_BYTES,
-    MAX_MEDIA_PROMPT_CHARS,
-    extract_user_text,
-    calculate_messages_size,
-    normalize_prompt_value,
-    enforce_prompt_size,
-    resolve_bound_subject,
-    get_usage_snapshot_for_subject,
-    consume_metric_for_subject,
-    get_metric_snapshot_for_subject,
-    normalize_forwarded_ip,
-    resolve_verify_token_rate_limit_identity,
-)
-
-from status import router as status_router
-from gen import router as gen_router
-from payg import router as payg_router
-
-app = FastAPI()
-def print_env_for_dotenv():
-    import os
-    for key, value in os.environ.items():
-        safe = str(value).replace('"', '\\"')
-        print(f'{key}="{safe}"')
-print_env_for_dotenv()
-LIGHTNING_TRANSFER_TOKEN = os.getenv("LIGHTNING_TRANSFER_TOKEN")
-VERIFY_TOKEN_USAGE_METRIC = "verifyTokenWithEmailDaily"
-VERIFY_TOKEN_FEATURE_NAME = "Token Verification Requests"
-VERIFY_TOKEN_CONTACT_NOTICE = (
-    "Need more usage? Contact us at inferenceportai@gmail.com."
-)
-
-WEBSOCKET_KEY = os.getenv("WEBSOCKET_KEY")
-
-# authentication attempt tracking
-AUTH_ATTEMPTS = defaultdict(lambda: deque())
-
-AUTH_WINDOW_SECONDS = 60
-AUTH_MAX_ATTEMPTS = 10
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["GET", "POST", "PUT", "DELETE", "HEAD"],
-    allow_headers=["*"],
-)
-
-app.include_router(asset_router)
-app.include_router(status_router)
-app.include_router(gen_router)
-app.include_router(payg_router)
-
-TOOL_REGISTRY_ROOT = Path(os.getenv("TOOL_REGISTRY_ROOT", "/tools"))
-TOOL_REGISTRY_INDEX = TOOL_REGISTRY_ROOT / "registry_index.json"
-TOOL_REGISTRY_LOCK = asyncio.Lock()
-
-
-def _ensure_tool_registry_root() -> None:
-    TOOL_REGISTRY_ROOT.mkdir(parents=True, exist_ok=True)
-    if not TOOL_REGISTRY_INDEX.exists():
-        TOOL_REGISTRY_INDEX.write_text("{}", encoding="utf-8")
-
-
-def _read_tool_registry_index() -> Dict[str, Dict[str, Any]]:
-    _ensure_tool_registry_root()
-    try:
-        raw = TOOL_REGISTRY_INDEX.read_text(encoding="utf-8")
-        data = json.loads(raw)
-        if isinstance(data, dict):
-            return data
-    except Exception:
-        pass
-    return {}
-
-
-def _write_tool_registry_index(index: Dict[str, Dict[str, Any]]) -> None:
-    _ensure_tool_registry_root()
-    TOOL_REGISTRY_INDEX.write_text(json.dumps(index, indent=2), encoding="utf-8")
-
-
-def _sanitize_tool_id(value: str) -> str:
-    tool_id = re.sub(r"[^a-zA-Z0-9_-]", "-", str(value or "").strip().lower())
-    tool_id = re.sub(r"-{2,}", "-", tool_id).strip("-")
-    return tool_id[:80]
-
-
-def _sanitize_tool_file_name(value: str) -> str:
-    name = Path(value or "tool").name
-    name = re.sub(r"[^a-zA-Z0-9._-]", "_", name)
-    return name[:120]
-
-
-def _normalize_tool_version(value: Any) -> str:
-    version = str(value or "0.1.0").strip()
-    if re.match(r"^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$", version):
-        return version[:64]
-    return "0.1.0"
-
-
-def _normalize_https_url(value: Any) -> str:
-    raw = str(value or "").strip()
-    if raw.startswith("https://"):
-        return raw[:512]
-    return ""
-
-
-def _to_registry_record(manifest: Dict[str, Any], *, now_iso: str) -> Dict[str, Any]:
-    tool_id = _sanitize_tool_id(manifest.get("id") or "")
-    code_file = _sanitize_tool_file_name(manifest.get("codeFile") or "tool")
-    visibility = str(manifest.get("visibility") or "public").strip().lower()
-    if visibility not in {"public", "unlisted"}:
-        visibility = "public"
-    return {
-        "id": tool_id,
-        "name": str(manifest.get("name") or tool_id),
-        "functionality": str(manifest.get("functionality") or ""),
-        "version": str(manifest.get("version") or "0.1.0"),
-        "releaseNotes": str(manifest.get("releaseNotes") or ""),
-        "websiteUrl": str(manifest.get("websiteUrl") or ""),
-        "language": str(manifest.get("language") or "javascript"),
-        "authorEmail": str(manifest.get("authorEmail") or ""),
-        "authorUserId": manifest.get("authorUserId"),
-        "codeHash": manifest.get("codeHash"),
-        "visibility": visibility,
-        "publishedAt": str(manifest.get("createdAt") or now_iso),
-        "updatedAt": now_iso,
-        "requirements": manifest.get("requirements") or {"runtime": [], "build": []},
-        "userInputs": manifest.get("userInputs") if isinstance(manifest.get("userInputs"), list) else [],
-        "openai": manifest.get("openai") or {},
-        "files": {
-            "manifestPath": f"{tool_id}/manifest.json",
-            "codePath": f"{tool_id}/{code_file}",
-        },
-    }
-
-
-async def _require_registry_identity(authorization: Optional[str]) -> Dict[str, Any]:
-    if not authorization or not authorization.startswith("Bearer "):
-        raise HTTPException(status_code=401, detail="Missing or invalid Authorization header")
-    token = authorization.split(" ", 1)[1].strip()
-    identity = await resolve_token_identity(token)
-    if not identity or "error" in identity:
-        raise HTTPException(status_code=401, detail="Invalid authorization token")
-    return identity
-
-
-@app.get("/tool-registry/tools")
-async def list_tool_registry_tools(q: Optional[str] = None, limit: int = 200):
-    index = _read_tool_registry_index()
-    rows = []
-    query = (q or "").strip().lower()
-    max_items = max(1, min(limit, 500))
-    for _, record in index.items():
-        if not isinstance(record, dict):
-            continue
-        if record.get("visibility") != "public":
-            continue
-        if query:
-            text = " ".join(
-                [
-                    str(record.get("id") or ""),
-                    str(record.get("name") or ""),
-                    str(record.get("functionality") or ""),
-                    str(record.get("language") or ""),
-                ]
-            ).lower()
-            if query not in text:
-                continue
-        rows.append(record)
-    rows.sort(key=lambda row: str(row.get("updatedAt") or ""), reverse=True)
-    return JSONResponse(status_code=200, content={"tools": rows[:max_items]})
-
-
-@app.get("/tool-registry/my-tools")
-async def list_my_tool_registry_tools(
-    authorization: Optional[str] = Header(None),
-    limit: int = 500,
-):
-    identity = await _require_registry_identity(authorization)
-    author_email = str(identity.get("email") or "").strip().lower()
-    user_id = str(identity.get("user_id") or "").strip()
-    max_items = max(1, min(limit, 1000))
-    index = _read_tool_registry_index()
-    rows = []
-    for _, record in index.items():
-        if not isinstance(record, dict):
-            continue
-        owner_email = str(record.get("authorEmail") or "").strip().lower()
-        owner_user_id = str(record.get("authorUserId") or "").strip()
-        if (user_id and owner_user_id == user_id) or (author_email and owner_email == author_email):
-            rows.append(record)
-    rows.sort(key=lambda row: str(row.get("updatedAt") or ""), reverse=True)
-    return JSONResponse(status_code=200, content={"tools": rows[:max_items]})
-
-
-@app.get("/tool-registry/tools/{tool_id}")
-async def get_tool_registry_item(tool_id: str):
-    normalized_id = _sanitize_tool_id(tool_id)
-    if not normalized_id:
-        raise HTTPException(status_code=400, detail="Invalid tool id")
-    index = _read_tool_registry_index()
-    record = index.get(normalized_id)
-    if not record:
-        raise HTTPException(status_code=404, detail="Tool not found")
-    return JSONResponse(status_code=200, content={"tool": record})
-
-
-@app.get("/tool-registry/tools/{tool_id}/source")
-async def get_tool_registry_source(tool_id: str):
-    normalized_id = _sanitize_tool_id(tool_id)
-    if not normalized_id:
-        raise HTTPException(status_code=400, detail="Invalid tool id")
-    index = _read_tool_registry_index()
-    record = index.get(normalized_id)
-    if not record:
-        raise HTTPException(status_code=404, detail="Tool not found")
-    manifest_path = TOOL_REGISTRY_ROOT / str(record.get("files", {}).get("manifestPath", ""))
-    code_path = TOOL_REGISTRY_ROOT / str(record.get("files", {}).get("codePath", ""))
-    if not manifest_path.exists() or not code_path.exists():
-        raise HTTPException(status_code=404, detail="Tool source files not found")
-    try:
-        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
-    except Exception:
-        raise HTTPException(status_code=500, detail="Failed to load tool manifest")
-    try:
-        code = code_path.read_text(encoding="utf-8")
-    except Exception:
-        raise HTTPException(status_code=500, detail="Failed to load tool code")
-    return JSONResponse(status_code=200, content={"manifest": manifest, "code": code})
-
-
-@app.post("/tool-registry/tools")
-async def create_tool_registry_item(
-    request: Request,
-    authorization: Optional[str] = Header(None),
-):
-    identity = await _require_registry_identity(authorization)
-    body = await request.json()
-    if not isinstance(body, dict):
-        raise HTTPException(status_code=400, detail="Invalid JSON body")
-    manifest = body.get("manifest")
-    code = body.get("code")
-    if not isinstance(manifest, dict) or not isinstance(code, str):
-        raise HTTPException(status_code=400, detail="Manifest and code are required")
-
-    now_iso = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
-    author_email = str(identity.get("email") or "").strip().lower()
-    if not author_email:
-        raise HTTPException(status_code=401, detail="Unable to resolve account email")
-
-    requested_id = _sanitize_tool_id(manifest.get("id") or manifest.get("name") or "")
-    if not requested_id:
-        requested_id = f"tool-{hashlib.sha256(os.urandom(8)).hexdigest()[:10]}"
-    manifest["id"] = requested_id
-    manifest["authorEmail"] = author_email
-    manifest["authorUserId"] = identity.get("user_id")
-
-    code_file = _sanitize_tool_file_name(manifest.get("codeFile") or "tool")
-    manifest["codeFile"] = code_file
-    manifest["codeHash"] = hashlib.sha256(code.encode("utf-8")).hexdigest()
-    manifest["version"] = _normalize_tool_version(manifest.get("version"))
-    manifest["releaseNotes"] = str(manifest.get("releaseNotes") or "")[:4000]
-    manifest["websiteUrl"] = _normalize_https_url(manifest.get("websiteUrl"))
-    visibility = str(manifest.get("visibility") or "public").strip().lower()
-    if visibility not in {"public", "unlisted"}:
-        visibility = "public"
-    manifest["visibility"] = visibility
-    if not manifest.get("createdAt"):
-        manifest["createdAt"] = now_iso
-    manifest["updatedAt"] = now_iso
-    manifest["published"] = True
-    manifest["registry"] = {
-        "source": "lightning",
-        "uploadedAt": manifest.get("createdAt") or now_iso,
-        "updatedAt": now_iso,
-    }
-
-    tool_dir = TOOL_REGISTRY_ROOT / requested_id
-    manifest_path = tool_dir / "manifest.json"
-    code_path = tool_dir / code_file
-    tool_dir.mkdir(parents=True, exist_ok=True)
-    manifest_path.write_text(json.dumps(manifest, indent=2), encoding="utf-8")
-    code_path.write_text(code, encoding="utf-8")
-
-    record = _to_registry_record(manifest, now_iso=now_iso)
-    record["authorEmail"] = author_email
-    record["authorUserId"] = identity.get("user_id")
-
-    async with TOOL_REGISTRY_LOCK:
-        index = _read_tool_registry_index()
-        existing = index.get(requested_id)
-        if existing and str(existing.get("authorEmail", "")).strip().lower() != author_email:
-            raise HTTPException(status_code=403, detail="Tool id already exists")
-        index[requested_id] = record
-        _write_tool_registry_index(index)
-
-    return JSONResponse(status_code=200, content={"tool": record})
-
-
-@app.delete("/tool-registry/tools/{tool_id}")
-async def delete_tool_registry_item(
-    tool_id: str,
-    authorization: Optional[str] = Header(None),
-):
-    identity = await _require_registry_identity(authorization)
-    author_email = str(identity.get("email") or "").strip().lower()
-    normalized_id = _sanitize_tool_id(tool_id)
-    if not normalized_id:
-        raise HTTPException(status_code=400, detail="Invalid tool id")
-
-    async with TOOL_REGISTRY_LOCK:
-        index = _read_tool_registry_index()
-        record = index.get(normalized_id)
-        if not record:
-            raise HTTPException(status_code=404, detail="Tool not found")
-        owner = str(record.get("authorEmail") or "").strip().lower()
-        if owner != author_email:
-            raise HTTPException(status_code=403, detail="Only the publisher can delete this tool")
-        index.pop(normalized_id, None)
-        _write_tool_registry_index(index)
-
-    tool_dir = TOOL_REGISTRY_ROOT / normalized_id
-    if tool_dir.exists():
-        for child in sorted(tool_dir.glob("**/*"), reverse=True):
-            try:
-                if child.is_file():
-                    child.unlink()
-                elif child.is_dir():
-                    child.rmdir()
-            except Exception:
-                continue
-        try:
-            tool_dir.rmdir()
-        except Exception:
-            pass
-
-    return JSONResponse(status_code=200, content={"ok": True})
-
-
-@app.put("/tool-registry/tools/{tool_id}")
-async def update_tool_registry_item(
-    tool_id: str,
-    request: Request,
-    authorization: Optional[str] = Header(None),
-):
-    identity = await _require_registry_identity(authorization)
-    author_email = str(identity.get("email") or "").strip().lower()
-    normalized_id = _sanitize_tool_id(tool_id)
-    if not normalized_id:
-        raise HTTPException(status_code=400, detail="Invalid tool id")
-    body = await request.json()
-    if not isinstance(body, dict):
-        raise HTTPException(status_code=400, detail="Invalid JSON body")
-    manifest = body.get("manifest")
-    code = body.get("code")
-    if not isinstance(manifest, dict):
-        raise HTTPException(status_code=400, detail="Manifest is required")
-
-    async with TOOL_REGISTRY_LOCK:
-        index = _read_tool_registry_index()
-        record = index.get(normalized_id)
-        if not record:
-            raise HTTPException(status_code=404, detail="Tool not found")
-        owner = str(record.get("authorEmail") or "").strip().lower()
-        if owner != author_email:
-            raise HTTPException(status_code=403, detail="Only the publisher can edit this tool")
-
-        now_iso = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
-        manifest["id"] = normalized_id
-        manifest["authorEmail"] = author_email
-        manifest["authorUserId"] = identity.get("user_id")
-        manifest["createdAt"] = manifest.get("createdAt") or record.get("publishedAt") or now_iso
-        manifest["updatedAt"] = now_iso
-        manifest["published"] = True
-        manifest["visibility"] = str(manifest.get("visibility") or record.get("visibility") or "public").lower()
-        if manifest["visibility"] not in {"public", "unlisted"}:
-            manifest["visibility"] = "public"
-        manifest["version"] = _normalize_tool_version(manifest.get("version") or record.get("version"))
-        manifest["releaseNotes"] = str(manifest.get("releaseNotes") or "")[:4000]
-        manifest["websiteUrl"] = _normalize_https_url(manifest.get("websiteUrl"))
-
-        code_file = _sanitize_tool_file_name(
-            manifest.get("codeFile")
-            or Path(str(record.get("files", {}).get("codePath", "tool"))).name
-            or "tool"
-        )
-        manifest["codeFile"] = code_file
-
-        tool_dir = TOOL_REGISTRY_ROOT / normalized_id
-        tool_dir.mkdir(parents=True, exist_ok=True)
-        manifest_path = tool_dir / "manifest.json"
-        code_path = tool_dir / code_file
-        if isinstance(code, str):
-            manifest["codeHash"] = hashlib.sha256(code.encode("utf-8")).hexdigest()
-            code_path.write_text(code, encoding="utf-8")
-        manifest_path.write_text(json.dumps(manifest, indent=2), encoding="utf-8")
-
-        updated_record = _to_registry_record(manifest, now_iso=now_iso)
-        updated_record["authorEmail"] = author_email
-        updated_record["authorUserId"] = identity.get("user_id")
-        index[normalized_id] = updated_record
-        _write_tool_registry_index(index)
-
-    return JSONResponse(status_code=200, content={"tool": updated_record})
-
-def check_ws_auth_rate_limit(ip: str):
-    now = time.time()
-    q = AUTH_ATTEMPTS[ip]
-
-    # purge old attempts
-    while q and now - q[0] > AUTH_WINDOW_SECONDS:
-        q.popleft()
-
-    if len(q) >= AUTH_MAX_ATTEMPTS:
-        return False
-
-    q.append(now)
-    return True
-
-
-@app.get("/")
-async def reroute_to_home():
-    return RedirectResponse(
-        url="https://inference.js.org", status_code=status.HTTP_308_PERMANENT_REDIRECT
-    )
-
-
-OLLAMA_LIBRARY_URL = "https://ollama.com/library"
-
-
-@app.head("/models")
-@app.get("/models")
-async def get_models() -> List[Dict]:
-    async with httpx.AsyncClient() as client:
-        response = await client.get(OLLAMA_LIBRARY_URL)
-        html = response.text
-
-    soup = BeautifulSoup(html, "html.parser")
-    items = soup.select("li[x-test-model]")
-
-    models = []
-    for item in items:
-        name = item.select_one("[x-test-model-title] span")
-        description = item.select_one("p.max-w-lg")
-        sizes = [el.get_text(strip=True) for el in item.select("[x-test-size]")]
-        pulls = item.select_one("[x-test-pull-count]")
-        tags = [
-            t.get_text(strip=True) for t in item.select('span[class*="text-blue-600"]')
-        ]
-        updated = item.select_one("[x-test-updated]")
-        link = item.select_one("a")
-
-        models.append(
-            {
-                "name": name.get_text(strip=True) if name else "",
-                "description": (
-                    description.get_text(strip=True)
-                    if description
-                    else "No description"
-                ),
-                "sizes": sizes,
-                "pulls": pulls.get_text(strip=True) if pulls else "Unknown",
-                "tags": tags,
-                "updated": updated.get_text(strip=True) if updated else "Unknown",
-                "link": link.get("href") if link else None,
-            }
-        )
-
-    return models
-
-@app.get("/subscription")
-async def get_subscription(authorization: Optional[str] = Header(None)):
-    if not authorization or not authorization.startswith("Bearer "):
-        raise HTTPException(401, "Missing or invalid Authorization header")
-
-    jwt = authorization.split(" ", 1)[1]
-
-    result = await fetch_subscription(jwt)
-    if "error" in result:
-        raise HTTPException(401, result["error"])
-
-    plan_key = normalize_plan_key(result.get("plan_key"))
-    result["plan_key"] = plan_key
-    result["plan_name"] = (TIER_CONFIG.get(plan_key) or TIER_CONFIG["free"])["name"]
-    return result
-
-
-@app.get("/usage")
-async def get_usage(
-    request: Request,
-    authorization: Optional[str] = Header(None),
-    x_client_id: Optional[str] = Header(None),
-):
-    plan_key, subject = await resolve_rate_limit_identity(
-        request, authorization, x_client_id
-    )
-    plan = TIER_CONFIG.get(plan_key) or TIER_CONFIG["free"]
-    usage = get_usage_snapshot_for_subject(plan_key, subject)
-    return JSONResponse(
-        status_code=200,
-        content={
-            "plan_key": plan_key,
-            "plan_name": plan.get("name", "Free Tier"),
-            "usage": usage,
-            "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-        },
-    )
-
-
-def build_verify_token_usage_response(
-    plan_key: str,
-    usage: Dict[str, Any],
-    *,
-    error: Optional[str] = None,
-):
-    plan = TIER_CONFIG.get(plan_key) or TIER_CONFIG["free"]
-    payload: Dict[str, Any] = {
-        "plan_key": plan_key,
-        "plan_name": plan.get("name", "Free Tier"),
-        "feature_name": VERIFY_TOKEN_FEATURE_NAME,
-        "notice": VERIFY_TOKEN_CONTACT_NOTICE,
-        "usage": usage,
-        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-    }
-    if error:
-        payload["error"] = error
-    return payload
-
-
-@app.get("/usage/verify-token-with-email")
-async def get_verify_token_with_email_usage(
-    request: Request,
-    authorization: Optional[str] = Header(None),
-):
-    auth_header = (
-        authorization if authorization and authorization.startswith("Bearer ") else None
-    )
-    request_ip = normalize_forwarded_ip(
-        request.headers.get("x-forwarded-for")
-        or request.headers.get("x-real-ip")
-        or (request.client.host if request.client else None)
-    )
-    plan_key, subject = await resolve_verify_token_rate_limit_identity(
-        auth_header, request_ip
-    )
-    usage = get_metric_snapshot_for_subject(plan_key, subject, VERIFY_TOKEN_USAGE_METRIC)
-    return JSONResponse(
-        status_code=200,
-        content=build_verify_token_usage_response(plan_key, usage),
-    )
-
-
-@app.put("/internal/usage/verify-token-with-email")
-async def put_verify_token_with_email_usage(
-    request: Request,
-    x_lightning_transfer_token: Optional[str] = Header(None),
-):
-    if (
-        not LIGHTNING_TRANSFER_TOKEN
-        or not x_lightning_transfer_token
-        or not hmac.compare_digest(x_lightning_transfer_token, LIGHTNING_TRANSFER_TOKEN)
-    ):
-        raise HTTPException(401, "Invalid transfer token")
-
-    try:
-        body = await request.json()
-    except Exception:
-        raise HTTPException(400, "Invalid JSON body")
-
-    auth_header = None
-    raw_jwt = body.get("supabase_jwt") if isinstance(body, dict) else None
-    raw_ip = body.get("ip") if isinstance(body, dict) else None
-
-    if isinstance(raw_jwt, str) and raw_jwt.strip():
-        auth_header = f"Bearer {raw_jwt.strip()}"
-
-    plan_key, subject = await resolve_verify_token_rate_limit_identity(
-        auth_header, normalize_forwarded_ip(raw_ip)
-    )
-
-    try:
-        usage = await consume_metric_for_subject(
-            VERIFY_TOKEN_USAGE_METRIC,
-            plan_key,
-            subject,
-        )
-    except HTTPException as exc:
-        if exc.status_code != 429:
-            raise
-
-        usage = get_metric_snapshot_for_subject(
-            plan_key, subject, VERIFY_TOKEN_USAGE_METRIC
-        )
-        return JSONResponse(
-            status_code=429,
-            content=build_verify_token_usage_response(
-                plan_key,
-                usage,
-                error="Token Verification Requests limit reached for today.",
-            ),
-        )
-
-    return JSONResponse(
-        status_code=200,
-        content=build_verify_token_usage_response(plan_key, usage),
-    )
-
-
-@app.get("/tier-config")
-async def tier_config():
-    plans = []
-    for idx, key in enumerate(PLAN_ORDER):
-        plan = TIER_CONFIG.get(key)
-        if not plan:
-            continue
-        plans.append(
-            {
-                "key": key,
-                "name": plan["name"],
-                "url": plan["url"],
-                "price": plan["price"],
-                "limits": plan["limits"],
-                "order": idx,
-            }
-        )
-
-    return JSONResponse(
-        status_code=200,
-        content={
-            "defaultPlanKey": "free",
-            "plans": plans,
-        },
-    )
-
-
-@app.get("/tiers")
-async def tiers():
-    paid_plans = []
-    for key in PLAN_ORDER:
-        if key == "free":
-            continue
-        plan = TIER_CONFIG.get(key)
-        if not plan:
-            continue
-        paid_plans.append(
-            {
-                "key": key,
-                "name": plan["name"],
-                "url": plan["url"],
-                "price": plan["price"],
-                "limits": plan["limits"],
-            }
-        )
-
-    return JSONResponse(
-        status_code=200,
-        content=paid_plans,
-    )
-
-@app.websocket("/ws/chat")
-async def websocket_chat(ws: WebSocket):
-    ip = ws.client.host
-
-    # Accept connection
-    await ws.accept()
-
-    # Basic connection rate limiting
-    if not check_ws_auth_rate_limit(ip):
-        await ws.close(code=4408)
-        return
-
-    try:
-        # Expect an auth message first
-        auth_msg = await ws.receive_text()
-        try:
-            auth_data = json.loads(auth_msg)
-        except Exception:
-            await ws.close(code=4400)
-            return
-
-        provided_key = auth_data.get("key")
-
-        if not WEBSOCKET_KEY or provided_key != WEBSOCKET_KEY:
-            await ws.close(code=4403)
-            return
-
-        await ws.send_json({
-            "type": "auth",
-            "status": "ok"
-        })
-
-        internal_url = "http://127.0.0.1:7860/gen/chat/completions"
-
-        async with httpx.AsyncClient(
-            timeout=None,
-            follow_redirects=False
-        ) as client:
-            request_counter = 0
-            
-            async def handle_incoming_requests():
-                nonlocal request_counter
-                while True:
-                    try:
-                        msg = await ws.receive_text()
-                    except WebSocketDisconnect:
-                        break
-
-                    try:
-                        data = json.loads(msg)
-                    except Exception:
-                        await ws.send_json({"error": "Invalid JSON"})
-                        continue
-
-                    body = data.get("body")
-                    headers = data.get("headers") or {}
-
-                    if not body:
-                        await ws.send_json({"error": "Missing body"})
-                        continue
-
-                    request_counter += 1
-                    request_id = request_counter
-                    
-                    # Process this request concurrently
-                    asyncio.create_task(process_request(client, request_id, body, headers))
-
-            async def process_request(client, request_id, body, headers):
-                try:
-                    async with client.stream(
-                        "POST",
-                        internal_url,
-                        json=body,
-                        headers=headers
-                    ) as response:
-
-                        # Handle upstream errors
-                        if response.status_code >= 400:
-                            error_text = ""
-                            try:
-                                error_text = (await response.aread()).decode(
-                                    "utf-8", errors="replace"
-                                )[:500]
-                            except Exception:
-                                pass
-
-                            error_payload = json.dumps({
-                                "error": "Upstream request failed",
-                                "status": response.status_code,
-                                "detail": error_text
-                            })
-                            try:
-                                await ws.send_text(f"{request_id}:{error_payload}")
-                            except RuntimeError:
-                                return
-                            return
-
-                        # Stream tokens/lines to the websocket
-                        async for line in response.aiter_lines():
-                            if not line:
-                                continue
-
-                            try:
-                                await ws.send_text(f"{request_id}:{line}")
-                            except RuntimeError:
-                                return
-
-                except Exception as stream_error:
-                    try:
-                        error_payload = json.dumps({
-                            "error": "Streaming error",
-                            "detail": str(stream_error)
-                        })
-                        await ws.send_text(f"{request_id}:{error_payload}")
-                    except Exception:
-                        pass
-
-            # Start handling incoming requests
-            await handle_incoming_requests()
-
-    except WebSocketDisconnect:
-        return
-
-    except Exception as e:
-        try:
-            await ws.send_json({
-                "error": "Server error",
-                "detail": str(e)
-            })
-        except Exception:
-            pass
-
-        try:
-            await ws.close()
-        except Exception:
-            pass
-
-@app.get("/portal")
-@app.post("/portal")
-async def redirect_to_protal(request: Request):
-    email = None
-
-    if request.method == "POST":
-        try:
-            body = await request.json()
-            email = body.get("email")
-        except:
-            email = None
-
-    base_url = "https://billing.stripe.com/p/login/5kQdR9aIM3ts4steyabbG00"
-
-    if not email:
-        return RedirectResponse(url=base_url, status_code=status.HTTP_302_FOUND)
-    if request.method != "POST":
-        return RedirectResponse(
-            url=f"{base_url}?prefilled_email={email}", status_code=status.HTTP_302_FOUND
-        )
-    else:
-        return JSONResponse({"redirect_url": (base_url + "?prefilled_email=" + email)})

assets/admins.json

@@ -1,56 +0,0 @@
-{
-  "sharktidedev@gmail.com": {
-    "plan_key": "core",
-    "product_name": "InferencePort AI Core",
-    "nickname": "Core Plan",
-    "subscription_id": "admin-override",
-    "status": "active",
-    "current_period_end": null,
-    "price_id": null
-  },
-  "hallmax249@gmail.com": {
-    "plan_key": "creator",
-    "product_name": "InferencePort AI Creator",
-    "nickname": "Creator Plan",
-    "subscription_id": "admin-override",
-    "status": "active",
-    "current_period_end": null,
-    "price_id": null
-  },
-  "w81537670@gmail.com": {
-    "plan_key": "light",
-    "product_name": "InferencePort AI Light",
-    "nickname": "Light Plan",
-    "subscription_id": "admin-override",
-    "status": "active",
-    "current_period_end": null,
-    "price_id": null
-  },
-  "jacoblamhome@gmail.com": {
-    "plan_key": "light",
-    "product_name": "InferencePort AI Light",
-    "nickname": "Light Plan",
-    "subscription_id": "admin-override",
-    "status": "active",
-    "current_period_end": null,
-    "price_id": null
-  },
-  "leo.dcam@gmail.com": {
-    "plan_key": "light",
-    "product_name": "InferencePort AI Light",
-    "nickname": "Light Plan",
-    "subscription_id": "admin-override",
-    "status": "active",
-    "current_period_end": null,
-    "price_id": null
-  },
-  "morriszdweck@gmail.com": {
-    "plan_key": "core",
-    "product_name": "InferencePort AI Core",
-    "nickname": "Core Plan",
-    "subscription_id": "admin-override",
-    "status": "active",
-    "current_period_end": null,
-    "price_id": null
-  }
-}

assets/extra_usage.json

@@ -1,7 +0,0 @@
-{
-  "sharktidedev@gmail.com": {
-    "limits": {
-      "verifyTokenWithEmailDaily": 500
-    }
-  }
-}

assets/payg_config.json

@@ -1,119 +0,0 @@
-{
-  "dashboard": {
-    "appName": "InferencePort AI",
-    "homeUrl": "https://inference.js.org",
-    "apiBaseUrl": "https://sharktide-lightning.hf.space",
-    "supportEmail": "inferenceportai@gmail.com",
-    "hostname": ""
-  },
-  "supabase": {
-    "url": "https://dpixehhdbtzsbckfektd.supabase.co",
-    "publishableKey": "sb_publishable_hbqJ9rAlgaeiYRzdVAqY4A_5pwWLSR9",
-    "resetRedirectUrl": "https://inference.js.org/reset.html",
-    "deletePasswordVerifyEndpoint": "https://dpixehhdbtzsbckfektd.supabase.co/functions/v1/verify_password",
-    "deleteAccountEndpoint": "https://dpixehhdbtzsbckfektd.supabase.co/functions/v1/delete_account"
-  },
-  "billing": {
-    "currency": "USD",
-    "packs": [
-      {
-        "id": "pack_25",
-        "label": "$25",
-        "amountUsd": 25,
-        "credits": 25,
-        "stripePaymentLink": "https://buy.stripe.com/14AcN5048bZY9MNdu6bbG0c",
-        "prod": "prod_UaDtOCJlDvJxvL"
-      },
-      {
-        "id": "pack_50",
-        "label": "$50",
-        "amountUsd": 50,
-        "credits": 50,
-        "stripePaymentLink": "https://buy.stripe.com/4gM8wPaIMd422klblYbbG0d",
-        "prod": "prod_UaDudJa2YJ2ZIr"
-      },
-      {
-        "id": "pack_100",
-        "label": "$100",
-        "amountUsd": 100,
-        "credits": 125,
-        "stripePaymentLink": "https://buy.stripe.com/fZu14ncQUbZYaQRahUbbG0e",
-        "prod": "prod_UaDvyEon5kRAID"
-      },
-      {
-        "id": "pack_200",
-        "label": "$200",
-        "amountUsd": 200,
-        "credits": 300,
-        "stripePaymentLink": "https://buy.stripe.com/dRm7sL6swd426ABdu6bbG0f",
-        "prod": "prod_UaDvUBzDw2lp4F"
-      },
-      {
-        "id": "pack_300",
-        "label": "$300",
-        "amountUsd": 300,
-        "credits": 475,
-        "stripePaymentLink": "https://buy.stripe.com/fZu4gzg361lk3op9dQbbG0g",
-        "prod": "prod_UaDxh19Z7kthIf"
-      },
-      {
-        "id": "pack_400",
-        "label": "$400",
-        "amountUsd": 400,
-        "credits": 650,
-        "stripePaymentLink": "https://buy.stripe.com/6oU9AT3gk7JI7EF89MbbG0h",
-        "prod": "prod_UaDxXdUqwo0aIw"
-      },
-      {
-        "id": "pack_500",
-        "label": "$500",
-        "amountUsd": 500,
-        "credits": 800,
-        "stripePaymentLink": "https://buy.stripe.com/14A14nbMQ9RQ5wx4XAbbG0i",
-        "prod": "prod_UaDyyvIggiDUbQ"
-      }
-    ]
-  },
-  "pricing": {
-    "textCreditPerMillionTokens": 0.75,
-    "imageCreditPerImage": 0.02,
-    "videoCreditPerSecond": 0.01,
-    "audioCreditPerSecond": 0.01,
-    "audioDefaultSeconds": 10,
-    "textTokenEstimateMultiplier": 1.0
-  },
-  "models": [
-    {
-      "id": "lightning-text-v2",
-      "type": "text",
-      "name": "Lightning Text v2"
-    },
-    {
-      "id": "lightning-image-turbo",
-      "type": "image",
-      "name": "Lightning Image Turbo"
-    },
-    {
-      "id": "ltx-2-3",
-      "type": "video",
-      "name": "LTX 2.3"
-    },
-    {
-      "id": "acestep-1-5-turbo",
-      "type": "audio",
-      "name": "AceStep 1.5 Turbo"
-    }
-  ],
-  "notices": [
-    {
-      "id": "welcome",
-      "level": "info",
-      "active": true,
-      "message": "Welcome to the InferencePort AI developer console."
-    }
-  ],
-  "limits": {
-    "requestsPerMinutePerIdentity": 120,
-    "minimumTextCreditsBalance": 10
-  }
-}

gen/__init__.py

@@ -1,21 +0,0 @@
-import os
-from fastapi import APIRouter
-
-router = APIRouter(prefix="/gen")
-
-PKEY = os.getenv("POLLINATIONS_KEY", "")
-PKEY2 = os.getenv("POLLINATIONS2_KEY", "")
-PKEY3 = os.getenv("POLLINATIONS3_KEY", "")
-AIRFORCE_KEY = os.getenv("AIRFORCE")
-AIRFORCE_VIDEO_MODEL = "grok-imagine-video"
-AIRFORCE_API_URL = "https://api.airforce/v1/images/generations"
-WEBSOCKET_KEY = os.getenv("WEBSOCKET_KEY", "")
-
-valid_ratios = {"3:2", "2:3", "1:1", "", None}
-ratios = {"3:2", "2:3", "1:1"}
-valid_modes = {"normal", "fun", "", None}
-modes = {"normal", "fun"}
-
-MAX_VIDEO_RETRIES = 6
-
-from . import media, chat, prompt, models

gen/chat.py

@@ -1,361 +0,0 @@
-import os
-import random
-import json
-import httpx
-from typing import Optional
-from fastapi import Request, HTTPException, Header
-from fastapi.responses import JSONResponse, StreamingResponse
-from helper.keywords import *
-from helper.ratelimit import (
-    MAX_CHAT_PROMPT_BYTES,
-    MAX_CHAT_PROMPT_CHARS,
-    MAX_GROQ_PROMPT_BYTES,
-    MAX_GROQ_PROMPT_CHARS,
-    extract_user_text,
-    calculate_messages_size,
-    normalize_prompt_value,
-    enforce_prompt_size,
-)
-from . import router, WEBSOCKET_KEY
-from .common import check_chat_rate_limit
-from .override import get_override, is_allowed_in, resolve_override_routing
-
-MODEL_MAP = {
-    "llama-3.1-8b-instant": "Meta Llama 3.1 8B Instant",
-    "gpt-4o-mini": "OpenAI GPT 4o Mini",
-    "gpt-4.1": "OpenAI GPT 4.1",
-    "nemotron-3-super": "NVIDIA Nemotron 3 Super",
-    "gpt-oss-120b": "OpenAI GPT-OSS 120B",
-    "zai-glm-4.7": "Z.AI GLM 4.7",
-    "openai/gpt-oss-120b": "OpenAI GPT-OSS 120B",
-    "openai/gpt-oss-20b": "OpenAI GPT-OSS 20B",
-    "qwen-3-235b-a22b-instruct-2507": "Qwen3 Instruct",
-    "llama-3.3-70b-versatile": "Meta Llama 3.3 70B Versatile",
-    "meta-llama/llama-4-scout-17b-16e-instruct": "Meta Llama 4 Scout",
-}
-
-
-def route_request(messages: list, body: dict, prompt_text: str) -> dict:
-    """
-    Analyze messages and determine the best model/provider.
-    Returns dict with keys: model, provider, url, api_key, model_name, is_override.
-    If body specifies an override model (from models_override.json), routes there.
-    """
-    requested_model = body.get("model")
-    override = get_override(requested_model) if requested_model else None
-
-    if override:
-        routing = resolve_override_routing(requested_model)
-        if routing and is_allowed_in(requested_model, "gen"):
-            return {
-                "model": requested_model,
-                "model_name": MODEL_MAP.get(requested_model, requested_model),
-                "provider": "override",
-                "url": routing["api_url"],
-                "api_key": routing["api_key"],
-                "is_override": True,
-                "override_key": requested_model,
-            }
-
-    total_chars, total_bytes = calculate_messages_size(messages)
-
-    uses_tools = (
-        "tools" in body and isinstance(body["tools"], list) and len(body["tools"]) > 0
-    ) or ("tool_choice" in body and body["tool_choice"] not in [None, "none"])
-
-    long_context = is_long_context(messages)
-    code_present = contains_code(prompt_text)
-    math_heavy = is_math_heavy(prompt_text)
-    structured_task = is_structured_task(prompt_text)
-    multi_q = multiple_questions(prompt_text)
-    code_heavy = is_code_heavy(prompt_text, code_present, long_context)
-
-    score = 0
-
-    if long_context:
-        score += 3
-
-    if math_heavy:
-        score += 3
-
-    if structured_task:
-        score += 2
-
-    if code_present:
-        score += 2
-
-    if multi_q:
-        score += 1
-
-    for kw in REASONING_KEYWORDS:
-        if kw in prompt_text:
-            score += 1
-
-    chosen_model = "llama-3.3-70b-versatile"
-    provider = "groq"
-    has_images = contains_images(messages)
-
-    if has_images:
-        chosen_model = "gpt-4.1"
-        provider = "navy vision"
-    else:
-        if score > 10:
-            score = 10
-        if uses_tools:
-            if score >= 6:
-                chosen_model = "nemotron-3-super"
-                provider = "navy"
-            elif score >= 4:
-                chosen_model = "gpt-oss-120b"
-                provider = "cerebras"
-            else:
-                chosen_model = "openai/gpt-oss-20b"
-                provider = "groq"
-
-        elif code_present:
-
-            if code_heavy and score >= 6:
-                chosen_model = "o3-mini"
-                provider = "navy"
-
-            elif score >= 4:
-                chosen_model = "zai-glm-4.7"
-                provider = "cerebras"
-
-        elif score >= 4:
-            chosen_model = "openai/gpt-oss-120b"
-            provider = "groq"
-
-        elif score >= 6:
-            chosen_model = "sonar"
-            provider = "navy"
-
-        if provider == "groq" and (
-            total_chars > MAX_GROQ_PROMPT_CHARS or total_bytes > MAX_GROQ_PROMPT_BYTES
-        ):
-            provider = "cerebras"
-            chosen_model = "gpt-oss-120b"
-
-    print(
-        f"""
-    [ADVANCED ROUTER]
-      Score: {score}
-      Uses tools: {uses_tools}
-      Long context: {long_context}
-      Code present: {code_present}
-      Math heavy: {math_heavy}
-      Structured: {structured_task}
-      Multi-question: {multi_q}
-      MULTIMODAL REQUIRED: {has_images}
-      → Selected: {chosen_model} ({provider})
-    """
-    )
-
-    if provider == "groq":
-        groq_keys = os.getenv("GROQ_KEY", "")
-        groq_keys_list = [k.strip() for k in groq_keys.split(",") if k.strip()]
-        if not groq_keys_list:
-            raise HTTPException(500, "Missing GROQ_KEY(s)")
-        api_key = random.choice(groq_keys_list)
-        url = "https://api.groq.com/openai/v1/chat/completions"
-
-    elif provider == "cerebras":
-        cer_keys = os.getenv("CER_KEY", "")
-        cer_keys_list = [k.strip() for k in cer_keys.split(",") if k.strip()]
-        if not cer_keys_list:
-            raise HTTPException(500, "Missing CER_KEY(s)")
-        api_key = random.choice(cer_keys_list)
-        url = "https://api.cerebras.ai/v1/chat/completions"
-
-    elif provider == "navy vision":
-        navy_keys = os.getenv("NAVY_KEY", "")
-        navy_keys_list = [k.strip() for k in navy_keys.split(",") if k.strip()]
-        if not navy_keys_list:
-            raise HTTPException(500, "Missing NAVY Keys(s)")
-        api_key = random.choice(navy_keys_list)
-        url = "https://api.navy/v1/chat/completions"
-
-    elif provider == "navy":
-        navy_keys = os.getenv("NAVY_TEXT_ONLY", "")
-        navy_keys_list = [k.strip() for k in navy_keys.split(",") if k.strip()]
-        if not navy_keys_list:
-            raise HTTPException(500, "Missing NAVY TEXT ONLY Keys(s)")
-        api_key = random.choice(navy_keys_list)
-        url = "https://api.navy/v1/chat/completions"
-
-    else:
-        raise HTTPException(500, "Unknown provider routing error")
-
-    return {
-        "model": chosen_model,
-        "model_name": MODEL_MAP.get(chosen_model, chosen_model),
-        "provider": provider,
-        "url": url,
-        "api_key": api_key,
-        "is_override": False,
-        "override_key": None,
-    }
-
-
-@router.post("/chat/completions")
-async def generate_text(
-    request: Request,
-    authorization: Optional[str] = Header(None),
-    x_client_id: Optional[str] = Header(None),
-):
-    body = await request.json()
-    messages = body.get("messages", [])
-    if not isinstance(messages, list) or len(messages) == 0:
-        raise HTTPException(400, "messages[] is required")
-
-    prompt_text = extract_user_text(messages)
-
-    if request.headers.get("x-payg-internal") != WEBSOCKET_KEY:
-        await check_chat_rate_limit(request, authorization, x_client_id)
-
-    route = route_request(messages, body, prompt_text)
-    chosen_model = route["model"]
-    provider = route["provider"]
-    url = route["url"]
-    api_key = route["api_key"]
-
-    body["model"] = chosen_model
-    headers = {"Authorization": f"Bearer {api_key}"}
-
-    stream = body.get("stream", False)
-    fallback_model = "meta-llama/llama-4-scout-17b-16e-instruct"
-    fallback_provider = "groq"
-
-    if stream:
-        body["stream"] = True
-
-        async def stream_primary(client, url, body, headers):
-            try:
-                async with client.stream("POST", url, json=body, headers=headers) as r:
-
-                    if r.status_code >= 400:
-                        print("[STREAM FALLBACK] Primary provider failed → switching to Groq fallback")
-                        async for chunk in stream_fallback(client, body):
-                            yield chunk
-                        return
-
-                    async for line in r.aiter_lines():
-                        if not line:
-                            yield "\n"
-                            continue
-                        if line.startswith("event: error"):
-                            if line.startswith("data:"):
-                                try:
-                                    obj = json.loads(line[5:].strip())
-                                    if isinstance(obj, dict) and "error" in obj and isinstance(obj["error"], dict):
-                                        pass
-                                except:
-                                    pass
-
-                        yield line + "\n"
-
-            except Exception as e:
-                print(f"[STREAM ERROR] {e}")
-                async for chunk in stream_fallback(client, body):
-                    yield chunk
-
-        async def stream_fallback(client, body):
-            fallback_body = {
-                "model": fallback_model,
-                "messages": body["messages"],
-                "stream": True,
-            }
-
-            groq_keys = os.getenv("GROQ_KEY", "")
-            groq_keys_list = [k.strip() for k in groq_keys.split(",") if k.strip()]
-            fallback_headers = {"Authorization": f"Bearer {random.choice(groq_keys_list)}"}
-
-            print("[FALLBACK] Starting Groq fallback stream")
-
-            async with client.stream(
-                "POST",
-                "https://api.groq.com/openai/v1/chat/completions",
-                json=fallback_body,
-                headers=fallback_headers,
-            ) as r:
-
-                if r.status_code >= 400:
-                    err = (await r.aread()).decode("utf-8", errors="replace")
-                    yield f'data: {{"error": "Fallback provider failed: {err[:500]}"}}\n\n'
-                    return
-
-                async for line in r.aiter_lines():
-                    if not line:
-                        yield "\n"
-                        continue
-
-                    if not line.startswith("data:"):
-                        yield f"data: {line}\n\n"
-                    else:
-                        yield line + "\n"
-
-        async def event_generator():
-            sent_metadata = False
-
-            async with httpx.AsyncClient(timeout=None) as client:
-                async for chunk in stream_primary(client, url, body, headers):
-
-                    if not sent_metadata:
-                        meta = {
-                            "router_metadata": {
-                                "model_name": route["model_name"]
-                            }
-                        }
-                        yield f"data: {json.dumps(meta)}\n\n"
-                        sent_metadata = True
-
-                    yield chunk
-
-        return StreamingResponse(
-            event_generator(),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "X-Accel-Buffering": "no",
-            },
-        )
-
-    else:
-        async with httpx.AsyncClient(timeout=None) as client:
-            r = await client.post(url, json=body, headers=headers)
-            if provider == "navy vision" and r.status_code >= 400:
-                print("[FALLBACK] Navy vision failed — switching to 17B Groq")
-
-                groq_keys = os.getenv("GROQ_KEY", "")
-                groq_keys_list = [k.strip() for k in groq_keys.split(",") if k.strip()]
-                if not groq_keys_list:
-                    raise HTTPException(500, "Missing GROQ_KEY(s) for fallback")
-
-                api_key = random.choice(groq_keys_list)
-
-                fallback_headers = {"Authorization": f"Bearer {api_key}"}
-                fallback_body = dict(body)
-                fallback_body["model"] = fallback_model
-
-                r = await client.post(
-                    "https://api.groq.com/openai/v1/chat/completions",
-                    json=fallback_body,
-                    headers=fallback_headers,
-                )
-        content_type = (r.headers.get("content-type") or "").lower()
-        if "application/json" in content_type:
-            try:
-                payload = r.json()
-            except Exception:
-                payload = {"error": "Upstream returned invalid JSON"}
-        else:
-            payload = {
-                "error": "Upstream returned non-JSON response",
-                "status_code": r.status_code,
-                "message": r.text[:1000],
-            }
-
-        return JSONResponse(status_code=r.status_code, content=payload)
-
-    raise HTTPException(500, "Unknown provider routing error")

gen/common.py

@@ -1,35 +0,0 @@
-import re
-from typing import Optional
-from fastapi import Request, Header
-from helper.keywords import CREATIVE_KEYWORDS, REASONING_KEYWORDS, LIGHTWEIGHT_KEYWORDS
-from helper.ratelimit import enforce_rate_limit
-
-def is_cinematic_image_prompt(prompt: str) -> bool:
-    for kw in CREATIVE_KEYWORDS:
-        if kw in prompt.lower():
-            return True
-    return False
-
-def is_complex_reasoning(prompt: str) -> bool:
-    if len(prompt) > 800:
-        return True
-    for kw in REASONING_KEYWORDS:
-        if kw in prompt:
-            return True
-    if re.search(r"\b(if|therefore|assume|let x|given that)\b", prompt):
-        return True
-    return False
-
-def is_lightweight(prompt: str) -> bool:
-    if len(prompt) < 100:
-        for kw in LIGHTWEIGHT_KEYWORDS:
-            if kw in prompt:
-                return True
-    return False
-
-async def check_chat_rate_limit(
-    request: Request,
-    authorization: Optional[str],
-    client_id: Optional[str] = None,
-):
-    return await enforce_rate_limit(request, authorization, "cloudChatDaily", client_id)

gen/media.py

@@ -1,408 +0,0 @@
-import os
-import base64
-import httpx
-from urllib.parse import quote
-from fastapi import Request, HTTPException, Header
-from fastapi.responses import Response, JSONResponse
-from typing import Optional
-from helper.assets import save_base64_image, cleanup_image, is_base64_image
-from helper.ratelimit import (
-    check_audio_rate_limit,
-    check_video_rate_limit,
-    check_image_rate_limit,
-    MAX_MEDIA_PROMPT_BYTES,
-    MAX_MEDIA_PROMPT_CHARS,
-    normalize_prompt_value,
-    enforce_prompt_size,
-)
-from . import (
-    router,
-    PKEY,
-    PKEY2,
-    WEBSOCKET_KEY,
-    AIRFORCE_KEY,
-    AIRFORCE_VIDEO_MODEL,
-    AIRFORCE_API_URL,
-    valid_ratios,
-    ratios,
-    valid_modes,
-    modes,
-)
-from .common import is_cinematic_image_prompt
-
-
-@router.post("/image")
-@router.get("/image/{prompt}")
-async def generate_image(
-    request: Request,
-    prompt: str = None,
-    authorization: str = Header(None),
-    x_client_id: str = Header(None),
-):
-    timeout = httpx.Timeout(300.0, read=300.0)
-
-    if prompt is None:
-        payload = await request.json()
-        prompt = payload.get("prompt")
-        mode = payload.get("mode")
-        image_urls = payload.get("image_urls")
-    else:
-        mode = request.query_params.get("mode")
-        image_urls = request.query_params.getlist("image_urls")
-
-    prompt = normalize_prompt_value(prompt, "prompt")
-    enforce_prompt_size(prompt, MAX_MEDIA_PROMPT_CHARS, MAX_MEDIA_PROMPT_BYTES, "Image prompt")
-    if request.headers.get("x-payg-internal") != WEBSOCKET_KEY:
-        await check_image_rate_limit(request, authorization, x_client_id)
-
-    chosen_model = "zimage"
-    if is_cinematic_image_prompt(prompt):
-        chosen_model = "flux"
-
-    if isinstance(mode, str):
-        m = mode.strip().lower()
-        if m == "fantasy":
-            chosen_model = "flux"
-        elif m == "realistic":
-            chosen_model = "zimage"
-
-    has_input_image = bool(image_urls)
-    temp_assets = []
-
-    if has_input_image:
-        chosen_model = "klein"
-
-    params = {"model": chosen_model, "key": PKEY2}
-
-    if has_input_image:
-        processed = []
-        for img in image_urls[:2]:
-            if is_base64_image(img):
-                image_id = save_base64_image(img)
-                temp_assets.append(image_id)
-                served = f"{request.base_url}asset-cdn/assets/{image_id}"
-                processed.append(served)
-            else:
-                processed.append(img)
-        params["image"] = "|".join(processed)
-
-    encoded_prompt = quote(prompt, safe="")
-    query = "&".join(f"{k}={quote(str(v), safe='')}" for k, v in params.items())
-    url = f"https://gen.pollinations.ai/image/{encoded_prompt}?{query}"
-
-    try:
-        async with httpx.AsyncClient(timeout=timeout) as client:
-            resp = await client.get(url)
-    finally:
-        for aid in temp_assets:
-            cleanup_image(aid)
-
-    if resp.status_code != 200:
-        raise HTTPException(500, f"Pollinations error: {resp.status_code}")
-
-    return Response(content=resp.content, media_type="image/jpeg")
-
-
-@router.get("/sfx/{prompt}")
-@router.post("/sfx")
-async def gensfx(
-    request: Request,
-    prompt: str = None,
-    authorization: str = Header(None),
-    x_client_id: str = Header(None),
-):
-    if prompt is None:
-        payload = await request.json()
-        prompt = payload.get("prompt")
-
-    prompt = normalize_prompt_value(prompt, "prompt")
-    enforce_prompt_size(prompt, MAX_MEDIA_PROMPT_CHARS, MAX_MEDIA_PROMPT_BYTES, "Audio prompt")
-    if request.headers.get("x-payg-internal") != WEBSOCKET_KEY:
-        await check_audio_rate_limit(request, authorization, x_client_id)
-
-    url = f"https://gen.pollinations.ai/audio/{prompt}?model=acestep&key={PKEY}"
-
-    async with httpx.AsyncClient(timeout=None) as client:
-        resp = await client.get(url)
-
-    if resp.status_code != 200:
-        return JSONResponse(
-            status_code=resp.status_code,
-            content={"success": False, "error": "Upstream music/sfx generation failed"},
-        )
-
-    return Response(resp.content, media_type="audio/mpeg")
-
-
-@router.get("/video/{prompt}")
-@router.post("/video")
-@router.head("/video")
-async def genvideo(request: Request, prompt: str = None, authorization: str = Header(None), x_client_id: str = Header(None)):
-    if request.method == "HEAD":
-        return Response(
-            status_code=200,
-            headers={
-                "Y-prompt": "string — required. The text prompt used to generate the video.",
-                "Y-ratio": "string — optional. Aspect ratio of the output video.",
-                "Y-ratio-values": "3:2,2:3,1:1",
-                "Y-ratio-default": "3:2",
-                "Y-mode": "string — optional. Controls generation style.",
-                "Y-mode-values": "normal,fun",
-                "Y-mode-default": "normal",
-                "Y-duration": "integer — optional. Duration in seconds (1–10).",
-                "Y-duration-default": "5",
-                "Y-image_urls": "array<string> — optional. Up to 2 image URLs for conditioning.",
-                "Y-image_urls-max": "2",
-                "Y-response_format": "video/mp4",
-                "Y-model": "grok-video",
-            },
-        )
-
-    aspectRatio = "3:2"
-    inputMode = "normal"
-    duration = 5
-    image_urls = None
-    ratio = None
-    mode = None
-
-    if prompt is None:
-        user_body = await request.json()
-        prompt = user_body.get("prompt")
-        ratio = user_body.get("ratio")
-        mode = user_body.get("mode")
-        image_urls = user_body.get("image_urls")
-        duration = user_body.get("duration", 5)
-
-        if ratio not in valid_ratios:
-            raise HTTPException(
-                status_code=400,
-                detail=f"Invalid aspect ratio '{ratio}'. Must be one of 3:2, 2:3, or 1:1.",
-            )
-        if ratio in ratios:
-            aspectRatio = ratio
-
-        if mode not in valid_modes:
-            raise HTTPException(
-                status_code=400,
-                detail=f"Invalid mode '{mode}'. Must be 'normal' or 'fun'.",
-            )
-        if mode in modes:
-            inputMode = mode
-
-        if image_urls:
-            if not isinstance(image_urls, list):
-                raise HTTPException(400, "image_urls must be a list")
-            if len(image_urls) > 2:
-                raise HTTPException(400, "You may provide at most two image URLs")
-
-        try:
-            duration = max(1, min(10, int(duration)))
-        except (TypeError, ValueError):
-            duration = 5
-
-    prompt = normalize_prompt_value(prompt, "prompt")
-    enforce_prompt_size(
-        prompt, MAX_MEDIA_PROMPT_CHARS, MAX_MEDIA_PROMPT_BYTES, "Video prompt"
-    )
-    if request.headers.get("x-payg-internal") != WEBSOCKET_KEY:
-        await check_video_rate_limit(request, authorization, x_client_id)
-
-    RATIO_MAP = {
-        "3:2": "16:9",
-        "2:3": "9:16",
-        "1:1": "9:16",
-    }
-    pollinations_ratio = RATIO_MAP.get(aspectRatio, "16:9")
-
-    encoded_prompt = quote(prompt, safe="")
-    params = {
-        "model": "ltx-2",
-        "duration": duration,
-        "aspectRatio": pollinations_ratio,
-        "seed": -1,
-    }
-
-    temp_assets = []
-
-    if image_urls:
-        processed_urls = []
-
-        for img in image_urls[:2]:
-            if is_base64_image(img):
-                image_id = save_base64_image(img)
-                temp_assets.append(image_id)
-
-                served_url = f"{request.base_url}asset-cdn/assets/{image_id}"
-                processed_urls.append(served_url)
-            else:
-                processed_urls.append(img)
-
-        params["image"] = "|".join(processed_urls)
-
-    if inputMode == "fun":
-        params["enhance"] = "true"
-
-    query_string = "&".join(f"{k}={quote(str(v), safe='')}" for k, v in params.items())
-    url = f"https://gen.pollinations.ai/video/{encoded_prompt}?{query_string}"
-
-    print(f"[VIDEO GEN] Pollinations URL: {url}")
-    url = url + f"&key={PKEY}"
-    resp = None
-    try:
-        async with httpx.AsyncClient(timeout=600) as client:
-            resp = await client.get(url)
-    finally:
-        for aid in temp_assets:
-            cleanup_image(aid)
-    if resp is None:
-        raise HTTPException(502, "Video generation request failed")
-    if resp.status_code != 200:
-        body_text = ""
-        try:
-            body_text = resp.text
-        except Exception:
-            pass
-        return JSONResponse(
-            status_code=resp.status_code,
-            content={
-                "success": False,
-                "error": "Upstream video generation failed",
-                "status_code": resp.status_code,
-                "message": body_text[:1000],
-            },
-        )
-
-    if not resp.content:
-        raise HTTPException(502, "Pollinations returned empty response")
-
-    return Response(
-        content=resp.content,
-        media_type="video/mp4",
-        headers={
-            "Content-Length": str(len(resp.content)),
-            "Accept-Ranges": "bytes",
-        },
-    )
-
-
-@router.get("/video/airforce/{prompt}")
-@router.post("/video/airforce")
-async def genvideo_airforce(
-    request: Request,
-    prompt: str = None,
-    authorization: str = Header(None),
-    x_client_id: str = Header(None),
-):
-    if request.method == "HEAD":
-        return Response(
-            status_code=200,
-            headers={
-                "Y-prompt": "string — required. The text prompt used to generate the video.",
-                "Y-ratio": "string — optional. Aspect ratio of the output video.",
-                "Y-ratio-values": "3:2,2:3,1:1",
-                "Y-ratio-default": "3:2",
-                "Y-mode": "string — optional. Controls generation style.",
-                "Y-mode-values": "normal,fun",
-                "Y-mode-default": "normal",
-                "Y-duration": "integer — optional. Duration in seconds.",
-                "Y-duration-default": "5",
-                "Y-image_urls": "array<string> — optional. Up to 2 image URLs for conditioning.",
-                "Y-image_urls-max": "2",
-                "Y-response_format": "video/mp4",
-                "Y-model": "grok-imagine-video",
-            },
-        )
-
-    aspectRatio = "3:2"
-    inputMode = "normal"
-    image_urls = None
-    ratio = None
-    mode = None
-
-    user_body = {}
-    if prompt is None:
-        user_body = await request.json()
-        prompt = user_body.get("prompt")
-        ratio = user_body.get("ratio")
-        mode = user_body.get("mode")
-        image_urls = user_body.get("image_urls")
-
-        if ratio not in valid_ratios:
-            raise HTTPException(
-                status_code=400,
-                detail=f"Invalid aspect ratio {ratio}. Must be one of 3:2, 2:3, or 1:1. Default is 3:2",
-            )
-        if ratio in ratios:
-            aspectRatio = ratio
-
-        if mode not in valid_modes:
-            raise HTTPException(
-                status_code=400,
-                detail=f"Invalid mode {mode}. Must be 'normal' or 'fun'. Default is normal",
-            )
-        if mode in modes:
-            inputMode = mode
-
-        if image_urls:
-            if not isinstance(image_urls, list):
-                raise HTTPException(400, "image_urls must be a list")
-
-            if len(image_urls) > 2:
-                raise HTTPException(400, "You may provide at most two image URLs")
-
-    prompt = normalize_prompt_value(prompt, "prompt")
-    enforce_prompt_size(
-        prompt, MAX_MEDIA_PROMPT_CHARS, MAX_MEDIA_PROMPT_BYTES, "Video prompt"
-    )
-    if request.headers.get("x-payg-internal") != WEBSOCKET_KEY:
-        await check_video_rate_limit(request, authorization, x_client_id)
-
-    payload = {
-        "model": AIRFORCE_VIDEO_MODEL,
-        "prompt": prompt,
-        "n": 1,
-        "size": "1024x1024",
-        "response_format": "b64_json",
-        "sse": False,
-        "mode": inputMode,
-        "aspectRatio": aspectRatio,
-    }
-
-    if image_urls:
-        payload["image_urls"] = image_urls
-
-    async with httpx.AsyncClient(timeout=600) as client:
-        resp = await client.post(
-            AIRFORCE_API_URL,
-            headers={
-                "Authorization": f"Bearer {AIRFORCE_KEY}",
-                "Content-Type": "application/json",
-            },
-            json=payload,
-        )
-
-    if resp.status_code != 200:
-        return JSONResponse(status_code=resp.status_code, content=resp.json())
-
-    if not resp.content:
-        raise HTTPException(502, "api.airforce returned empty response")
-
-    try:
-        result = resp.json()
-        b64_video = result["data"][0]["b64_json"]
-    except Exception:
-        raise HTTPException(502, f"Invalid api.airforce response: {resp.text[:500]}")
-
-    if not b64_video:
-        raise HTTPException(502, "Airforce returned empty b64_json")
-
-    video_bytes = base64.b64decode(b64_video)
-
-    return Response(
-        content=video_bytes,
-        media_type="video/mp4",
-        headers={
-            "Content-Length": str(len(video_bytes)),
-            "Accept-Ranges": "bytes",
-        },
-    )

gen/models.py

@@ -1,10 +0,0 @@
-from . import router
-from .override import build_all_models
-
-
-@router.get("/models")
-def return_models_openai():
-    return {
-      "object": "list",
-      "data": build_all_models(),
-    }

gen/override.py

@@ -1,133 +0,0 @@
-import json
-import os
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-CONFIG_PATH = Path(__file__).resolve().parent.parent / "models_override.json"
-LIGHTNING_CREATED = 1767225600
-
-_OVERRIDE_CACHE: Optional[Dict[str, Any]] = None
-_OVERRIDE_MTIME: Optional[float] = None
-
-
-def _load_overrides() -> Dict[str, Any]:
-    global _OVERRIDE_CACHE, _OVERRIDE_MTIME
-    mtime = None
-    try:
-        mtime = CONFIG_PATH.stat().st_mtime
-    except FileNotFoundError:
-        pass
-
-    if _OVERRIDE_CACHE is not None and _OVERRIDE_MTIME == mtime:
-        return _OVERRIDE_CACHE
-
-    data = {"lightning": {}, "overrides": []}
-    if mtime is not None:
-        try:
-            raw = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
-            if isinstance(raw, dict):
-                if not isinstance(raw.get("overrides"), list):
-                    raw["overrides"] = []
-                if not isinstance(raw.get("lightning"), dict):
-                    raw["lightning"] = {}
-                data = raw
-        except Exception:
-            pass
-
-    _OVERRIDE_CACHE = data
-    _OVERRIDE_MTIME = mtime
-    return data
-
-
-def get_override(model_id: str) -> Optional[Dict[str, Any]]:
-    data = _load_overrides()
-    for entry in data.get("overrides", []):
-        if isinstance(entry, dict) and entry.get("id") == model_id:
-            return entry
-    return None
-
-
-def is_allowed_in(model_id: str, context: str) -> bool:
-    entry = get_override(model_id)
-    if not entry:
-        return False
-    allowed = entry.get("allowed_in", [])
-    return context in allowed
-
-
-def resolve_override_routing(model_id: str) -> Optional[Dict[str, Any]]:
-    entry = get_override(model_id)
-    if not entry:
-        return None
-    api_url = entry.get("api_url")
-    api_key_env = entry.get("api_key_env")
-    api_key = os.getenv(api_key_env, "") if api_key_env else ""
-    if not api_url or not api_key:
-        return None
-    return {
-        "api_url": api_url,
-        "api_key": api_key,
-        "pricing_per_million_tokens": float(entry.get("pricing_per_million_tokens", 0)),
-    }
-
-
-def _ppm_to_per_token(ppm: float) -> str:
-    return f"{ppm / 1_000_000:.12f}"
-
-
-def _build_lightning_entry(config_data: Dict[str, Any]) -> Dict[str, Any]:
-    lightning = config_data.get("lightning", {})
-    ppm = float(lightning.get("pricing_per_million_tokens", 0.75))
-    pt = _ppm_to_per_token(ppm)
-    return {
-        "id": "lightning",
-        "name": lightning.get("name", "Lightning"),
-        "created": LIGHTNING_CREATED,
-        "context_length": lightning.get("context_length", 128000),
-        "max_output_length": lightning.get("max_output_length", 32000),
-        "input_modalities": lightning.get("input_modalities", ["text", "image", "file"]),
-        "output_modalities": lightning.get("output_modalities", ["text"]),
-        "pricing": {
-            "prompt": pt,
-            "completion": pt,
-            "image": "0",
-            "request": "0",
-            "input_cache_read": "0",
-        },
-        "supported_features": lightning.get("supported_features", ["tools", "json_mode", "streaming", "structured_outputs"]),
-    }
-
-
-def _build_override_entry(entry: Dict[str, Any]) -> Dict[str, Any]:
-    ppm = float(entry.get("pricing_per_million_tokens", 0))
-    pt = _ppm_to_per_token(ppm)
-    return {
-        "id": entry.get("id", ""),
-        "name": entry.get("name", entry.get("id", "")),
-        "created": entry.get("created", LIGHTNING_CREATED),
-        "context_length": entry.get("context_length", 128000),
-        "max_output_length": entry.get("max_output_length", 32000),
-        "input_modalities": entry.get("input_modalities", ["text"]),
-        "output_modalities": entry.get("output_modalities", ["text"]),
-        "pricing": {
-            "prompt": pt,
-            "completion": pt,
-            "image": "0",
-            "request": "0",
-            "input_cache_read": "0",
-        },
-        "supported_features": entry.get("supported_features", ["streaming"]),
-        "quantization": entry.get("quantization"),
-        "description": entry.get("description"),
-        "is_ready": True,
-        "is_free": ppm == 0,
-    }
-
-
-def build_all_models() -> List[Dict[str, Any]]:
-    data = _load_overrides()
-    models = [_build_lightning_entry(data)]
-    for entry in data.get("overrides", []):
-        if isinstance(entry, dict):
-            models.append(_build_override_entry(entry))
-    return models

gen/prompt.py

@@ -1,101 +0,0 @@
-from fastapi import Request, HTTPException
-from fastapi.responses import JSONResponse
-from helper.keywords import *
-from helper.ratelimit import (
-    extract_user_text,
-    calculate_messages_size,
-    MAX_GROQ_PROMPT_BYTES,
-    MAX_GROQ_PROMPT_CHARS,
-)
-from . import router
-from .chat import MODEL_MAP
-
-
-@router.post("/prompt_analyze")
-async def analyze_prompt(request: Request):
-    body = await request.json()
-    messages = body.get("prompt", [])
-    if not isinstance(messages, list) or len(messages) == 0:
-        raise HTTPException(400, "messages[] is required")
-
-    total_chars, total_bytes = calculate_messages_size(messages)
-    prompt_text = extract_user_text(messages)
-
-    uses_tools = (
-        "tools" in body and isinstance(body["tools"], list) and len(body["tools"]) > 0
-    ) or ("tool_choice" in body and body["tool_choice"] not in [None, "none"])
-
-    long_context = is_long_context(messages)
-    code_present = contains_code(prompt_text)
-    math_heavy = is_math_heavy(prompt_text)
-    structured_task = is_structured_task(prompt_text)
-    multi_q = multiple_questions(prompt_text)
-    code_heavy = is_code_heavy(prompt_text, code_present, long_context)
-
-    score = 0
-
-    if long_context:
-        score += 3
-
-    if math_heavy:
-        score += 3
-
-    if structured_task:
-        score += 2
-
-    if code_present:
-        score += 2
-
-    if multi_q:
-        score += 1
-
-    for kw in REASONING_KEYWORDS:
-        if kw in prompt_text:
-            score += 1
-
-    chosen_model = "llama-3.3-70b-versatile"
-    provider = "groq"
-    has_images = contains_images(messages)
-
-    if has_images:
-        chosen_model = "gpt-4.1"
-        provider = "navy vision"
-    else:
-        if score > 10:
-            score = 10
-        if uses_tools:
-            if score >= 6:
-                chosen_model = "nemotron-3-super"
-                provider = "navy"
-            elif score >= 4:
-                chosen_model = "gpt-oss-120b"
-                provider = "cerebras"
-            else:
-                chosen_model = "openai/gpt-oss-20b"
-                provider = "groq"
-
-        elif code_present:
-
-            if code_heavy and score >= 6:
-                chosen_model = "o3-mini"
-                provider = "navy"
-
-            elif score >= 4:
-                chosen_model = "zai-glm-4.7"
-                provider = "cerebras"
-
-        elif score >= 4:
-            chosen_model = "openai/gpt-oss-120b"
-            provider = "groq"
-
-        elif score >= 6:
-            chosen_model = "sonar"
-            provider = "navy"
-
-        if provider == "groq" and (
-            total_chars > MAX_GROQ_PROMPT_CHARS or total_bytes > MAX_GROQ_PROMPT_BYTES
-        ):
-            provider = "cerebras"
-            chosen_model = "gpt-oss-120b"
-
-    return {MODEL_MAP[chosen_model]}

helper/assets.py

@@ -1,80 +0,0 @@
-# app.py
-import base64
-import os
-import uuid
-from pathlib import Path
-from typing import Dict
-from PIL import Image
-from io import BytesIO
-
-from fastapi import FastAPI, HTTPException, APIRouter
-from fastapi.responses import FileResponse
-
-BASE_DIR = Path(__file__).parent
-ASSETS_DIR = BASE_DIR / "cdn-assets"
-ASSETS_DIR.mkdir(exist_ok=True)
-
-image_registry: Dict[str, Path] = {}
-asset_router = APIRouter(prefix="/asset-cdn", tags=["asset-cdn"])
-
-def save_base64_image(b64_data: str) -> str:
-    """
-    Decodes a base64 string, converts the image to PNG, stores it in /cdn-assets and returns the
-    unique image_id that can be used in the public URL.
-    """
-
-    if "," in b64_data:
-        _, b64_data = b64_data.split(",", 1)
-
-    try:
-        decoded = base64.b64decode(b64_data)
-    except (base64.binascii.Error, ValueError) as exc:
-        raise ValueError("Invalid base64 data") from exc
-
-    image = Image.open(BytesIO(decoded))
-
-    image_id = uuid.uuid4().hex
-    file_path = ASSETS_DIR / f"{image_id}.png"
-
-    image.save(file_path, "PNG")
-
-    image_registry[image_id] = file_path
-
-    return image_id
-
-
-@asset_router.get("/assets/{image_id}")
-def get_image(image_id: str):
-    """
-    FastAPI route that streams the requested image to the client.
-    If the image was cleaned up or never existed, a 404 is returned.
-    """
-    file_path = image_registry.get(image_id)
-    if not file_path or not file_path.exists():
-        raise HTTPException(status_code=404, detail="Image not found")
-
-    return FileResponse(path=file_path, media_type="image/png")
-
-def cleanup_image(image_id: str) -> bool:
-    """
-    Deletes the image file and removes it from the registry.
-    Returns True if the image existed and was removed, otherwise False.
-    """
-    file_path = image_registry.pop(image_id, None)
-    if file_path and file_path.exists():
-        try:
-            file_path.unlink()
-        except Exception:
-            image_registry[image_id] = file_path
-            return False
-        return True
-    return False
-
-def is_base64_image(value: str) -> bool:
-    if not isinstance(value, str):
-        return False
-    if value.startswith("http://") or value.startswith("https://"):
-        return False
-    if value.startswith("data:image"):
-        return True
-    return False

helper/keywords.py

@@ -1,274 +0,0 @@
-import re
-REASONING_KEYWORDS = [
-    # explicit reasoning requests
-    "prove", "demonstrate", "derive", "justify", "verify",
-    "show that", "walk through", "step by step", "reason through",
-    "chain of reasoning", "rigorous", "formal proof",
-
-    # analysis/comparison
-    "analyze", "analysis of", "compare and contrast",
-    "evaluate", "critically assess", "explain why",
-    "explain how", "what causes", "implications of",
-
-    # problem solving
-    "solve", "solution to", "how would you approach",
-    "strategy for", "optimize", "algorithm for",
-
-    # technical domains
-    "theorem", "lemma", "corollary",
-    "complexity analysis", "big o", "time complexity",
-    "mathematical", "statistical", "probabilistic",
-    "model the", "simulate",
-]
-
-CODE_KEYWORDS = [
-    "await", "async", "print(", "console.log(",
-    "code", "ts", "js", "py", ".repy", ".rb",
-    "gnu", "gcc", "clang", "clang++", "program",
-    "coding", "import", "include", "const", "var",
-    "let", "str", "string", "int", "float", "code",
-    "bot", "server", "html", "script", "database",
-    "db", "sql", "postgre", "app store", "tensorflow",
-    "pytorch", "python", "rust", "api",
-]
-
-CREATIVE_KEYWORDS = [
-    # cinematic cues
-    "cinematic", "film still", "movie scene",
-    "epic", "dramatic lighting", "moody lighting",
-    "volumetric lighting", "depth of field",
-    "anamorphic lens", "8k", "4k",
-
-    # art styles
-    "concept art", "digital painting",
-    "fantasy art", "sci-fi", "mythical",
-    "cyberpunk", "steampunk",
-    "baroque", "surreal", "abstract",
-    "oil painting", "watercolor",
-
-    # rendering engines
-    "octane render", "unreal engine",
-    "ray tracing", "global illumination",
-
-    # emotional narrative framing
-    "emotional portrait", "story scene",
-    "hero shot", "dramatic pose",
-]
-
-STRUCTURED_KEYWORDS = [
-    "return as json",
-    "output json",
-    "json schema",
-    "format as json",
-    "structured output",
-    "extract entities",
-    "extract fields",
-    "parse this",
-    "convert to table",
-    "create a table",
-    "categorize into",
-    "classify",
-    "label the following",
-    "taxonomy",
-    "generate schema",
-]
-
-MATH_PATTERNS = [
-    r"\b∫\b", r"\b∑\b", r"\b∂\b",
-    r"\bmatrix\b",
-    r"\blimit\b",
-    r"\bintegral\b",
-    r"\bderivative\b",
-    r"\bdifferential equation\b",
-    r"\blinear algebra\b",
-    r"\boptimi[sz]e\b",
-    r"\bgradient\b",
-    r"\bbackprop\b",
-    r"\bproof\b",
-    r"\btheorem\b",
-]
-
-LIGHTWEIGHT_KEYWORDS = [
-    "hello", "hi", "hey",
-    "thanks", "thank you",
-    "define", "definition of",
-    "what is", "who is",
-    "quick question",
-    "short answer",
-    "brief explanation",
-    "summarize",
-    "paraphrase",
-    "rewrite this",
-]
-
-
-def _message_content_to_text(content):
-    if isinstance(content, str):
-        return content
-
-    if isinstance(content, list):
-        parts = []
-        for item in content:
-            if isinstance(item, str):
-                parts.append(item)
-            elif isinstance(item, dict):
-                for key in (
-                    "text",
-                    "content",
-                    "arguments",
-                    "function_call",
-                    "function",
-                    "tool_calls",
-                    "prompt",
-                    "input",
-                    "output",
-                    "message",
-                    "description",
-                    "caption",
-                    "query",
-                    "summary",
-                ):
-                    nested = item.get(key)
-                    if nested is None:
-                        continue
-                    nested_text = _message_content_to_text(nested)
-                    if nested_text:
-                        parts.append(nested_text)
-        return " ".join(parts)
-
-    if isinstance(content, dict):
-        parts = []
-        for key in (
-            "text",
-            "content",
-            "arguments",
-            "function_call",
-            "function",
-            "tool_calls",
-            "prompt",
-            "input",
-            "output",
-            "message",
-            "description",
-            "caption",
-            "query",
-            "summary",
-        ):
-            nested = content.get(key)
-            if nested is None:
-                continue
-            nested_text = _message_content_to_text(nested)
-            if nested_text:
-                parts.append(nested_text)
-        return " ".join(parts)
-
-    return ""
-
-
-def _message_contains_images(content) -> bool:
-    if isinstance(content, list):
-        for item in content:
-            if isinstance(item, dict):
-                item_type = str(item.get("type") or "").lower()
-                if item_type in {"image", "image_url", "input_image", "image_urls"}:
-                    return True
-                if "image_url" in item:
-                    return True
-                if _message_contains_images(item.get("content")):
-                    return True
-        return False
-
-    if isinstance(content, dict):
-        item_type = str(content.get("type") or "").lower()
-        if item_type in {"image", "image_url", "input_image", "image_urls"}:
-            return True
-        if "image_url" in content:
-            return True
-        for key in ("content", "message", "input", "output", "prompt", "function_call", "function", "tool_calls"):
-            if _message_contains_images(content.get(key)):
-                return True
-
-    return False
-
-
-def is_long_context(messages: list) -> bool:
-    total_chars = 0
-    for message in messages:
-        if not isinstance(message, dict):
-            continue
-        total_chars += len(_message_content_to_text(message.get("content")))
-    return total_chars > 4000
-
-
-def contains_code(prompt: str) -> bool:
-    if "```" in prompt:
-        return True
-    for kw in CODE_KEYWORDS:
-        if kw in prompt:
-            return True
-    return False
-
-def is_code_heavy(prompt: str, code_present: bool, long_context: bool) -> bool:
-    """
-    Determines whether the coding task is substantial enough
-    to require a code-optimized or larger model.
-    """
-
-    if not code_present:
-        return False
-
-    heavy_patterns = [
-        r"\brefactor\b",
-        r"\boptimi[sz]e\b",
-        r"\bdebug\b",
-        r"\bfix this\b",
-        r"\barchitecture\b",
-        r"\bdesign pattern\b",
-        r"\bscalable\b",
-        r"\bmicroservice\b",
-        r"\bmultiple files\b",
-        r"\bentire project\b",
-        r"\bcodebase\b",
-        r"\bperformance\b",
-    ]
-
-    for pattern in heavy_patterns:
-        if re.search(pattern, prompt):
-            return True
-
-    if prompt.count("```") >= 2:
-        return True
-
-    if long_context:
-        return True
-
-    return False
-
-def is_math_heavy(prompt: str) -> bool:
-    for pattern in MATH_PATTERNS:
-        if re.search(pattern, prompt):
-            return True
-    return False
-
-def is_structured_task(prompt: str) -> bool:
-    for kw in STRUCTURED_KEYWORDS:
-        if kw in prompt:
-            return True
-    return False
-
-def multiple_questions(prompt: str) -> bool:
-    return prompt.count("?") >= 3
-
-def contains_images(messages):
-    for msg in messages:
-        if not isinstance(msg, dict):
-            continue
-
-        content = msg.get("content")
-        if _message_contains_images(content):
-            return True
-
-        if "image" in msg or "image_url" in msg:
-            return True
-
-    return False

helper/payg.py

@@ -1,670 +0,0 @@
-import asyncio
-import json
-import math
-import os
-import time
-from collections import defaultdict, deque
-from decimal import Decimal, ROUND_HALF_UP
-from pathlib import Path
-from typing import Any, Dict, Optional
-from psycopg.errors import UniqueViolation
-from fastapi import HTTPException
-
-from helper.subscriptions import execute_query, resolve_token_identity
-
-CONFIG_PATH = Path(__file__).resolve().parent.parent / "assets" / "payg_config.json"
-CONFIG_LOCK = asyncio.Lock()
-_CONFIG_CACHE: Optional[Dict[str, Any]] = None
-_CONFIG_MTIME: Optional[float] = None
-
-SPAM_TRACKER: Dict[str, deque] = defaultdict(deque)
-SPAM_LOCK = asyncio.Lock()
-
-CREDIT_SCALE = Decimal("0.0001")
-
-
-def _default_config() -> Dict[str, Any]:
-    return {
-        "dashboard": {
-            "appName": "InferencePort AI",
-            "homeUrl": "https://inference.js.org",
-            "apiBaseUrl": "https://sharktide-lightning.hf.space",
-            "supportEmail": "inferenceportai@gmail.com",
-            "hostname": "",
-        },
-        "supabase": {
-            "url": "",
-            "publishableKey": "",
-            "resetRedirectUrl": "https://inference.js.org/reset.html",
-            "deletePasswordVerifyEndpoint": "",
-            "deleteAccountEndpoint": "",
-        },
-        "billing": {
-            "currency": "USD",
-            "packs": [],
-        },
-        "pricing": {
-            "textCreditPerMillionTokens": 0.75,
-            "imageCreditPerImage": 0.02,
-            "videoCreditPerSecond": 0.01,
-            "audioCreditPerSecond": 0.01,
-            "audioDefaultSeconds": 10,
-            "textTokenEstimateMultiplier": 1.0,
-        },
-        "models": [],
-        "notices": [],
-        "limits": {
-            "requestsPerMinutePerIdentity": 120,
-            "minimumTextCreditsBalance": 10,
-        },
-    }
-
-
-def _deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
-    out = dict(base)
-    for key, value in override.items():
-        if isinstance(value, dict) and isinstance(out.get(key), dict):
-            out[key] = _deep_merge(out[key], value)
-        else:
-            out[key] = value
-    return out
-
-
-def _to_decimal(value: Any, default: str = "0") -> Decimal:
-    try:
-        return Decimal(str(value))
-    except Exception:
-        return Decimal(default)
-
-
-def quantize_credits(value: Decimal | float | int) -> Decimal:
-    if not isinstance(value, Decimal):
-        value = _to_decimal(value)
-    return value.quantize(CREDIT_SCALE, rounding=ROUND_HALF_UP)
-
-
-async def get_payg_config() -> Dict[str, Any]:
-    global _CONFIG_CACHE, _CONFIG_MTIME
-
-    async with CONFIG_LOCK:
-        mtime = None
-        try:
-            mtime = CONFIG_PATH.stat().st_mtime
-        except FileNotFoundError:
-            pass
-
-        if _CONFIG_CACHE is not None and _CONFIG_MTIME == mtime:
-            return _CONFIG_CACHE
-
-        config = _default_config()
-
-        if mtime is not None:
-            try:
-                file_data = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
-                if isinstance(file_data, dict):
-                    config = _deep_merge(config, file_data)
-            except Exception:
-                pass
-
-        packs = []
-        for raw_pack in config.get("billing", {}).get("packs", []):
-            if not isinstance(raw_pack, dict):
-                continue
-            credits = _to_decimal(raw_pack.get("credits"), "0")
-            amount = _to_decimal(raw_pack.get("amountUsd"), "0")
-            if credits <= 0 or amount <= 0:
-                continue
-            packs.append(
-                {
-                    "id": str(raw_pack.get("id") or "").strip(),
-                    "label": str(raw_pack.get("label") or "").strip() or f"${amount}",
-                    "amountUsd": float(amount),
-                    "credits": float(quantize_credits(credits)),
-                    "stripePaymentLink": str(raw_pack.get("stripePaymentLink") or "").strip(),
-                    "prod": str(raw_pack.get("prod") or "").strip(),
-                }
-            )
-        config["billing"]["packs"] = packs
-
-        _CONFIG_CACHE = config
-        _CONFIG_MTIME = mtime
-
-        return config
-
-
-async def require_payg_identity(authorization: Optional[str]) -> Dict[str, Any]:
-    if not authorization or not authorization.startswith("Bearer "):
-        raise HTTPException(status_code=401, detail="Missing or invalid Authorization header")
-
-    token = authorization.split(" ", 1)[1].strip()
-    identity = await resolve_token_identity(token)
-    if not identity:
-        raise HTTPException(status_code=401, detail="Invalid authorization token")
-
-    user_id = identity.get("user_id")
-    email = identity.get("email")
-    if not user_id or not email:
-        raise HTTPException(status_code=401, detail="Unable to resolve account identity")
-
-    return {
-        "token": token,
-        "user_id": str(user_id),
-        "email": str(email).strip().lower(),
-        "auth_type": identity.get("auth_type") or "unknown",
-    }
-
-
-async def enforce_payg_spam_limit(subject: str, per_minute_limit: int):
-    now = time.time()
-    cutoff = now - 60
-
-    async with SPAM_LOCK:
-        bucket = SPAM_TRACKER[subject]
-        while bucket and bucket[0] < cutoff:
-            bucket.popleft()
-
-        if len(bucket) >= per_minute_limit:
-            raise HTTPException(status_code=429, detail="Too many requests. Please slow down.")
-
-        bucket.append(now)
-
-
-async def ensure_user_wallet(user_id: str):
-    await execute_query(
-        """
-        insert into public.user_wallets (user_id, balance_credits, lifetime_credits_purchased)
-        values (%s, 0, 0)
-        on conflict (user_id) do nothing;
-        """,
-        (user_id,),
-        commit=True,
-    )
-
-
-async def get_wallet_snapshot(user_id: str) -> Dict[str, Any]:
-    await ensure_user_wallet(user_id)
-    row = await execute_query(
-        """
-        select
-            user_id,
-            balance_credits,
-            lifetime_credits_purchased,
-            stripe_customer_id,
-            updated_at
-        from public.user_wallets
-        where user_id = %s
-        limit 1;
-        """,
-        (user_id,),
-        fetchone=True,
-    )
-
-    if not row:
-        raise HTTPException(status_code=500, detail="Unable to load wallet")
-
-    return {
-        "user_id": str(row.get("user_id")),
-        "balance_credits": float(quantize_credits(_to_decimal(row.get("balance_credits"), "0"))),
-        "lifetime_credits_purchased": float(
-            quantize_credits(_to_decimal(row.get("lifetime_credits_purchased"), "0"))
-        ),
-        "stripe_customer_id": row.get("stripe_customer_id"),
-        "updated_at": row.get("updated_at").isoformat() if hasattr(row.get("updated_at"), "isoformat") else None,
-    }
-
-
-async def list_credit_ledger(user_id: str, limit: int = 100) -> list[Dict[str, Any]]:
-    safe_limit = max(1, min(limit, 500))
-    rows = await execute_query(
-        """
-        select
-            id,
-            delta_credits,
-            balance_after,
-            entry_type,
-            usage_kind,
-            units,
-            unit_label,
-            source,
-            source_ref,
-            metadata,
-            created_at
-        from public.credit_ledger
-        where user_id = %s
-        order by created_at desc
-        limit %s;
-        """,
-        (user_id, safe_limit),
-    )
-
-    result = []
-    for row in rows or []:
-        result.append(
-            {
-                "id": row.get("id"),
-                "delta_credits": float(quantize_credits(_to_decimal(row.get("delta_credits"), "0"))),
-                "balance_after": float(quantize_credits(_to_decimal(row.get("balance_after"), "0"))),
-                "entry_type": row.get("entry_type"),
-                "usage_kind": row.get("usage_kind"),
-                "units": float(row.get("units")) if row.get("units") is not None else None,
-                "unit_label": row.get("unit_label"),
-                "source": row.get("source"),
-                "source_ref": row.get("source_ref"),
-                "metadata": row.get("metadata") if isinstance(row.get("metadata"), dict) else None,
-                "created_at": row.get("created_at").isoformat() if hasattr(row.get("created_at"), "isoformat") else None,
-            }
-        )
-
-    return result
-
-async def append_credit_ledger_entry(
-    *,
-    user_id: str,
-    delta_credits: Decimal,
-    entry_type: str,
-    usage_kind: Optional[str] = None,
-    units: Optional[float] = None,
-    unit_label: Optional[str] = None,
-    source: Optional[str] = None,
-    source_ref: Optional[str] = None,
-    idempotency_key: Optional[str] = None,
-    metadata: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
-    await ensure_user_wallet(user_id)
-
-    delta_credits = quantize_credits(delta_credits)
-    metadata_json = json.dumps(metadata or {})
-
-    row = None
-
-    try:
-        row = await execute_query(
-            """
-            with updated_wallet as (
-                update public.user_wallets
-                set
-                    balance_credits = balance_credits + %s,
-                    lifetime_credits_purchased = case
-                        when %s > 0 then lifetime_credits_purchased + %s
-                        else lifetime_credits_purchased
-                    end,
-                    updated_at = timezone('utc', now())
-                where user_id = %s
-                  and (balance_credits + %s) >= 0
-                returning balance_credits
-            ),
-            inserted as (
-                insert into public.credit_ledger (
-                    user_id,
-                    delta_credits,
-                    balance_after,
-                    entry_type,
-                    usage_kind,
-                    units,
-                    unit_label,
-                    source,
-                    source_ref,
-                    idempotency_key,
-                    metadata
-                )
-                select
-                    %s,
-                    %s,
-                    updated_wallet.balance_credits,
-                    %s,
-                    %s,
-                    %s,
-                    %s,
-                    %s,
-                    %s,
-                    %s,
-                    %s::jsonb
-                from updated_wallet
-                returning id, balance_after, created_at
-            )
-            select id, balance_after, created_at
-            from inserted
-            limit 1;
-            """,
-            (
-                delta_credits,
-                delta_credits,
-                delta_credits,
-                user_id,
-                delta_credits,
-                user_id,
-                delta_credits,
-                entry_type,
-                usage_kind,
-                units,
-                unit_label,
-                source,
-                source_ref,
-                idempotency_key,
-                metadata_json,
-            ),
-            fetchone=True,
-            commit=True,
-        )
-
-    except UniqueViolation:
-        row = None
-
-    if row:
-        return {
-            "ledger_id": row.get("id"),
-            "balance_after": float(
-                quantize_credits(
-                    _to_decimal(row.get("balance_after"), "0")
-                )
-            ),
-            "created_at": (
-                row.get("created_at").isoformat()
-                if hasattr(row.get("created_at"), "isoformat")
-                else None
-            ),
-        }
-
-    if idempotency_key:
-        existing = await execute_query(
-            """
-            select id, balance_after, created_at
-            from public.credit_ledger
-            where user_id = %s
-              and idempotency_key = %s
-            limit 1;
-            """,
-            (user_id, idempotency_key),
-            fetchone=True,
-        )
-
-        if existing:
-            return {
-                "ledger_id": existing.get("id"),
-                "balance_after": float(
-                    quantize_credits(
-                        _to_decimal(existing.get("balance_after"), "0")
-                    )
-                ),
-                "created_at": (
-                    existing.get("created_at").isoformat()
-                    if hasattr(existing.get("created_at"), "isoformat")
-                    else None
-                ),
-                "idempotent_replay": True,
-            }
-
-    raise HTTPException(
-        status_code=402,
-        detail="Insufficient credits",
-    )
-
-def _estimate_tokens_from_text(text: str) -> int:
-    if not isinstance(text, str):
-        return 0
-
-    stripped = text.strip()
-    if not stripped:
-        return 0
-
-    # Rough multilingual token estimate without relying on model-specific tokenizers.
-    return max(1, int(math.ceil(len(stripped) / 3.5)))
-
-
-def _collect_chat_text_and_image_counts(value: Any) -> tuple[int, int]:
-    if value is None:
-        return 0, 0
-
-    if isinstance(value, str):
-        return len(value), 0
-
-    if isinstance(value, list):
-        chars = 0
-        image_count = 0
-        for item in value:
-            item_chars, item_images = _collect_chat_text_and_image_counts(item)
-            chars += item_chars
-            image_count += item_images
-        return chars, image_count
-
-    if isinstance(value, dict):
-        chars = 0
-        image_count = 0
-        item_type = str(value.get("type") or "").lower()
-        if item_type in {"image", "image_url", "input_image"}:
-            image_count += 1
-
-        text_value = value.get("text")
-        if isinstance(text_value, str):
-            chars += len(text_value)
-
-        if isinstance(value.get("content"), (str, list, dict)):
-            nested_chars, nested_images = _collect_chat_text_and_image_counts(value.get("content"))
-            chars += nested_chars
-            image_count += nested_images
-
-        if isinstance(value.get("arguments"), str):
-            chars += len(value["arguments"])
-
-        if isinstance(value.get("function_call"), (str, list, dict)):
-            nested_chars, nested_images = _collect_chat_text_and_image_counts(value.get("function_call"))
-            chars += nested_chars
-            image_count += nested_images
-
-        if isinstance(value.get("function"), (str, list, dict)):
-            nested_chars, nested_images = _collect_chat_text_and_image_counts(value.get("function"))
-            chars += nested_chars
-            image_count += nested_images
-
-        if isinstance(value.get("tool_calls"), list):
-            nested_chars, nested_images = _collect_chat_text_and_image_counts(value.get("tool_calls"))
-            chars += nested_chars
-            image_count += nested_images
-
-        if isinstance(value.get("image_url"), dict):
-            image_count += 1
-
-        for key, nested in value.items():
-            if key in {
-                "content",
-                "text",
-                "arguments",
-                "function",
-                "function_call",
-                "tool_calls",
-                "image_url",
-                "role",
-                "type",
-                "index",
-                "id",
-            }:
-                continue
-
-            if isinstance(nested, (list, dict)):
-                nested_chars, nested_images = _collect_chat_text_and_image_counts(nested)
-                chars += nested_chars
-                image_count += nested_images
-            elif isinstance(nested, str) and key.lower() in {
-                "prompt",
-                "input",
-                "output",
-                "message",
-                "description",
-                "caption",
-                "query",
-                "summary",
-            }:
-                chars += len(nested)
-
-        return chars, image_count
-
-    return 0, 0
-
-
-def estimate_text_tokens_from_messages(messages: Any) -> int:
-    if not isinstance(messages, list):
-        return 0
-
-    chars = 0
-    image_count = 0
-
-    for message in messages:
-        message_chars, message_images = _collect_chat_text_and_image_counts(message)
-        chars += message_chars
-        image_count += message_images
-
-    estimated = int(math.ceil(chars / 3.5))
-    estimated += image_count * 300
-    return max(0, estimated)
-
-
-def estimate_text_tokens_from_text(text: Any) -> int:
-    if not isinstance(text, str):
-        return 0
-    return _estimate_tokens_from_text(text)
-
-
-def extract_usage_tokens(payload: Dict[str, Any], fallback_tokens: int) -> int:
-    usage = payload.get("usage") if isinstance(payload, dict) else None
-    if isinstance(usage, dict):
-        total = usage.get("total_tokens")
-        try:
-            if total is not None:
-                total_int = int(total)
-                if total_int >= 0:
-                    return total_int
-        except Exception:
-            pass
-
-        prompt_tokens = usage.get("prompt_tokens")
-        completion_tokens = usage.get("completion_tokens")
-        try:
-            if prompt_tokens is not None and completion_tokens is not None:
-                prompt_int = int(prompt_tokens)
-                completion_int = int(completion_tokens)
-                if prompt_int >= 0 and completion_int >= 0:
-                    return max(0, prompt_int + completion_int)
-        except Exception:
-            pass
-    return max(0, fallback_tokens)
-
-
-def extract_usage_breakdown(
-    payload: Dict[str, Any],
-    fallback_input_tokens: int,
-    fallback_output_tokens: int = 0,
-) -> Dict[str, int]:
-    usage = payload.get("usage") if isinstance(payload, dict) else None
-    input_tokens = max(0, int(fallback_input_tokens))
-    output_tokens = max(0, int(fallback_output_tokens))
-    total_tokens = input_tokens + output_tokens
-
-    if isinstance(usage, dict):
-        try:
-            prompt_tokens = usage.get("prompt_tokens")
-            if prompt_tokens is not None:
-                prompt_int = int(prompt_tokens)
-                if prompt_int >= 0:
-                    input_tokens = prompt_int
-        except Exception:
-            pass
-
-        try:
-            completion_tokens = usage.get("completion_tokens")
-            if completion_tokens is not None:
-                completion_int = int(completion_tokens)
-                if completion_int >= 0:
-                    output_tokens = completion_int
-        except Exception:
-            pass
-
-        try:
-            total = usage.get("total_tokens")
-            if total is not None:
-                total_int = int(total)
-                if total_int >= 0:
-                    total_tokens = total_int
-                else:
-                    total_tokens = input_tokens + output_tokens
-            else:
-                total_tokens = input_tokens + output_tokens
-        except Exception:
-            total_tokens = input_tokens + output_tokens
-
-        if output_tokens <= 0 and total_tokens >= input_tokens:
-            output_tokens = max(0, total_tokens - input_tokens)
-
-    if total_tokens < input_tokens + output_tokens:
-        total_tokens = input_tokens + output_tokens
-
-    return {
-        "input_tokens": max(0, input_tokens),
-        "output_tokens": max(0, output_tokens),
-        "total_tokens": max(0, total_tokens),
-    }
-
-
-def calculate_text_credit_cost(total_tokens: int, config: Dict[str, Any]) -> Decimal:
-    pricing = config.get("pricing", {})
-    per_million = _to_decimal(pricing.get("textCreditPerMillionTokens"), "0.75")
-    multiplier = _to_decimal(pricing.get("textTokenEstimateMultiplier"), "1")
-    tokens = _to_decimal(total_tokens, "0")
-    cost = (tokens / Decimal("1000000")) * per_million * multiplier
-    return quantize_credits(cost)
-
-
-def calculate_image_credit_cost(image_count: int, config: Dict[str, Any]) -> Decimal:
-    per_image = _to_decimal(config.get("pricing", {}).get("imageCreditPerImage"), "0.02")
-    cost = _to_decimal(max(1, image_count)) * per_image
-    return quantize_credits(cost)
-
-
-def calculate_video_credit_cost(seconds: int, config: Dict[str, Any]) -> Decimal:
-    per_second = _to_decimal(config.get("pricing", {}).get("videoCreditPerSecond"), "0.01")
-    cost = _to_decimal(max(1, seconds)) * per_second
-    return quantize_credits(cost)
-
-
-def calculate_audio_credit_cost(seconds: int, config: Dict[str, Any]) -> Decimal:
-    per_second = _to_decimal(config.get("pricing", {}).get("audioCreditPerSecond"), "0.01")
-    cost = _to_decimal(max(1, seconds)) * per_second
-    return quantize_credits(cost)
-
-
-def get_pack_by_session_amount(config: Dict[str, Any], amount_total_cents: int) -> Optional[Dict[str, Any]]:
-    if amount_total_cents <= 0:
-        return None
-    amount_usd = Decimal(amount_total_cents) / Decimal("100")
-
-    for pack in config.get("billing", {}).get("packs", []):
-        candidate = _to_decimal(pack.get("amountUsd"), "0")
-        if candidate == amount_usd:
-            return pack
-
-    return None
-
-
-def build_usage_summary_from_ledger_rows(rows: list[Dict[str, Any]]) -> Dict[str, Any]:
-    summary = {
-        "text": {"credits": 0.0, "units": 0.0, "unit_label": "tokens"},
-        "image": {"credits": 0.0, "units": 0.0, "unit_label": "images"},
-        "video": {"credits": 0.0, "units": 0.0, "unit_label": "seconds"},
-        "audio": {"credits": 0.0, "units": 0.0, "unit_label": "seconds"},
-        "totalCreditsUsed": 0.0,
-    }
-
-    for row in rows:
-        if row.get("entry_type") != "usage":
-            continue
-
-        kind = str(row.get("usage_kind") or "other").lower()
-        credits = abs(float(row.get("delta_credits") or 0.0))
-        units = float(row.get("units") or 0.0)
-
-        if kind in summary:
-            summary[kind]["credits"] += credits
-            summary[kind]["units"] += units
-
-        summary["totalCreditsUsed"] += credits
-
-    return summary

helper/ratelimit.py

@@ -1,522 +0,0 @@
-import asyncio
-import hashlib
-import os
-import re
-import time
-from typing import Any, Dict, List, Optional
-
-from fastapi import HTTPException, Request
-
-from helper.subscriptions import (
-    TIER_CONFIG,
-    USAGE_PERIODS,
-    fetch_subscription,
-    get_effective_limit_for_email,
-    normalize_plan_key,
-    usage_locks,
-    usage_store,
-)
-
-
-# -------------------------------------------------------------------
-# Configuration / Constants
-# -------------------------------------------------------------------
-
-IDENTITY_CACHE_TTL_SECONDS = 60
-
-CLIENT_BIND_TTL_SECONDS = int(
-    os.getenv("CLIENT_BIND_TTL_SECONDS", str(8 * 24 * 60 * 60))
-)
-
-MAX_CLIENT_ID_LENGTH = 128
-
-MAX_CHAT_PROMPT_CHARS = int(os.getenv("MAX_CHAT_PROMPT_CHARS", "120000"))
-MAX_CHAT_PROMPT_BYTES = int(os.getenv("MAX_CHAT_PROMPT_BYTES", "500000"))
-
-MAX_GROQ_PROMPT_CHARS = int(os.getenv("MAX_GROQ_PROMPT_CHARS", "90000"))
-MAX_GROQ_PROMPT_BYTES = int(os.getenv("MAX_GROQ_PROMPT_BYTES", "350000"))
-
-MAX_MEDIA_PROMPT_CHARS = int(os.getenv("MAX_MEDIA_PROMPT_CHARS", "4000"))
-MAX_MEDIA_PROMPT_BYTES = int(os.getenv("MAX_MEDIA_PROMPT_BYTES", "16000"))
-
-
-# -------------------------------------------------------------------
-# In-memory state
-# -------------------------------------------------------------------
-
-identity_cache: Dict[str, Dict[str, Any]] = {}
-
-client_subject_bindings: Dict[str, Dict[str, Any]] = {}
-
-
-# -------------------------------------------------------------------
-# Public Rate Limit APIs
-# -------------------------------------------------------------------
-
-async def resolve_rate_limit_identity(
-    request: Request,
-    authorization: Optional[str],
-    client_id: Optional[str] = None,
-) -> tuple[str, str]:
-    now = time.time()
-
-    normalized_client_id = sanitize_client_id(client_id)
-    default_subject = build_default_subject(request, normalized_client_id)
-
-    if not authorization or not authorization.startswith("Bearer "):
-        return "free", resolve_bound_subject(normalized_client_id, default_subject)
-
-    token = authorization.split(" ", 1)[1].strip()
-    if not token:
-        return "free", resolve_bound_subject(normalized_client_id, default_subject)
-
-    cached = identity_cache.get(token)
-    if cached and cached.get("expires_at", 0) > now:
-        plan_key = cached.get("plan_key", "free")
-        subject = cached.get("subject", default_subject)
-
-        bind_client_subject(normalized_client_id, subject, plan_key)
-        return plan_key, subject
-
-    try:
-        sub = await fetch_subscription(token)
-    except HTTPException as authfailure:
-        raise authfailure
-    except Exception:
-        return "free", resolve_bound_subject(normalized_client_id, default_subject)
-
-    if not isinstance(sub, dict) or sub.get("error"):
-        return "free", resolve_bound_subject(normalized_client_id, default_subject)
-
-    email = sub.get("email")
-    if isinstance(email, str) and email.strip():
-        subject = f"user:{email.strip().lower()}"
-    else:
-        subject = default_subject
-
-    plan_key = normalize_plan_key(sub.get("plan_key"))
-
-    identity_cache[token] = {
-        "plan_key": plan_key,
-        "subject": subject,
-        "expires_at": now + IDENTITY_CACHE_TTL_SECONDS,
-    }
-
-    bind_client_subject(normalized_client_id, subject, plan_key)
-
-    return plan_key, subject
-
-
-async def enforce_rate_limit(
-    request: Request,
-    authorization: Optional[str],
-    metric: str,
-    client_id: Optional[str] = None,
-) -> Dict[str, Optional[int | str]]:
-    if metric not in usage_store:
-        raise HTTPException(status_code=500, detail=f"Unknown limit metric: {metric}")
-
-    plan_key, subject = await resolve_rate_limit_identity(
-        request, authorization, client_id
-    )
-    return await consume_metric_for_subject(metric, plan_key, subject)
-
-
-async def resolve_verify_token_rate_limit_identity(
-    authorization: Optional[str],
-    ip: Optional[str],
-) -> tuple[str, str]:
-    if authorization and authorization.startswith("Bearer "):
-        token = authorization.split(" ", 1)[1].strip()
-        if token:
-            try:
-                sub = await fetch_subscription(token)
-            except HTTPException:
-                sub = None
-            except Exception:
-                sub = None
-
-            if isinstance(sub, dict) and not sub.get("error"):
-                email = sub.get("email")
-                if isinstance(email, str) and email.strip():
-                    return (
-                        normalize_plan_key(sub.get("plan_key")),
-                        f"user:{email.strip().lower()}",
-                    )
-
-    return "free", build_verify_token_ip_subject(ip)
-
-
-async def consume_metric_for_subject(
-    metric: str,
-    plan_key: str,
-    subject: str,
-) -> Dict[str, Optional[int | str]]:
-    if metric not in usage_store:
-        raise HTTPException(status_code=500, detail=f"Unknown limit metric: {metric}")
-
-    plan = TIER_CONFIG.get(plan_key) or TIER_CONFIG["free"]
-    subject_email = subject[5:] if subject.startswith("user:") else None
-    limit = get_effective_limit_for_email(plan_key, metric, subject_email)
-    window_key = get_usage_period_key(metric)
-    lock = get_usage_lock(metric, subject)
-
-    async with lock:
-        bucket = usage_store[metric]
-        entry = bucket.get(subject)
-
-        if not entry or entry.get("window") != window_key:
-            entry = {"window": window_key, "count": 0}
-            bucket[subject] = entry
-
-        if limit is not None and entry["count"] >= int(limit):
-            raise HTTPException(
-                status_code=429,
-                detail=f"{metric} limit reached for {plan.get('name', 'current plan')}",
-            )
-
-        entry["count"] += 1
-        remaining = None if limit is None else max(0, int(limit) - entry["count"])
-
-        return {
-            "plan_key": plan_key,
-            "limit": limit,
-            "remaining": remaining,
-            "used": entry["count"],
-            "window": window_key,
-            "period": USAGE_PERIODS.get(metric, "daily"),
-        }
-
-
-async def check_audio_rate_limit(
-    request: Request,
-    authorization: Optional[str],
-    client_id: Optional[str] = None,
-):
-    await enforce_rate_limit(request, authorization, "audioWeekly", client_id)
-
-
-async def check_image_rate_limit(
-    request: Request,
-    authorization: Optional[str],
-    client_id: Optional[str] = None,
-):
-    await enforce_rate_limit(request, authorization, "imagesDaily", client_id)
-
-
-async def check_video_rate_limit(
-    request: Request,
-    authorization: Optional[str],
-    client_id: Optional[str] = None,
-):
-    await enforce_rate_limit(request, authorization, "videosDaily", client_id)
-
-
-# -------------------------------------------------------------------
-# Prompt Utilities
-# -------------------------------------------------------------------
-
-def normalize_prompt_value(prompt: Optional[str], field_name: str = "prompt") -> str:
-    if not isinstance(prompt, str):
-        raise HTTPException(status_code=400, detail=f"{field_name} is required")
-
-    normalized = prompt.strip()
-
-    if not normalized:
-        raise HTTPException(status_code=400, detail=f"{field_name} is required")
-
-    return normalized
-
-
-def enforce_prompt_size(prompt: str, max_chars: int, max_bytes: int, context: str):
-    char_len = len(prompt)
-    byte_len = len(prompt.encode("utf-8"))
-
-    if char_len > max_chars or byte_len > max_bytes:
-        raise HTTPException(
-            status_code=413,
-            detail=(
-                f"{context} is too large ({char_len} chars, {byte_len} bytes). "
-                f"Max allowed is {max_chars} chars or {max_bytes} bytes."
-            ),
-        )
-
-
-def calculate_messages_size(messages: list) -> tuple[int, int]:
-    total_chars = 0
-    total_bytes = 0
-
-    for message in messages:
-        if not isinstance(message, dict):
-            continue
-
-        text = message_content_to_text(message.get("content"))
-
-        if not text:
-            continue
-
-        total_chars += len(text)
-        total_bytes += len(text.encode("utf-8"))
-
-    return total_chars, total_bytes
-
-
-def extract_user_text(messages: list) -> str:
-    return " ".join(
-        message_content_to_text(m.get("content"))
-        for m in messages
-        if isinstance(m, dict) and m.get("role") == "user"
-    ).lower()
-
-
-# -------------------------------------------------------------------
-# Usage / Rate Limit Internals
-# -------------------------------------------------------------------
-
-def get_usage_period_key(metric: str) -> str:
-    now = time.gmtime()
-
-    period = USAGE_PERIODS.get(metric, "daily")
-
-    if period == "weekly":
-        iso_year, iso_week, _ = time.strftime("%G %V %u", now).split(" ")
-        return f"{iso_year}-W{iso_week}"
-
-    return time.strftime("%Y-%m-%d", now)
-
-
-def get_usage_lock(metric: str, subject: str) -> asyncio.Lock:
-    metric_locks = usage_locks.get(metric)
-
-    if metric_locks is None:
-        metric_locks = {}
-        usage_locks[metric] = metric_locks
-
-    lock = metric_locks.get(subject)
-
-    if lock is None:
-        lock = asyncio.Lock()
-        metric_locks[subject] = lock
-
-    return lock
-
-
-def get_usage_snapshot_for_subject(
-    plan_key: str, subject: str
-) -> Dict[str, Dict[str, Any]]:
-    snapshot: Dict[str, Dict[str, Any]] = {}
-
-    for metric in usage_store.keys():
-        snapshot[metric] = get_metric_snapshot_for_subject(plan_key, subject, metric)
-
-    return snapshot
-
-
-def get_metric_snapshot_for_subject(
-    plan_key: str,
-    subject: str,
-    metric: str,
-) -> Dict[str, Any]:
-    subject_email = subject[5:] if subject.startswith("user:") else None
-    limit = get_effective_limit_for_email(plan_key, metric, subject_email)
-    window_key = get_usage_period_key(metric)
-    entry = usage_store[metric].get(subject)
-    used = 0
-
-    if entry and entry.get("window") == window_key:
-        used = max(0, int(entry.get("count", 0)))
-
-    remaining = None if limit is None else max(0, int(limit) - used)
-
-    return {
-        "limit": limit,
-        "used": used,
-        "remaining": remaining,
-        "window": window_key,
-        "period": USAGE_PERIODS.get(metric, "daily"),
-    }
-
-
-# -------------------------------------------------------------------
-# Identity / Client helpers
-# -------------------------------------------------------------------
-
-def sanitize_client_id(raw_client_id: Optional[str]) -> Optional[str]:
-    if not isinstance(raw_client_id, str):
-        return None
-
-    trimmed = raw_client_id.strip()
-
-    if not trimmed or len(trimmed) > MAX_CLIENT_ID_LENGTH:
-        return None
-
-    if not re.match(r"^[A-Za-z0-9._:-]+$", trimmed):
-        return None
-
-    return trimmed
-
-
-def build_default_subject(request: Request, client_id: Optional[str]) -> str:
-    if client_id:
-        client_hash = hashlib.sha256(client_id.encode("utf-8")).hexdigest()[:24]
-        return f"client:{client_hash}"
-
-    host = request.client.host if request.client else "unknown"
-
-    user_agent = request.headers.get("user-agent", "")
-
-    ua_hash = (
-        hashlib.sha256(user_agent.encode("utf-8")).hexdigest()[:12]
-        if user_agent
-        else "noua"
-    )
-
-    return f"anon:{host}:{ua_hash}"
-
-
-def normalize_forwarded_ip(raw_ip: Optional[str]) -> Optional[str]:
-    if not isinstance(raw_ip, str):
-        return None
-
-    candidate = raw_ip.split(",", 1)[0].strip()
-
-    if not candidate:
-        return None
-
-    if candidate.startswith("[") and "]" in candidate:
-        candidate = candidate[1 : candidate.index("]")]
-    elif candidate.count(":") == 1 and "." in candidate:
-        candidate = candidate.rsplit(":", 1)[0]
-
-    return candidate or None
-
-
-def build_verify_token_ip_subject(ip: Optional[str]) -> str:
-    normalized_ip = normalize_forwarded_ip(ip)
-    if not normalized_ip:
-        return "verify-ip:unknown"
-
-    ip_hash = hashlib.sha256(normalized_ip.encode("utf-8")).hexdigest()[:24]
-    return f"verify-ip:{ip_hash}"
-
-
-def bind_client_subject(client_id: Optional[str], subject: str, plan_key: str):
-    if not client_id:
-        return
-
-    client_subject_bindings[client_id] = {
-        "subject": subject,
-        "plan_key": plan_key,
-        "expires_at": time.time() + CLIENT_BIND_TTL_SECONDS,
-    }
-
-
-def resolve_bound_subject(client_id: Optional[str], fallback_subject: str) -> str:
-    if not client_id:
-        return fallback_subject
-
-    bound = client_subject_bindings.get(client_id)
-
-    if not bound:
-        return fallback_subject
-
-    if bound.get("expires_at", 0) <= time.time():
-        client_subject_bindings.pop(client_id, None)
-        return fallback_subject
-
-    return bound.get("subject", fallback_subject)
-
-
-# -------------------------------------------------------------------
-# Message parsing helpers
-# -------------------------------------------------------------------
-
-def message_content_to_text(content: Any) -> str:
-    if isinstance(content, str):
-        return content
-
-    if isinstance(content, list):
-        parts: List[str] = []
-
-        for item in content:
-            if isinstance(item, str):
-                parts.append(item)
-                continue
-
-            if isinstance(item, dict):
-                text = item.get("text")
-                if isinstance(text, str):
-                    parts.append(text)
-
-                nested_content = item.get("content")
-                if nested_content is not None:
-                    nested_text = message_content_to_text(nested_content)
-                    if nested_text:
-                        parts.append(nested_text)
-
-                arguments = item.get("arguments")
-                if isinstance(arguments, str):
-                    parts.append(arguments)
-
-                for key in (
-                    "function_call",
-                    "function",
-                    "tool_calls",
-                    "prompt",
-                    "input",
-                    "output",
-                    "message",
-                    "description",
-                    "caption",
-                    "query",
-                    "summary",
-                ):
-                    nested_value = item.get(key)
-                    if nested_value is None:
-                        continue
-                    nested_text = message_content_to_text(nested_value)
-                    if nested_text:
-                        parts.append(nested_text)
-
-        return " ".join(parts)
-
-    if isinstance(content, dict):
-        parts: List[str] = []
-
-        text = content.get("text")
-        if isinstance(text, str):
-            parts.append(text)
-
-        nested_content = content.get("content")
-        if nested_content is not None:
-            nested_text = message_content_to_text(nested_content)
-            if nested_text:
-                parts.append(nested_text)
-
-        arguments = content.get("arguments")
-        if isinstance(arguments, str):
-            parts.append(arguments)
-
-        for key in (
-            "function_call",
-            "function",
-            "tool_calls",
-            "prompt",
-            "input",
-            "output",
-            "message",
-            "description",
-            "caption",
-            "query",
-            "summary",
-        ):
-            nested_value = content.get(key)
-            if nested_value is None:
-                continue
-            nested_text = message_content_to_text(nested_value)
-            if nested_text:
-                parts.append(nested_text)
-
-        return " ".join(parts)
-
-    return ""

helper/subscriptions.py

@@ -1,436 +0,0 @@
-import asyncio
-import hashlib
-import json
-import os
-from datetime import datetime, timezone
-from pathlib import Path
-import base64
-import psycopg
-from psycopg.rows import dict_row
-from supabase import Client, create_client
-import hmac
-ADMINS_PATH = Path("assets/admins.json")
-EXTRA_USAGE_PATH = Path("assets/extra_usage.json")
-
-try:
-    ADMIN_EMAIL_MAP = json.loads(ADMINS_PATH.read_text())
-except Exception as e:
-    print(f"Failed to load admins.json: {e}")
-    ADMIN_EMAIL_MAP = {}
-
-try:
-    EXTRA_USAGE_EMAIL_MAP = json.loads(EXTRA_USAGE_PATH.read_text())
-except Exception as e:
-    print(f"Failed to load extra_usage.json: {e}")
-    EXTRA_USAGE_EMAIL_MAP = {}
-
-PLAN_ORDER = ["free", "light", "core", "creator", "professional"]
-TIER_CONFIG = {
-    "free": {
-        "name": "Free Tier",
-        "url": "",
-        "price": "0.00",
-        "limits": {
-            "cloudChatDaily": 50,
-            "imagesDaily": 10,
-            "videosDaily": 3,
-            "audioWeekly": 1,
-            "verifyTokenWithEmailDaily": 100,
-        },
-    },
-    "light": {
-        "name": "InferencePort AI Light",
-        "url": "https://buy.stripe.com/bJedR93gk4xw7EFeyabbG08",
-        "price": "9.99",
-        "limits": {
-            "cloudChatDaily": None,
-            "imagesDaily": 50,
-            "videosDaily": 10,
-            "audioWeekly": 5,
-            "verifyTokenWithEmailDaily": 100,
-        },
-    },
-    "core": {
-        "name": "InferencePort AI Core",
-        "url": "https://buy.stripe.com/28E4gzg365BA1gh61EbbG09",
-        "price": "15.99",
-        "limits": {
-            "cloudChatDaily": None,
-            "imagesDaily": 150,
-            "videosDaily": 30,
-            "audioWeekly": 25,
-            "verifyTokenWithEmailDaily": 100,
-        },
-    },
-    "creator": {
-        "name": "InferencePort AI Creator",
-        "url": "https://buy.stripe.com/dRmdR98AE5BA8IJ89MbbG0a",
-        "price": "29.99",
-        "limits": {
-            "cloudChatDaily": None,
-            "imagesDaily": 300,
-            "videosDaily": 50,
-            "audioWeekly": 45,
-            "verifyTokenWithEmailDaily": 100,
-        },
-    },
-    "professional": {
-        "name": "InferencePort AI Professional",
-        "url": "https://buy.stripe.com/14AaEX7wA3ts7EF2PsbbG0b",
-        "price": "99.99",
-        "limits": {
-            "cloudChatDaily": None,
-            "imagesDaily": None,
-            "videosDaily": None,
-            "audioWeekly": 75,
-            "verifyTokenWithEmailDaily": 100,
-        },
-    },
-}
-USAGE_PERIODS = {
-    "cloudChatDaily": "daily",
-    "imagesDaily": "daily",
-    "videosDaily": "daily",
-    "audioWeekly": "weekly",
-    "verifyTokenWithEmailDaily": "daily",
-}
-usage_store = {
-    "cloudChatDaily": {},
-    "imagesDaily": {},
-    "videosDaily": {},
-    "audioWeekly": {},
-    "verifyTokenWithEmailDaily": {},
-}
-usage_locks = {
-    "cloudChatDaily": {},
-    "imagesDaily": {},
-    "videosDaily": {},
-    "audioWeekly": {},
-    "verifyTokenWithEmailDaily": {},
-}
-
-conn = None
-conn_lock = asyncio.Lock()
-
-SUPABASE_URL = os.getenv("SUPABASE_URL")
-SUPABASE_KEY = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
-supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
-POSTGRE_SECRET = os.getenv("POSTGRE_SECRET")
-
-async def get_conn():
-    global conn
-
-    if conn is None or conn.closed:
-       conn = await psycopg.AsyncConnection.connect(POSTGRE_SECRET, row_factory=dict_row, sslmode="verify-full", sslrootcert="prod-ca-2021.crt")
-
-    return conn
-
-import psycopg
-from psycopg.rows import dict_row
-
-async def execute_query(query: str, params=(), *, fetchone=False, commit=False):
-    async with conn_lock:
-        conn = await get_conn()
-
-        try:
-            async with conn.cursor() as cur:
-                await cur.execute(query, params)
-
-                if cur.description is None:
-                    result = None if fetchone else []
-                else:
-                    result = await cur.fetchone() if fetchone else await cur.fetchall()
-
-            if commit:
-                await conn.commit()
-
-            return result
-
-        except psycopg.OperationalError:
-            # reconnect using ASYNC connection
-            conn = await psycopg.AsyncConnection.connect(
-                POSTGRE_SECRET,
-                row_factory=dict_row,
-                sslmode="verify-full",
-                sslrootcert="prod-ca-2021.crt",
-            )
-            globals()["conn"] = conn
-
-            async with conn.cursor() as cur:
-                await cur.execute(query, params)
-
-                if cur.description is None:
-                    result = None if fetchone else []
-                else:
-                    result = await cur.fetchone() if fetchone else await cur.fetchall()
-
-            if commit:
-                await conn.commit()
-
-            return result
-
-        except psycopg.Error as e:
-            await conn.rollback()
-            raise e
-
-def normalize_plan_key(plan_name: str | None) -> str:
-    if not plan_name:
-        return "free"
-    normalized = "".join(ch for ch in str(plan_name).lower() if ch.isalpha())
-    if "professional" in normalized:
-        return "professional"
-    if "creator" in normalized:
-        return "creator"
-    if "core" in normalized:
-        return "core"
-    if "light" in normalized:
-        return "light"
-    return "free"
-
-
-def get_effective_limit_for_email(
-    plan_key: str,
-    metric: str,
-    email: str | None = None,
-):
-    plan = TIER_CONFIG.get(plan_key) or TIER_CONFIG["free"]
-    default_limit = plan.get("limits", {}).get(metric)
-
-    if not isinstance(email, str) or not email.strip():
-        return default_limit
-
-    entry = EXTRA_USAGE_EMAIL_MAP.get(email.strip().lower())
-    if not isinstance(entry, dict):
-        return default_limit
-
-    raw_limits = entry.get("limits") if isinstance(entry.get("limits"), dict) else entry
-    override = raw_limits.get(metric) if isinstance(raw_limits, dict) else None
-
-    if override is None and metric not in raw_limits:
-        return default_limit
-
-    if override is None:
-        return None
-
-    if isinstance(override, (int, float)) and override >= 0:
-        return int(override)
-
-    return default_limit
-
-
-async def fetch_subscription(jwt: str):
-    identity = await resolve_token_identity(jwt)
-    if "error" in identity:
-        return identity
-
-    email = identity["email"]
-    signed_up = identity["signed_up"]
-
-    if email in ADMIN_EMAIL_MAP:
-        admin = ADMIN_EMAIL_MAP[email]
-        print(f"[ADMIN OVERRIDE] {email} → forcing plan '{admin['plan_key']}'")
-
-        subscription_obj = {
-            "subscription_id": admin.get("subscription_id", "admin-override"),
-            "status": admin.get("status", "active"),
-            "current_period_end": None,
-            "price_id": None,
-            "product_name": admin.get("product_name"),
-            "nickname": admin.get("nickname"),
-            "plan_key": admin.get("plan_key"),
-        }
-
-        return {
-            "email": email,
-            "signed_up": signed_up,
-            "subscription": [subscription_obj],
-            "plan_key": admin["plan_key"],
-            "auth_type": identity["auth_type"],
-        }
-
-    rows = await execute_query(
-        """
-            with cust as (
-                select id
-                from stripe.customers
-                where email = %s
-            ),
-            subs as (
-                select
-                    s.id as subscription_id,
-                    s.status,
-                    s.current_period_end,
-                    s.items->'data'->0->'price'->>'id' as price_id
-                from stripe.subscriptions s
-                join cust on s.customer = cust.id
-                where s.status in ('active', 'trialing', 'past_due')
-            )
-            select
-                subs.subscription_id,
-                subs.status,
-                subs.current_period_end,
-                subs.price_id,
-                prices.nickname,
-                prices.product as product_id,
-                products.name as product_name
-            from subs
-            left join stripe.prices prices
-              on prices.id = subs.price_id
-            left join stripe.products products
-              on prices.product = products.id;
-        """,
-        (email,),
-    )
-
-    if not rows:
-        return {
-            "email": email,
-            "signed_up": signed_up,
-            "subscription": None,
-            "plan_key": "free",
-            "auth_type": identity["auth_type"],
-        }
-
-    subscriptions = []
-    preferred_plan_key = "free"
-
-    for row in rows:
-        plan_key = normalize_plan_key(row["product_name"] or row["nickname"])
-
-        subscriptions.append({
-            "subscription_id": row["subscription_id"],
-            "status": row["status"],
-            "current_period_end": row["current_period_end"],
-            "price_id": row["price_id"],
-            "product_name": row["product_name"],
-            "nickname": row["nickname"],
-            "plan_key": plan_key,
-        })
-
-        if row["status"] in ("active", "trialing"):
-            preferred_plan_key = plan_key
-
-    return {
-        "email": email,
-        "signed_up": signed_up,
-        "subscription": subscriptions,
-        "plan_key": preferred_plan_key,
-        "auth_type": identity["auth_type"],
-    }
-
-
-from fastapi import HTTPException
-
-async def resolve_token_identity(token: str | None):
-    if not token or (token == "public"):
-        return None
-
-    jwt_identity = resolve_jwt_identity(token)
-    if jwt_identity is not None:
-        return jwt_identity
-
-    api_identity = await resolve_api_key_identity(token)
-    if api_identity is not None:
-        if "error" in api_identity:
-            raise HTTPException(status_code=401, detail=api_identity["error"])
-        return api_identity
-
-    raise HTTPException(status_code=401, detail="Invalid API key or token")
-
-
-
-def resolve_jwt_identity(token: str):
-    try:
-        auth_res = supabase.auth.get_user(token)
-    except Exception:
-        return None
-
-    user = getattr(auth_res, "user", None)
-    email = getattr(user, "email", None)
-    created_at = getattr(user, "created_at", None)
-    user_id = getattr(user, "id", None)
-    if user is None or not isinstance(email, str) or not email.strip():
-        return None
-    return {
-        "auth_type": "jwt",
-        "user_id": user_id,
-        "email": email.strip().lower(),
-        "signed_up": created_at.isoformat() if hasattr(created_at, "isoformat") else None,
-    }
-
-def verify_lightning_api_key(secret: str, stored: str) -> bool:
-    _, salt_b64, key_b64 = stored.split("$")
-
-    salt = base64.urlsafe_b64decode(salt_b64 + "==")
-    stored_key = base64.urlsafe_b64decode(key_b64 + "==")
-
-    derived_key = hashlib.scrypt(
-        secret.encode("utf-8"),
-        salt=salt,
-        n=16384, r=8, p=1,
-        dklen=32
-    )
-
-    return hmac.compare_digest(derived_key, stored_key)
-
-async def resolve_api_key_identity(token: str | None):
-    if token is None or token.strip() == "":
-        return None
-
-    prefix = token[:16]
-
-    row = await execute_query(
-        """
-        select
-            k.id,
-            k.user_id,
-            k.name,
-            k.expires_at,
-            k.revoked_at,
-            k.key_hash,
-            u.email,
-            u.created_at as user_created_at
-        from public.lightning_api_keys k
-        join auth.users u on u.id = k.user_id
-        where k.key_prefix = %s
-        limit 1;
-        """,
-        (prefix,),
-        fetchone=True,
-    )
-
-    if not row:
-        raise HTTPException(status_code=401, detail="Invalid API key or token")
-
-    if not verify_lightning_api_key(token, row["key_hash"]):
-        raise HTTPException(status_code=401, detail="Invalid API key or token")
-
-    if row.get("revoked_at") is not None:
-        raise HTTPException(status_code=401, detail="Invalid API key or token")
-
-    expires_at = row.get("expires_at")
-    if expires_at is not None and expires_at <= datetime.now(timezone.utc):
-        raise HTTPException(status_code=401, detail="Invalid API key or token")
-
-    email = row.get("email")
-    if not isinstance(email, str) or not email.strip():
-        raise HTTPException(status_code=401, detail="Invalid API key or token")
-
-    await execute_query(
-        """
-        update public.lightning_api_keys
-        set last_used_at = timezone('utc', now())
-        where id = %s;
-        """,
-        (row["id"],),
-        commit=True,
-    )
-
-    return {
-        "auth_type": "api_key",
-        "user_id": str(row["user_id"]) if row["user_id"] is not None else None,
-        "email": email.strip().lower(),
-        "signed_up": row["user_created_at"].isoformat()
-            if hasattr(row["user_created_at"], "isoformat")
-            else None,
-    }

models_override.json

@@ -1,39 +0,0 @@
-{
-  "lightning": {
-    "name": "Lightning",
-    "context_length": 128000,
-    "max_output_length": 32000,
-    "pricing_per_million_tokens": 0.75,
-    "input_modalities": ["text", "image", "file"],
-    "output_modalities": ["text"],
-    "supported_features": ["tools", "json_mode", "streaming", "structured_outputs"]
-  },
-  "overrides": [
-    {
-      "id": "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning",
-      "name": "NVIDIA: Nemotron 3 Nano Omni 30B A3B Reasoning",
-      "api_url": "https://api.aimlapi.com/v1/chat/completions",
-      "api_key_env": "AIML_KEY",
-      "allowed_in": ["gen", "payg"],
-      "context_length": 128000,
-      "max_output_length": 32000,
-      "input_modalities": ["text"],
-      "output_modalities": ["text"],
-      "supported_features": ["tools", "json_mode", "streaming"],
-      "pricing_per_million_tokens": 0.04
-    },
-    {
-      "id": "baidu/ernie-4-5-0-3b",
-      "name": "Baidu: ERNIE 4.5 0 3B",
-      "api_url": "https://api.aimlapi.com/v1/chat/completions",
-      "api_key_env": "AIML_KEY",
-      "allowed_in": ["gen", "payg"],
-      "context_length": 128000,
-      "max_output_length": 32000,
-      "input_modalities": ["text"],
-      "output_modalities": ["text"],
-      "supported_features": ["tools", "json_mode", "streaming"],
-      "pricing_per_million_tokens": 0.04
-    }
-  ]
-}

payg/__init__.py

@@ -1,5 +0,0 @@
-from fastapi import APIRouter
-
-router = APIRouter(prefix="/v1")
-
-from . import stripe, account, chat, media

payg/account.py

@@ -1,208 +0,0 @@
-import time
-import uuid
-from typing import Any, Dict, Optional
-from fastapi import Header, HTTPException, Query, Request
-from fastapi.responses import JSONResponse
-from helper.payg import (
-    get_payg_config,
-    get_wallet_snapshot,
-    list_credit_ledger,
-    build_usage_summary_from_ledger_rows,
-    require_payg_identity,
-)
-from helper.subscriptions import execute_query
-from . import router
-from .common import (
-    build_public_config,
-    normalize_lightning_api_key_row,
-    build_lightning_api_key_secret,
-    build_lightning_api_key_prefix,
-    hash_lightning_api_key,
-    parse_lightning_api_key_expiry,
-    trimmed_string,
-)
-
-
-@router.get("/config")
-async def v1_get_public_config():
-    config = await get_payg_config()
-    return JSONResponse(status_code=200, content=build_public_config(config))
-
-
-@router.get("/models")
-async def v1_get_models():
-    config = await get_payg_config()
-    from gen.override import build_all_models
-    return JSONResponse(status_code=200, content={
-        "object": "list",
-        "data": build_all_models(),
-    })
-
-
-@router.get("/me")
-async def v1_get_me(authorization: Optional[str] = Header(None)):
-    identity = await require_payg_identity(authorization)
-    wallet = await get_wallet_snapshot(identity["user_id"])
-    ledger = await list_credit_ledger(identity["user_id"], limit=200)
-    usage_summary = build_usage_summary_from_ledger_rows(ledger)
-
-    return JSONResponse(
-        status_code=200,
-        content={
-            "identity": {
-                "email": identity["email"],
-                "auth_type": identity["auth_type"],
-                "user_id": identity["user_id"],
-            },
-            "wallet": wallet,
-            "usage_summary": usage_summary,
-            "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-        },
-    )
-
-
-@router.get("/credits/ledger")
-async def v1_get_credit_ledger(
-    authorization: Optional[str] = Header(None),
-    limit: int = Query(default=50, ge=1, le=500),
-):
-    identity = await require_payg_identity(authorization)
-    ledger = await list_credit_ledger(identity["user_id"], limit=limit)
-    return {"entries": ledger}
-
-
-@router.get("/lightning-api-keys")
-async def v1_list_lightning_api_keys(authorization: Optional[str] = Header(None)):
-    identity = await require_payg_identity(authorization)
-    rows = await execute_query(
-        """
-        select
-            id,
-            name,
-            key_prefix,
-            created_at,
-            last_used_at,
-            expires_at,
-            revoked_at
-        from public.lightning_api_keys
-        where user_id = %s
-        order by created_at desc;
-        """,
-        (identity["user_id"],),
-    )
-
-    items = []
-    for row in rows or []:
-        normalized = normalize_lightning_api_key_row(row or {})
-        if normalized:
-            items.append(normalized)
-
-    return JSONResponse(status_code=200, content={"items": items})
-
-
-@router.post("/lightning-api-keys")
-async def v1_create_lightning_api_key(
-    request: Request,
-    authorization: Optional[str] = Header(None),
-):
-    identity = await require_payg_identity(authorization)
-
-    try:
-        body = await request.json()
-    except Exception:
-        raise HTTPException(status_code=400, detail="Invalid JSON body")
-
-    if not isinstance(body, dict):
-        raise HTTPException(status_code=400, detail="Invalid JSON body")
-
-    name = trimmed_string(body.get("name"))
-    if not name:
-        raise HTTPException(status_code=400, detail="API key name is required")
-    if len(name) > 64:
-        raise HTTPException(status_code=400, detail="API key name must be 64 characters or fewer")
-
-    expires_at = parse_lightning_api_key_expiry(body.get("expiresAt"))
-    raw_key = build_lightning_api_key_secret()
-    key_hash = hash_lightning_api_key(raw_key)
-    key_prefix = build_lightning_api_key_prefix(raw_key)
-
-    key_id = str(uuid.uuid4())
-
-    row = await execute_query(
-        """
-        insert into public.lightning_api_keys (
-            id,
-            user_id,
-            name,
-            key_hash,
-            key_prefix,
-            expires_at
-        )
-        values (%s, %s, %s, %s, %s, %s)
-        returning
-            id,
-            name,
-            key_prefix,
-            created_at,
-            last_used_at,
-            expires_at,
-            revoked_at;
-        """,
-        (
-            key_id,
-            identity["user_id"],
-            name,
-            key_hash,
-            key_prefix,
-            expires_at,
-        ),
-        fetchone=True,
-        commit=True,
-    )
-
-    normalized = normalize_lightning_api_key_row(row or {})
-    if not normalized:
-        raise HTTPException(status_code=500, detail="Created API key response was invalid")
-
-    return JSONResponse(status_code=200, content={"apiKey": normalized, "rawKey": raw_key})
-
-
-@router.delete("/lightning-api-keys/{key_id}")
-async def v1_revoke_lightning_api_key(
-    key_id: str,
-    authorization: Optional[str] = Header(None),
-):
-    identity = await require_payg_identity(authorization)
-    key_id = trimmed_string(key_id)
-    if not key_id:
-        raise HTTPException(status_code=400, detail="API key id is required")
-
-    row = await execute_query(
-        """
-        update public.lightning_api_keys
-        set revoked_at = timezone('utc', now())
-        where id = %s
-          and user_id = %s
-          and revoked_at is null
-        returning
-            id,
-            name,
-            key_prefix,
-            created_at,
-            last_used_at,
-            expires_at,
-            revoked_at;
-        """,
-        (key_id, identity["user_id"]),
-        fetchone=True,
-        commit=True,
-    )
-
-    if not row:
-        raise HTTPException(status_code=404, detail="API key not found or already revoked")
-
-    normalized = normalize_lightning_api_key_row(row or {})
-    if not normalized:
-        raise HTTPException(status_code=500, detail="Updated API key response was invalid")
-
-    return JSONResponse(status_code=200, content={"success": True, "apiKey": normalized})

payg/chat.py

@@ -1,292 +0,0 @@
-import json
-import uuid
-from decimal import Decimal, ROUND_HALF_UP
-from typing import Any, Dict, Optional
-import httpx
-from fastapi import Header, HTTPException, Request
-from fastapi.responses import JSONResponse, StreamingResponse
-from helper.payg import (
-    append_credit_ledger_entry,
-    calculate_text_credit_cost,
-    enforce_payg_spam_limit,
-    estimate_text_tokens_from_messages,
-    estimate_text_tokens_from_text,
-    extract_usage_breakdown,
-    get_payg_config,
-    get_wallet_snapshot,
-    require_payg_identity,
-)
-from gen.override import get_override, is_allowed_in
-from . import router
-from .common import (
-    INTERNAL_API_BASE,
-    count_input_images,
-    build_upstream_headers,
-    get_minimum_text_balance,
-    extract_stream_usage_and_text,
-    extract_completion_text_from_payload,
-    stringify_uuids,
-)
-
-
-def _get_override_pricing(model_id: str) -> Decimal:
-    entry = get_override(model_id)
-    if entry:
-        ppm = entry.get("pricing_per_million_tokens", 0)
-        try:
-            return Decimal(str(ppm))
-        except Exception:
-            pass
-    return Decimal("0")
-
-
-def quantize_override_cost(tokens: int, ppm: Decimal) -> Decimal:
-    cost = (Decimal(str(tokens)) / Decimal("1000000")) * ppm
-    return cost.quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
-
-
-@router.post("/chat/completions")
-async def v1_chat_completions(
-    request: Request,
-    authorization: Optional[str] = Header(None),
-    x_client_id: Optional[str] = Header(None),
-):
-    identity = await require_payg_identity(authorization)
-    config = await get_payg_config()
-
-    limit = int(config.get("limits", {}).get("requestsPerMinutePerIdentity", 120))
-    await enforce_payg_spam_limit(f"{identity['user_id']}:text", max(1, limit))
-
-    wallet = await get_wallet_snapshot(identity["user_id"])
-    minimum_balance = get_minimum_text_balance(config)
-    current_balance = Decimal(str(wallet.get("balance_credits") or 0))
-    if current_balance < minimum_balance:
-        raise HTTPException(
-            status_code=402,
-            detail=f"At least ${minimum_balance} in credits is required for text generation.",
-        )
-
-    body = await request.json()
-    if not isinstance(body, dict):
-        raise HTTPException(status_code=400, detail="Invalid JSON body")
-
-    requested_model = body.get("model")
-    override_entry = get_override(requested_model) if requested_model else None
-    is_override = override_entry is not None and is_allowed_in(requested_model, "payg")
-    override_ppm = _get_override_pricing(requested_model) if is_override else Decimal("0")
-
-    estimated_input_tokens = estimate_text_tokens_from_messages(body.get("messages"))
-    image_count = count_input_images(body.get("messages"))
-    estimated_input_tokens += 15000 * image_count
-
-    estimated_output_tokens = 0
-    max_tokens_value = body.get("max_completion_tokens")
-    if max_tokens_value is None:
-        max_tokens_value = body.get("max_tokens")
-    try:
-        if max_tokens_value is not None:
-            estimated_output_tokens = max(0, int(max_tokens_value))
-    except Exception:
-        estimated_output_tokens = 0
-
-    estimated_total_tokens = estimated_input_tokens + estimated_output_tokens
-
-    if is_override:
-        estimated_total_cost = quantize_override_cost(estimated_total_tokens, override_ppm)
-    else:
-        estimated_total_cost = calculate_text_credit_cost(estimated_total_tokens, config)
-        if estimated_output_tokens <= 0:
-            estimated_total_cost = calculate_text_credit_cost(estimated_input_tokens, config)
-
-    if current_balance < max(minimum_balance, estimated_total_cost):
-        raise HTTPException(
-            status_code=402,
-            detail=(
-                "Insufficient credits for this text request. "
-                f"Current balance is {current_balance:.2f} credits."
-            ),
-        )
-
-    stream = bool(body.get("stream"))
-    if stream:
-        body["stream"] = True
-        stream_options = body.get("stream_options")
-        if not isinstance(stream_options, dict):
-            stream_options = {}
-        stream_options["include_usage"] = True
-        body["stream_options"] = stream_options
-
-    async def settle_text_usage(
-        *,
-        input_tokens: int,
-        output_tokens: int,
-        source: str,
-        payload: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> Dict[str, Any]:
-        input_tokens = max(0, int(input_tokens))
-        output_tokens = max(0, int(output_tokens))
-        total_tokens = input_tokens + output_tokens
-
-        if is_override:
-            final_cost = quantize_override_cost(total_tokens, override_ppm)
-        else:
-            final_cost = calculate_text_credit_cost(total_tokens, config)
-
-        usage_key = f"text:{uuid.uuid4().hex}"
-        entry_metadata = {
-            "input_tokens": input_tokens,
-            "output_tokens": output_tokens,
-            "total_tokens": total_tokens,
-            "stream": stream,
-            "is_override": is_override,
-            "override_model": requested_model if is_override else None,
-        }
-        if isinstance(metadata, dict):
-            entry_metadata.update(metadata)
-
-        ledger_entry = await append_credit_ledger_entry(
-            user_id=identity["user_id"],
-            delta_credits=-final_cost,
-            entry_type="usage",
-            usage_kind="text",
-            units=float(total_tokens),
-            unit_label="tokens",
-            source=source,
-            source_ref=usage_key,
-            idempotency_key=usage_key,
-            metadata=entry_metadata,
-        )
-        ledger_entry = stringify_uuids(ledger_entry)
-
-        if isinstance(payload, dict):
-            payload.setdefault("usage", {})
-            payload["usage"]["payg_input_tokens"] = input_tokens
-            payload["usage"]["payg_output_tokens"] = output_tokens
-            payload["usage"]["payg_total_tokens"] = total_tokens
-            payload["usage"]["payg_credits_charged"] = float(final_cost)
-            payload["usage"]["payg_ledger_entry"] = stringify_uuids(ledger_entry)
-        return payload or {
-            "usage": {
-                "payg_input_tokens": input_tokens,
-                "payg_output_tokens": output_tokens,
-                "payg_total_tokens": total_tokens,
-                "payg_credits_charged": float(final_cost),
-                "payg_ledger_entry": ledger_entry,
-            }
-        }
-
-    try:
-        if stream:
-            async def event_generator():
-                completion_text = []
-                seen_usage: Optional[Dict[str, Any]] = None
-
-                try:
-                    async with httpx.AsyncClient(timeout=None) as client:
-                        async with client.stream(
-                            "POST",
-                            f"{INTERNAL_API_BASE}/gen/chat/completions",
-                            json=body,
-                            headers=build_upstream_headers(authorization, x_client_id),
-                        ) as upstream:
-                            if upstream.status_code >= 400:
-                                error_text = await upstream.aread()
-                                error_body = error_text.decode("utf-8", errors="replace")
-                                yield (
-                                    f'data: {json.dumps({"error": "Upstream request failed", "detail": error_body[:1000]})}\n\n'
-                                )
-                                return
-
-                            async for line in upstream.aiter_lines():
-                                if not line:
-                                    yield "\n"
-                                    continue
-
-                                collected_text, usage, is_done = extract_stream_usage_and_text(line)
-                                if collected_text:
-                                    completion_text.append(collected_text)
-                                if usage:
-                                    seen_usage = usage
-
-                                yield line + "\n"
-
-                                if is_done:
-                                    break
-
-                    usage_payload = {"usage": seen_usage} if isinstance(seen_usage, dict) else {}
-                    breakdown = extract_usage_breakdown(
-                        usage_payload,
-                        estimated_input_tokens,
-                        estimate_text_tokens_from_text("".join(completion_text)),
-                    )
-                    final_payload = await settle_text_usage(
-                        input_tokens=breakdown["input_tokens"],
-                        output_tokens=breakdown["output_tokens"],
-                        source="v1_chat_stream",
-                        metadata={
-                            "usage_source": "stream",
-                            "estimated_input_tokens": estimated_input_tokens,
-                            "estimated_output_tokens": estimated_output_tokens,
-                        },
-                    )
-                    yield f"event: payg-usage\ndata: {json.dumps(final_payload.get('usage', {}))}\n\n"
-                except Exception as exc:
-                    yield f'data: {json.dumps({"error": "Text generation failed", "detail": str(exc)[:500]})}\n\n'
-
-            return StreamingResponse(
-                event_generator(),
-                media_type="text/event-stream",
-                headers={
-                    "Cache-Control": "no-cache",
-                    "Connection": "keep-alive",
-                    "X-Accel-Buffering": "no",
-                },
-            )
-
-        async with httpx.AsyncClient(timeout=120) as client:
-            upstream = await client.post(
-                f"{INTERNAL_API_BASE}/gen/chat/completions",
-                json=body,
-                headers=build_upstream_headers(authorization, x_client_id),
-            )
-
-        if upstream.status_code >= 400:
-            content_type = (upstream.headers.get("content-type") or "").lower()
-            if "application/json" in content_type:
-                return JSONResponse(status_code=upstream.status_code, content=upstream.json())
-            return JSONResponse(
-                status_code=upstream.status_code,
-                content={"error": "Upstream request failed", "detail": upstream.text[:1000]},
-            )
-
-        payload = upstream.json()
-        breakdown = extract_usage_breakdown(
-            payload,
-            estimated_input_tokens,
-            estimate_text_tokens_from_text(extract_completion_text_from_payload(payload)),
-        )
-
-        if breakdown["output_tokens"] <= 0:
-            breakdown["output_tokens"] = estimate_text_tokens_from_text(
-                extract_completion_text_from_payload(payload)
-            )
-            breakdown["total_tokens"] = breakdown["input_tokens"] + breakdown["output_tokens"]
-
-        final_payload = await settle_text_usage(
-            input_tokens=breakdown["input_tokens"],
-            output_tokens=breakdown["output_tokens"],
-            source="v1_chat",
-            payload=payload,
-            metadata={
-                "usage_source": "non_stream",
-                "estimated_input_tokens": estimated_input_tokens,
-                "estimated_output_tokens": estimated_output_tokens,
-            },
-        )
-        return JSONResponse(status_code=upstream.status_code, content=final_payload)
-
-    except HTTPException:
-        raise
-    except Exception as exc:
-        raise HTTPException(status_code=502, detail=f"Text generation failed: {str(exc)[:300]}")

payg/common.py

@@ -1,316 +0,0 @@
-import base64
-import hashlib
-import json
-import secrets
-import time
-import uuid
-from datetime import datetime, timezone
-from decimal import Decimal
-from typing import Any, Dict, Optional
-import os
-from fastapi import HTTPException
-
-
-INTERNAL_API_BASE = os.getenv("INTERNAL_API_BASE", "http://127.0.0.1:7860")
-STRIPE_SECRET_KEY = os.getenv("STRIPE_SECRET_KEY", "")
-WEBHOOK_KEY = os.getenv("WEBHOOK_KEY", "")
-
-
-def stringify_uuids(obj):
-    if isinstance(obj, uuid.UUID):
-        return str(obj)
-    if isinstance(obj, dict):
-        return {k: stringify_uuids(v) for k, v in obj.items()}
-    if isinstance(obj, list):
-        return [stringify_uuids(v) for v in obj]
-    return obj
-
-
-def count_input_images(body: Any) -> int:
-    if not isinstance(body, dict):
-        return 0
-
-    messages = body.get("messages")
-    count = 0
-
-    if isinstance(messages, list):
-        for msg in messages:
-            content = msg.get("content")
-
-            if isinstance(content, list):
-                for part in content:
-                    if not isinstance(part, dict):
-                        continue
-
-                    t = part.get("type")
-
-                    if t in ("image_url", "image"):
-                        count += 1
-
-                    if t == "image_urls":
-                        urls = part.get("image_urls")
-                        if isinstance(urls, list):
-                            count += len(urls)
-
-            elif isinstance(content, dict):
-                t = content.get("type")
-
-                if t in ("image_url", "image"):
-                    count += 1
-
-                if t == "image_urls":
-                    urls = content.get("image_urls")
-                    if isinstance(urls, list):
-                        count += len(urls)
-
-    top_level_urls = body.get("image_urls")
-    if isinstance(top_level_urls, list):
-        count += len(top_level_urls)
-
-    return count
-
-
-def build_public_config(config: Dict[str, Any]) -> Dict[str, Any]:
-    return {
-        "dashboard": config.get("dashboard", {}),
-        "supabase": config.get("supabase", {}),
-        "billing": config.get("billing", {}),
-        "pricing": config.get("pricing", {}),
-        "models": config.get("models", []),
-        "notices": [
-            notice
-            for notice in config.get("notices", [])
-            if isinstance(notice, dict) and notice.get("active") is not False
-        ],
-        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
-    }
-
-
-def trimmed_string(value: Any) -> Optional[str]:
-    if value is None:
-        return None
-
-    if isinstance(value, uuid.UUID):
-        return str(value)
-
-    if not isinstance(value, str):
-        return None
-
-    trimmed = value.strip()
-    return trimmed or None
-
-
-def format_iso_datetime(value: Any) -> Optional[str]:
-    if value is None:
-        return None
-
-    if isinstance(value, str):
-        return (
-            value
-            .replace("+00:00", "Z")
-            .replace("+00", "Z")
-        )
-
-    if hasattr(value, "isoformat"):
-        try:
-            return value.isoformat().replace("+00:00", "Z")
-        except Exception:
-            return None
-
-    return None
-
-
-def normalize_lightning_api_key_row(row: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-    key_id = trimmed_string(row.get("id"))
-    name = trimmed_string(row.get("name"))
-    key_prefix = trimmed_string(row.get("key_prefix"))
-    created_at = format_iso_datetime(row.get("created_at"))
-    if not key_id or not name or not key_prefix or not created_at:
-        return None
-
-    last_used_at = format_iso_datetime(row.get("last_used_at"))
-    expires_at = format_iso_datetime(row.get("expires_at"))
-    revoked_at = format_iso_datetime(row.get("revoked_at"))
-    is_expired = False
-
-    if revoked_at is None and expires_at:
-        try:
-            expires_dt = datetime.fromisoformat(expires_at.replace("Z", "+00:00"))
-            is_expired = expires_dt <= datetime.now(timezone.utc)
-        except Exception:
-            is_expired = False
-
-    return {
-        "id": key_id,
-        "name": name,
-        "keyPrefix": key_prefix,
-        "createdAt": created_at,
-        "lastUsedAt": last_used_at,
-        "expiresAt": expires_at,
-        "revokedAt": revoked_at,
-        "isRevoked": revoked_at is not None,
-        "isExpired": is_expired,
-    }
-
-
-def build_lightning_api_key_secret() -> str:
-    secret = base64.urlsafe_b64encode(secrets.token_bytes(24)).decode("ascii").rstrip("=")
-    return f"ipa_live_{secret}"
-
-
-def build_lightning_api_key_prefix(secret: str) -> str:
-    return secret[:16]
-
-
-def hash_lightning_api_key(secret: str) -> str:
-    salt = secrets.token_bytes(16)
-    derived_key = hashlib.scrypt(
-        secret.encode("utf-8"),
-        salt=salt,
-        n=16384,
-        r=8,
-        p=1,
-        dklen=32,
-    )
-    salt_b64 = base64.urlsafe_b64encode(salt).decode("ascii").rstrip("=")
-    key_b64 = base64.urlsafe_b64encode(derived_key).decode("ascii").rstrip("=")
-    return f"scrypt${salt_b64}${key_b64}"
-
-
-def parse_lightning_api_key_expiry(value: Any) -> Optional[str]:
-    trimmed = trimmed_string(value)
-    if not trimmed:
-        return None
-
-    normalized = trimmed.replace("Z", "+00:00")
-    try:
-        parsed = datetime.fromisoformat(normalized)
-    except Exception as exc:
-        raise HTTPException(
-            status_code=400,
-            detail="Expiration date must be a valid ISO timestamp",
-        ) from exc
-
-    if parsed.tzinfo is None:
-        parsed = parsed.replace(tzinfo=timezone.utc)
-
-    return parsed.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
-
-
-def build_upstream_headers(authorization: str, x_client_id: Optional[str]) -> Dict[str, str]:
-    headers = {
-        "Authorization": authorization,
-        "x-payg-internal": WEBHOOK_KEY,
-    }
-    if x_client_id:
-        headers["x-client-id"] = x_client_id
-    return headers
-
-
-def get_minimum_text_balance(config: Dict[str, Any]) -> Decimal:
-    raw_value = config.get("limits", {}).get("minimumTextCreditsBalance", 10)
-    try:
-        return Decimal(str(raw_value))
-    except Exception:
-        return Decimal("10")
-
-
-def extract_stream_usage_and_text(line: str) -> tuple[str, Optional[Dict[str, Any]], bool]:
-    if not isinstance(line, str) or not line.startswith("data:"):
-        return "", None, False
-
-    data = line[5:].strip()
-    if not data:
-        return "", None, False
-
-    if data == "[DONE]":
-        return "", None, True
-
-    try:
-        payload = json.loads(data)
-    except Exception:
-        return "", None, False
-
-    if not isinstance(payload, dict):
-        return "", None, False
-
-    usage = payload.get("usage") if isinstance(payload.get("usage"), dict) else None
-    collected_text = []
-
-    choices = payload.get("choices")
-    if isinstance(choices, list):
-        for choice in choices:
-            if not isinstance(choice, dict):
-                continue
-
-            delta = choice.get("delta")
-            if isinstance(delta, dict):
-                content = delta.get("content")
-                if isinstance(content, str):
-                    collected_text.append(content)
-                elif isinstance(content, list):
-                    for item in content:
-                        if isinstance(item, str):
-                            collected_text.append(item)
-                        elif isinstance(item, dict):
-                            text = item.get("text")
-                            if isinstance(text, str):
-                                collected_text.append(text)
-
-            message = choice.get("message")
-            if isinstance(message, dict):
-                content = message.get("content")
-                if isinstance(content, str):
-                    collected_text.append(content)
-                elif isinstance(content, list):
-                    for item in content:
-                        if isinstance(item, str):
-                            collected_text.append(item)
-                        elif isinstance(item, dict):
-                            text = item.get("text")
-                            if isinstance(text, str):
-                                collected_text.append(text)
-
-    return "".join(collected_text), usage, False
-
-
-def extract_completion_text_from_payload(payload: Dict[str, Any]) -> str:
-    if not isinstance(payload, dict):
-        return ""
-
-    collected_text = []
-    choices = payload.get("choices")
-    if isinstance(choices, list):
-        for choice in choices:
-            if not isinstance(choice, dict):
-                continue
-
-            message = choice.get("message")
-            if isinstance(message, dict):
-                content = message.get("content")
-                if isinstance(content, str):
-                    collected_text.append(content)
-                elif isinstance(content, list):
-                    for item in content:
-                        if isinstance(item, str):
-                            collected_text.append(item)
-                        elif isinstance(item, dict):
-                            text = item.get("text")
-                            if isinstance(text, str):
-                                collected_text.append(text)
-
-            delta = choice.get("delta")
-            if isinstance(delta, dict):
-                content = delta.get("content")
-                if isinstance(content, str):
-                    collected_text.append(content)
-                elif isinstance(content, list):
-                    for item in content:
-                        if isinstance(item, str):
-                            collected_text.append(item)
-                        elif isinstance(item, dict):
-                            text = item.get("text")
-                            if isinstance(text, str):
-                                collected_text.append(text)
-
-    return "".join(collected_text)

payg/media.py

@@ -1,307 +0,0 @@
-import base64
-import json
-import time
-import uuid
-from typing import Optional
-import httpx
-from fastapi import Header, HTTPException, Request
-from fastapi.responses import JSONResponse, Response
-from helper.payg import (
-    append_credit_ledger_entry,
-    calculate_audio_credit_cost,
-    calculate_image_credit_cost,
-    calculate_video_credit_cost,
-    enforce_payg_spam_limit,
-    get_payg_config,
-    require_payg_identity,
-)
-from . import router
-from .common import INTERNAL_API_BASE, build_upstream_headers
-
-
-@router.post("/images/generations")
-async def v1_images_generations(
-    request: Request,
-    authorization: Optional[str] = Header(None),
-    x_client_id: Optional[str] = Header(None),
-):
-    identity = await require_payg_identity(authorization)
-    config = await get_payg_config()
-
-    limit = int(config.get("limits", {}).get("requestsPerMinutePerIdentity", 120))
-    await enforce_payg_spam_limit(f"{identity['user_id']}:image", max(1, limit))
-
-    body = await request.json()
-    if not isinstance(body, dict):
-        raise HTTPException(status_code=400, detail="Invalid JSON body")
-
-    n = int(body.get("n") or 1)
-    n = max(1, min(n, 4))
-
-    cost = calculate_image_credit_cost(n, config)
-    usage_key = f"usage:image:{uuid.uuid4().hex}"
-
-    await append_credit_ledger_entry(
-        user_id=identity["user_id"],
-        delta_credits=-cost,
-        entry_type="usage",
-        usage_kind="image",
-        units=float(n),
-        unit_label="images",
-        source="v1_image",
-        source_ref=usage_key,
-        idempotency_key=usage_key,
-        metadata={"count": n},
-    )
-
-    prompt = body.get("prompt")
-    if not isinstance(prompt, str) or not prompt.strip():
-        raise HTTPException(status_code=400, detail="prompt is required")
-
-    payload = {
-        "prompt": prompt,
-        "mode": body.get("mode"),
-        "image_urls": body.get("image_urls"),
-    }
-
-    try:
-        async with httpx.AsyncClient(timeout=300) as client:
-            upstream = await client.post(
-                f"{INTERNAL_API_BASE}/gen/image",
-                json=payload,
-                headers=build_upstream_headers(authorization, x_client_id),
-            )
-
-        if upstream.status_code >= 400:
-            await append_credit_ledger_entry(
-                user_id=identity["user_id"],
-                delta_credits=cost,
-                entry_type="adjustment",
-                usage_kind="image",
-                units=float(n),
-                unit_label="images",
-                source="v1_image_refund",
-                source_ref=usage_key,
-                idempotency_key=f"refund:{usage_key}",
-                metadata={"reason": "upstream_error"},
-            )
-            return JSONResponse(
-                status_code=upstream.status_code,
-                content={"error": "Image generation failed", "detail": upstream.text[:1000]},
-            )
-
-        b64_image = base64.b64encode(upstream.content).decode("ascii")
-        return JSONResponse(
-            status_code=200,
-            content={
-                "created": int(time.time()),
-                "data": [{"b64_json": b64_image, "mime_type": "image/jpeg"}],
-                "usage": {"payg_credits_charged": float(cost), "image_count": n},
-            },
-        )
-
-    except Exception as exc:
-        await append_credit_ledger_entry(
-            user_id=identity["user_id"],
-            delta_credits=cost,
-            entry_type="adjustment",
-            usage_kind="image",
-            units=float(n),
-            unit_label="images",
-            source="v1_image_refund",
-            source_ref=usage_key,
-            idempotency_key=f"fatal-refund:{usage_key}",
-            metadata={"reason": "exception", "detail": str(exc)[:300]},
-        )
-        raise HTTPException(status_code=502, detail="Image generation failed")
-
-
-@router.post("/videos/generations")
-async def v1_video_generations(
-    request: Request,
-    authorization: Optional[str] = Header(None),
-    x_client_id: Optional[str] = Header(None),
-):
-    identity = await require_payg_identity(authorization)
-    config = await get_payg_config()
-
-    limit = int(config.get("limits", {}).get("requestsPerMinutePerIdentity", 120))
-    await enforce_payg_spam_limit(f"{identity['user_id']}:video", max(1, limit))
-
-    body = await request.json()
-    if not isinstance(body, dict):
-        raise HTTPException(status_code=400, detail="Invalid JSON body")
-
-    seconds = int(body.get("duration") or 5)
-    seconds = max(1, min(seconds, 10))
-
-    cost = calculate_video_credit_cost(seconds, config)
-    usage_key = f"usage:video:{uuid.uuid4().hex}"
-
-    await append_credit_ledger_entry(
-        user_id=identity["user_id"],
-        delta_credits=-cost,
-        entry_type="usage",
-        usage_kind="video",
-        units=float(seconds),
-        unit_label="seconds",
-        source="v1_video",
-        source_ref=usage_key,
-        idempotency_key=usage_key,
-        metadata={"duration_seconds": seconds},
-    )
-
-    payload = {
-        "prompt": body.get("prompt"),
-        "ratio": body.get("ratio"),
-        "mode": body.get("mode"),
-        "duration": seconds,
-        "image_urls": body.get("image_urls"),
-    }
-
-    try:
-        async with httpx.AsyncClient(timeout=600) as client:
-            upstream = await client.post(
-                f"{INTERNAL_API_BASE}/gen/video",
-                json=payload,
-                headers=build_upstream_headers(authorization, x_client_id),
-            )
-
-        if upstream.status_code >= 400:
-            await append_credit_ledger_entry(
-                user_id=identity["user_id"],
-                delta_credits=cost,
-                entry_type="adjustment",
-                usage_kind="video",
-                units=float(seconds),
-                unit_label="seconds",
-                source="v1_video_refund",
-                source_ref=usage_key,
-                idempotency_key=f"refund:{usage_key}",
-                metadata={"reason": "upstream_error"},
-            )
-            return JSONResponse(
-                status_code=upstream.status_code,
-                content={"error": "Video generation failed", "detail": upstream.text[:1000]},
-            )
-
-        return Response(
-            content=upstream.content,
-            media_type="video/mp4",
-            headers={
-                "X-Payg-Credits-Charged": str(float(cost)),
-                "X-Payg-Units": str(seconds),
-                "X-Payg-Unit-Label": "seconds",
-            },
-        )
-
-    except Exception as exc:
-        await append_credit_ledger_entry(
-            user_id=identity["user_id"],
-            delta_credits=cost,
-            entry_type="adjustment",
-            usage_kind="video",
-            units=float(seconds),
-            unit_label="seconds",
-            source="v1_video_refund",
-            source_ref=usage_key,
-            idempotency_key=f"fatal-refund:{usage_key}",
-            metadata={"reason": "exception", "detail": str(exc)[:300]},
-        )
-        raise HTTPException(status_code=502, detail="Video generation failed")
-
-
-@router.post("/audio/generations")
-async def v1_audio_generations(
-    request: Request,
-    authorization: Optional[str] = Header(None),
-    x_client_id: Optional[str] = Header(None),
-):
-    identity = await require_payg_identity(authorization)
-    config = await get_payg_config()
-
-    limit = int(config.get("limits", {}).get("requestsPerMinutePerIdentity", 120))
-    await enforce_payg_spam_limit(f"{identity['user_id']}:audio", max(1, limit))
-
-    body = await request.json()
-    if not isinstance(body, dict):
-        raise HTTPException(status_code=400, detail="Invalid JSON body")
-
-    audio_type = "sfx"
-
-    default_seconds = int(config.get("pricing", {}).get("audioDefaultSeconds", 10))
-    seconds = int(body.get("duration_seconds") or default_seconds)
-    seconds = max(1, min(seconds, 90))
-
-    cost = calculate_audio_credit_cost(seconds, config)
-    usage_key = f"usage:audio:{uuid.uuid4().hex}"
-
-    await append_credit_ledger_entry(
-        user_id=identity["user_id"],
-        delta_credits=-cost,
-        entry_type="usage",
-        usage_kind="audio",
-        units=float(seconds),
-        unit_label="seconds",
-        source="v1_audio",
-        source_ref=usage_key,
-        idempotency_key=usage_key,
-        metadata={"duration_seconds": seconds, "audio_type": audio_type},
-    )
-
-    prompt = body.get("prompt")
-    if not isinstance(prompt, str) or not prompt.strip():
-        raise HTTPException(status_code=400, detail="prompt is required")
-
-    endpoint = "sfx"
-
-    try:
-        async with httpx.AsyncClient(timeout=300) as client:
-            upstream = await client.post(
-                f"{INTERNAL_API_BASE}/gen/{endpoint}",
-                json={"prompt": prompt},
-                headers=build_upstream_headers(authorization, x_client_id),
-            )
-
-        if upstream.status_code >= 400:
-            await append_credit_ledger_entry(
-                user_id=identity["user_id"],
-                delta_credits=cost,
-                entry_type="adjustment",
-                usage_kind="audio",
-                units=float(seconds),
-                unit_label="seconds",
-                source="v1_audio_refund",
-                source_ref=usage_key,
-                idempotency_key=f"refund:{usage_key}",
-                metadata={"reason": "upstream_error"},
-            )
-            return JSONResponse(
-                status_code=upstream.status_code,
-                content={"error": "Audio generation failed", "detail": upstream.text[:1000]},
-            )
-
-        return Response(
-            content=upstream.content,
-            media_type="audio/mpeg",
-            headers={
-                "X-Payg-Credits-Charged": str(float(cost)),
-                "X-Payg-Units": str(seconds),
-                "X-Payg-Unit-Label": "seconds",
-            },
-        )
-
-    except Exception as exc:
-        await append_credit_ledger_entry(
-            user_id=identity["user_id"],
-            delta_credits=cost,
-            entry_type="adjustment",
-            usage_kind="audio",
-            units=float(seconds),
-            unit_label="seconds",
-            source="v1_audio_refund",
-            source_ref=usage_key,
-            idempotency_key=f"fatal-refund:{usage_key}",
-            metadata={"reason": "exception", "detail": str(exc)[:300]},
-        )
-        raise HTTPException(status_code=502, detail="Audio generation failed")

payg/stripe.py

@@ -1,250 +0,0 @@
-import os
-import stripe
-from decimal import Decimal
-from fastapi import Request, HTTPException
-from fastapi.responses import JSONResponse
-from helper.payg import (
-    append_credit_ledger_entry,
-    get_pack_by_session_amount,
-    get_payg_config,
-    get_wallet_snapshot,
-    quantize_credits,
-)
-from helper.subscriptions import execute_query
-from . import router
-
-STRIPE_SECRET_KEY = os.getenv("STRIPE_SECRET_KEY", "")
-stripe.api_key = STRIPE_SECRET_KEY
-STRIPE_WEBHOOK_SECRET = os.getenv("STRIPE_WEBHOOK_SECRET")
-
-
-@router.post("/stripe/webhook")
-async def stripe_webhook(request: Request):
-    payload = await request.body()
-    sig_header = request.headers.get("stripe-signature")
-
-    try:
-        event = stripe.Webhook.construct_event(
-            payload=payload,
-            sig_header=sig_header,
-            secret=STRIPE_WEBHOOK_SECRET,
-        )
-    except stripe.error.SignatureVerificationError:
-        raise HTTPException(status_code=400, detail="Invalid Stripe signature")
-
-    if event["type"] == "checkout.session.completed":
-        session = event["data"]["object"]
-        checkout_session_id = session["id"]
-        session = session.to_dict()
-
-        payment_status = (session.get("payment_status") or "").lower()
-        mode = session.get("mode")
-
-        customer_email = (
-            (session.get("customer_details") or {}).get("email") or ""
-        ).strip().lower()
-
-        if mode != "payment":
-            raise HTTPException(
-                status_code=400,
-                detail="Not a one-time payment session",
-            )
-
-        if payment_status != "paid":
-            return JSONResponse({"ok": True, "ignored": "not paid yet"})
-
-        if not customer_email:
-            raise HTTPException(
-                status_code=400,
-                detail="Missing customer email",
-            )
-
-        config = await get_payg_config()
-
-        user_row = await execute_query(
-            """
-            SELECT id
-            FROM auth.users
-            WHERE lower(email) = %s
-            LIMIT 1;
-            """,
-            (customer_email,),
-            fetchone=True,
-        )
-
-        if not user_row:
-            raise HTTPException(
-                status_code=404,
-                detail="User not found",
-            )
-
-        user_id = str(user_row["id"])
-
-        line_items = stripe.checkout.Session.list_line_items(
-            checkout_session_id,
-            limit=100,
-        )
-
-        packs = config.get("billing", {}).get("packs", [])
-
-        granted_packs = []
-        total_credits = Decimal("0")
-
-        for item in line_items.data:
-            product_id = str(item.price.product)
-            quantity = int(item.quantity or 1)
-
-            pack = next(
-                (
-                    p for p in packs
-                    if str(p.get("prod")) == product_id
-                ),
-                None,
-            )
-
-            if not pack:
-                continue
-
-            pack_credits = Decimal(str(pack.get("credits") or 0))
-
-            if pack_credits <= 0:
-                continue
-
-            granted = pack_credits * Decimal(str(quantity))
-            total_credits += granted
-
-            granted_packs.append({
-                "pack_id": pack.get("id"),
-                "product_id": product_id,
-                "quantity": quantity,
-                "credits": float(granted),
-            })
-
-        if total_credits <= 0:
-            raise HTTPException(
-                status_code=400,
-                detail="No valid packs found in checkout session",
-            )
-
-        idempotency_key = f"stripe_checkout:{checkout_session_id}"
-
-        entry = await append_credit_ledger_entry(
-            user_id=user_id,
-            delta_credits=quantize_credits(total_credits),
-            entry_type="purchase",
-            usage_kind=None,
-            units=float(total_credits),
-            unit_label="credits",
-            source="stripe_checkout_session",
-            source_ref=checkout_session_id,
-            idempotency_key=idempotency_key,
-            metadata={
-                "email": customer_email,
-                "packs": granted_packs,
-            },
-        )
-
-        wallet = await get_wallet_snapshot(user_id)
-
-        return {
-            "ok": True,
-            "user_id": user_id,
-            "email": customer_email,
-            "granted_credits": float(total_credits),
-            "packs": granted_packs,
-            "wallet": wallet,
-            "ledger": entry,
-        }
-
-    return JSONResponse({"ok": True})
-
-
-@router.get("/stripe/reconcile/{session_id}")
-async def reconcile_checkout_session(session_id: str):
-    try:
-        session = stripe.checkout.Session.retrieve(
-            session_id,
-            expand=[
-                "payment_intent.latest_charge",
-                "invoice",
-                "subscription.latest_invoice"
-            ]
-        )
-
-        line_items = stripe.checkout.Session.list_line_items(session_id, limit=1)
-        item = line_items.data[0] if line_items.data else None
-
-        receipt_url = None
-        payment_method_info = None
-
-        def parse_payment_method(charge):
-            if not charge or not getattr(charge, "payment_method_details", None):
-                return {"type": "unknown", "brand": None, "last4": None}
-            pm = charge.payment_method_details
-            return {
-                "type": pm.type,
-                "brand": getattr(pm.card, "brand", None) if pm.type == "card" else None,
-                "last4": getattr(pm.card, "last4", None) if pm.type == "card" else None,
-            }
-
-        if session.mode == "payment":
-            invoice = session.invoice
-            payment_intent = session.payment_intent
-
-            if invoice and not isinstance(invoice, str):
-                receipt_url = invoice.hosted_invoice_url or invoice.invoice_pdf
-
-            if payment_intent and not isinstance(payment_intent, str):
-                charge = getattr(payment_intent, "latest_charge", None)
-                if charge and not isinstance(charge, str):
-                    receipt_url = charge.receipt_url or receipt_url
-                    payment_method_info = parse_payment_method(charge)
-
-            elif session.amount_total > 0:
-                return {
-                    "ok": False,
-                    "status": session.status,
-                    "payment_status": session.payment_status,
-                    "message": "Payment not completed yet or still processing."
-                }
-
-        elif session.mode == "subscription":
-            subscription = session.subscription
-            if subscription and not isinstance(subscription, str) and subscription.latest_invoice:
-                invoice = subscription.latest_invoice
-                if not isinstance(invoice, str):
-                    receipt_url = invoice.hosted_invoice_url or invoice.invoice_pdf
-
-                    try:
-                        full_invoice = stripe.Invoice.retrieve(invoice.id, expand=["latest_charge"])
-                        charge = getattr(full_invoice, "latest_charge", None)
-                        if charge and not isinstance(charge, str):
-                            payment_method_info = parse_payment_method(charge)
-                    except Exception:
-                        pass
-
-            if not payment_method_info:
-                payment_method_info = {"type": "subscription", "brand": None, "last4": None}
-
-        else:
-            payment_method_info = {"type": session.mode, "brand": None, "last4": None}
-
-        return {
-            "ok": True,
-            "session_id": session.id,
-            "mode": session.mode,
-            "free_checkout": session.amount_total == 0,
-            "amount_total": session.amount_total,
-            "currency": session.currency,
-            "customer_email": session.customer_details.email if session.customer_details else None,
-            "product": {
-                "name": item.description if item else None,
-                "quantity": item.quantity if item else None,
-                "amount_each": item.amount_total if item else (0 if session.amount_total == 0 else None),
-            },
-            "payment_method": payment_method_info,
-            "receipt_url": receipt_url,
-        }
-
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))

prod-ca-2021.crt

@@ -1,23 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDxDCCAqygAwIBAgIUbLxMod62P2ktCiAkxnKJwtE9VPYwDQYJKoZIhvcNAQEL
-BQAwazELMAkGA1UEBhMCVVMxEDAOBgNVBAgMB0RlbHdhcmUxEzARBgNVBAcMCk5l
-dyBDYXN0bGUxFTATBgNVBAoMDFN1cGFiYXNlIEluYzEeMBwGA1UEAwwVU3VwYWJh
-c2UgUm9vdCAyMDIxIENBMB4XDTIxMDQyODEwNTY1M1oXDTMxMDQyNjEwNTY1M1ow
-azELMAkGA1UEBhMCVVMxEDAOBgNVBAgMB0RlbHdhcmUxEzARBgNVBAcMCk5ldyBD
-YXN0bGUxFTATBgNVBAoMDFN1cGFiYXNlIEluYzEeMBwGA1UEAwwVU3VwYWJhc2Ug
-Um9vdCAyMDIxIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqQXW
-QyHOB+qR2GJobCq/CBmQ40G0oDmCC3mzVnn8sv4XNeWtE5XcEL0uVih7Jo4Dkx1Q
-DmGHBH1zDfgs2qXiLb6xpw/CKQPypZW1JssOTMIfQppNQ87K75Ya0p25Y3ePS2t2
-GtvHxNjUV6kjOZjEn2yWEcBdpOVCUYBVFBNMB4YBHkNRDa/+S4uywAoaTWnCJLUi
-cvTlHmMw6xSQQn1UfRQHk50DMCEJ7Cy1RxrZJrkXXRP3LqQL2ijJ6F4yMfh+Gyb4
-O4XajoVj/+R4GwywKYrrS8PrSNtwxr5StlQO8zIQUSMiq26wM8mgELFlS/32Uclt
-NaQ1xBRizkzpZct9DwIDAQABo2AwXjALBgNVHQ8EBAMCAQYwHQYDVR0OBBYEFKjX
-uXY32CztkhImng4yJNUtaUYsMB8GA1UdIwQYMBaAFKjXuXY32CztkhImng4yJNUt
-aUYsMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAB8spzNn+4VU
-tVxbdMaX+39Z50sc7uATmus16jmmHjhIHz+l/9GlJ5KqAMOx26mPZgfzG7oneL2b
-VW+WgYUkTT3XEPFWnTp2RJwQao8/tYPXWEJDc0WVQHrpmnWOFKU/d3MqBgBm5y+6
-jB81TU/RG2rVerPDWP+1MMcNNy0491CTL5XQZ7JfDJJ9CCmXSdtTl4uUQnSuv/Qx
-Cea13BX2ZgJc7Au30vihLhub52De4P/4gonKsNHYdbWjg7OWKwNv/zitGDVDB9Y2
-CMTyZKG3XEu5Ghl1LEnI3QmEKsqaCLv12BnVjbkSeZsMnevJPs1Ye6TjjJwdik5P
-o/bKiIz+Fq8=
------END CERTIFICATE-----

requirements.txt

@@ -1,8 +0,0 @@
-fastapi
-uvicorn[standard]
-httpx
-beautifulsoup4
-supabase
-psycopg[binary]
-pillow
-stripe

status.py

@@ -1,69 +0,0 @@
-# status.py
-from fastapi import APIRouter, Response
-from fastapi.responses import JSONResponse
-
-router = APIRouter(prefix="/status")
-
-@router.head("/sfx")
-async def head_sfx():
-    return Response(
-        status_code=200,
-        headers={
-            "Content-Type": "audio/mpeg",
-            "Accept-Ranges": "bytes",
-        },
-    )
-
-@router.head("/image")
-async def head_image():
-    return Response(
-        status_code=200,
-        headers={
-            "Content-Type": "image/jpeg",
-            "Accept-Ranges": "bytes",
-        },
-    )
-
-@router.head("/video")
-async def head_video():
-    return Response(
-        status_code=200,
-        headers={
-            "Content-Type": "video/mp4",
-            "Accept-Ranges": "bytes",
-        },
-    )
-
-@router.head("/text")
-async def head_text():
-    return Response(
-        status_code=200,
-        headers={
-            "Content-Type": "application/json",
-            "Accept-Ranges": "bytes",
-        },
-    )
-
-@router.get("/")
-async def get_status():
-    notify = ""
-    services = {
-        "Video Generation": {"code": 200, "state": "ok", "message": "Running Normally"},
-        "Image Generation": {"code": 200, "state": "ok", "message": "Running Normally"},
-        "Lightning-Text v2": {"code": 200, "state": "ok", "message": "Running normally"},
-        "Music/SFX Generation": {"code": 200, "state": "ok", "message": "Running normally"},
-    }
-
-    overall_state = (
-        "ok" if all(s["state"] == "ok" for s in services.values()) else "degraded"
-    )
-
-    return JSONResponse(
-        status_code=200,
-        content={
-            "state": overall_state,
-            "services": services,
-            "notifications": notify,
-            "latest": "2.12.0",
-        },
-    )