Update main.py

main.py

@@ -1,395 +1,1447 @@
 import os
-import json
-import datetime
-import asyncio
 import re
-from functools import lru_cache
-from pathlib import Path
-from typing import List, Dict, Any, Tuple, Optional
-
-import httpx
-import uvicorn
 from dotenv import load_dotenv
-from fastapi import FastAPI, HTTPException, Request, Depends, Security, Query, APIRouter
-from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse, FileResponse, PlainTextResponse
+from fastapi import FastAPI, HTTPException, Request, Depends, Security, Query
+from fastapi.responses import StreamingResponse, HTMLResponse, JSONResponse, FileResponse, PlainTextResponse
 from fastapi.security import APIKeyHeader
-from pydantic_settings import BaseSettings
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
+import httpx
+from functools import lru_cache
+from pathlib import Path
+import json
+import datetime
+import time
+import threading
+from typing import Optional, Dict, List, Any, Generator
+import asyncio
+from starlette.status import HTTP_403_FORBIDDEN
+import cloudscraper
+from concurrent.futures import ThreadPoolExecutor
+import uvloop
+from fastapi.middleware.gzip import GZipMiddleware
 from starlette.middleware.cors import CORSMiddleware
-from starlette.middleware.gzip import GZipMiddleware
-from starlette.status import HTTP_403_FORBIDDEN, HTTP_503_SERVICE_UNAVAILABLE
+import contextlib
+import requests
 
-# Use cloudscraper for specific endpoints that need it
-try:
-    import cloudscraper
-except ImportError:
-    cloudscraper = None
+asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
 
-from usage_tracker import UsageTracker
+executor = ThreadPoolExecutor(max_workers=16)
 
-# --- Initial Setup ---
 load_dotenv()
-# Use uvloop for better performance if available
-try:
-    import uvloop
-    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
-except ImportError:
-    pass
-
-# --- Configuration Management using Pydantic ---
-class Settings(BaseSettings):
-    """Manages all application settings and environment variables in one place."""
-    api_keys: List[str] = Field(..., env="API_KEYS")
-    
-    # Endpoints for various model providers
-    secret_api_endpoint: str = Field(..., env="SECRET_API_ENDPOINT")
-    secret_api_endpoint_2: str = Field(..., env="SECRET_API_ENDPOINT_2")
-    secret_api_endpoint_3: str = Field(..., env="SECRET_API_ENDPOINT_3")
-    secret_api_endpoint_4: str = "https://text.pollinations.ai/openai"
-    secret_api_endpoint_5: str = Field(..., env="SECRET_API_ENDPOINT_5")
-    secret_api_endpoint_6: str = Field(..., env="SECRET_API_ENDPOINT_6")
-    
-    # Specific provider keys and APIs
-    mistral_api: str = "https://api.mistral.ai"
-    mistral_key: str = Field(..., env="MISTRAL_KEY")
-    gemini_key: str = Field(..., env="GEMINI_KEY")
-    new_img_api: str = Field(..., env="NEW_IMG")
-    
-    endpoint_origin: Optional[str] = Field(None, env="ENDPOINT_ORIGIN")
-    header_url: Optional[str] = Field(None, env="HEADER_URL")
 
-    class Config:
-        env_file = '.env'
-        env_file_encoding = 'utf-8'
+api_key_header = APIKeyHeader(name="Authorization", auto_error=False)
+
+from usage_tracker import UsageTracker
+usage_tracker = UsageTracker()
+
+app = FastAPI()
+
+app.add_middleware(GZipMiddleware, minimum_size=1000)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@lru_cache(maxsize=1)
+def get_env_vars():
+    """
+    Loads and caches environment variables. This function is memoized
+    to avoid re-reading .env file on every call, improving performance.
+    """
+    return {
+        'api_keys': os.getenv('API_KEYS', '').split(','),
+        'secret_api_endpoint': os.getenv('SECRET_API_ENDPOINT'),
+        'secret_api_endpoint_2': os.getenv('SECRET_API_ENDPOINT_2'),
+        'secret_api_endpoint_3': os.getenv('SECRET_API_ENDPOINT_3'),
+        'secret_api_endpoint_4': os.getenv('SECRET_API_ENDPOINT_4', "https://text.pollinations.ai/openai"),
+        'secret_api_endpoint_5': os.getenv('SECRET_API_ENDPOINT_5'),
+        'secret_api_endpoint_6': os.getenv('SECRET_API_ENDPOINT_6'), # New endpoint for Gemini
+        'mistral_api': os.getenv('MISTRAL_API', "https://api.mistral.ai"),
+        'mistral_key': os.getenv('MISTRAL_KEY'),
+        'gemini_key': os.getenv('GEMINI_KEY'), # Gemini API Key
+        'endpoint_origin': os.getenv('ENDPOINT_ORIGIN'),
+        'new_img': os.getenv('NEW_IMG') # For image generation API
+    }
+
+# Define sets of models for different API endpoints for easier routing
+mistral_models = {
+    "mistral-large-latest", "pixtral-large-latest", "mistral-moderation-latest",
+    "ministral-3b-latest", "ministral-8b-latest", "open-mistral-nemo",
+    "mistral-small-latest", "mistral-saba-latest", "codestral-latest"
+}
 
-@lru_cache()
-def get_settings():
-    return Settings()
+pollinations_models = {
+    "openai", "openai-large", "openai-fast", "openai-xlarge", "openai-reasoning",
+    "qwen-coder", "llama", "mistral", "searchgpt", "deepseek", "claude-hybridspace",
+    "deepseek-r1", "deepseek-reasoner", "llamalight", "gemini", "gemini-thinking",
+    "hormoz", "phi", "phi-mini", "openai-audio", "llama-scaleway"
+}
+alternate_models = {
+    "o1", "llama-4-scout", "o4-mini", "sonar", "sonar-pro", "sonar-reasoning",
+    "sonar-reasoning-pro", "grok-3", "grok-3-fast", "r1-1776", "o3"
+}
+
+claude_3_models = {
+    "claude-3-7-sonnet", "claude-3-7-sonnet-thinking", "claude 3.5 haiku",
+    "claude 3.5 sonnet", "claude 3.5 haiku", "o3-mini-medium", "o3-mini-high",
+    "grok-3", "grok-3-thinking", "grok 2"
+}
+
+gemini_models = {
+    "gemini-1.5-pro", "gemini-1.5-flash", "gemini-2.0-flash-lite-preview",
+    "gemini-2.0-flash", "gemini-2.0-flash-thinking",  # aka Reasoning
+    "gemini-2.0-flash-preview-image-generation", "gemini-2.5-flash",
+    "gemini-2.5-pro-exp", "gemini-exp-1206"
+}
 
-# --- Pydantic Models for Payloads ---
-class ChatPayload(BaseModel):
+supported_image_models = {
+    "Flux Pro Ultra", "grok-2-aurora", "Flux Pro", "Flux Pro Ultra Raw",
+    "Flux Dev", "Flux Schnell", "stable-diffusion-3-large-turbo",
+    "Flux Realism", "stable-diffusion-ultra", "dall-e-3", "sdxl-lightning-4step"
+}
+
+class Payload(BaseModel):
+    """Pydantic model for chat completion requests."""
     model: str
-    messages: List[Dict[str, Any]]
+    messages: list
     stream: bool = False
 
 class ImageGenerationPayload(BaseModel):
+    """Pydantic model for image generation requests."""
     model: str
     prompt: str
-    size: int
-    number: int
-
-# --- Global Objects & State ---
-app = FastAPI(
-    title="LokiAI API",
-    version="2.5.0",
-    description="A robust and scalable API proxy for various AI models, now fully rewritten.",
-)
-usage_tracker = UsageTracker()
-api_key_header = APIKeyHeader(name="Authorization", auto_error=False)
-server_status = {"online": True}
-
-# --- Model & API Configuration ---
-MODEL_SETS = {
-    "mistral": {"mistral-large-latest", "codestral-latest", "mistral-small-latest"},
-    "pollinations": {"openai", "gemini", "phi", "llama"},
-    "alternate": {"o1", "grok-3", "sonar-pro"},
-    "claude": {"claude-3-7-sonnet", "claude 3.5 sonnet", "o3-mini-medium"},
-    "gemini": {"gemini-1.5-pro", "gemini-1.5-flash", "gemini-2.0-flash"},
-    "image": {"Flux Pro Ultra", "dall-e-3", "stable-diffusion-3-large-turbo"},
-}
+    size: str = "1024x1024" # Default size, assuming models support it
+    number: int = 1
 
-def get_api_details(model_name: str, settings: Settings) -> Tuple[str, Dict, str]:
-    """Returns the endpoint, headers, and path for a given model."""
-    if model_name in MODEL_SETS["mistral"]:
-        return settings.mistral_api, {"Authorization": f"Bearer {settings.mistral_key}"}, "/v1/chat/completions"
-    if model_name in MODEL_SETS["gemini"]:
-        return settings.secret_api_endpoint_6, {"Authorization": f"Bearer {settings.gemini_key}"}, "/chat/completions"
-    if model_name in MODEL_SETS["pollinations"]:
-        return settings.secret_api_endpoint_4, {}, "/v1/chat/completions"
-    if model_name in MODEL_SETS["claude"]:
-        return settings.secret_api_endpoint_5, {}, "/v1/chat/completions"
-    if model_name in MODEL_SETS["alternate"]:
-        return settings.secret_api_endpoint_2, {}, "/v1/chat/completions"
-    if model_name in MODEL_SETS["image"]:
-        return settings.new_img_api, {}, ""
-    
-    # Default case
-    headers = {
-        "Origin": settings.header_url, "Referer": settings.header_url
-    } if settings.header_url else {}
-    return settings.secret_api_endpoint, headers, "/v1/chat/completions"
+server_status = True # Global flag for server maintenance status
+available_model_ids: List[str] = [] # List of all available model IDs
 
-# --- Dependencies & Security ---
-async def get_api_key(request: Request, api_key: str = Security(api_key_header)):
-    """Validates the API key, allowing specific referers to bypass."""
-    referer = request.headers.get("referer", "")
-    if referer and "parthsadaria-lokiai.hf.space" in referer:
-        return "hf_space_bypass"
+@lru_cache(maxsize=1)
+def get_async_client():
+    """Returns a memoized httpx.AsyncClient instance for making async HTTP requests."""
+    return httpx.AsyncClient(
+        timeout=60.0,
+        limits=httpx.Limits(max_keepalive_connections=50, max_connections=200)
+    )
 
-    settings = get_settings()
-    if not api_key or not api_key.startswith("Bearer "):
-        raise HTTPException(status_code=HTTP_403_FORBIDDEN, detail="Invalid authorization format.")
-    
-    key = api_key.split(" ")[1]
-    if key not in settings.api_keys:
-        raise HTTPException(status_code=HTTP_403_FORBIDDEN, detail="Invalid API key.")
-    return key
-
-@lru_cache()
-def get_http_client() -> httpx.AsyncClient:
-    return httpx.AsyncClient(timeout=60.0, limits=httpx.Limits(max_connections=200))
-
-# --- API Routers ---
-chat_router = APIRouter(tags=["AI Models"])
-image_router = APIRouter(tags=["AI Models"])
-usage_router = APIRouter(tags=["Server Administration"])
-utility_router = APIRouter(tags=["Utilities & Pages"])
-
-# --- Chat Completions Router ---
-@chat_router.post("/chat/completions")
-async def chat_completions(
-    payload: ChatPayload,
+scraper_pool = []
+MAX_SCRAPERS = 20
+
+def get_scraper():
+    """Retrieves a cloudscraper instance from a pool for web scraping."""
+    if not scraper_pool:
+        # Initialize the pool if it's empty (should be done at startup)
+        for _ in range(MAX_SCRAPERS):
+            scraper_pool.append(cloudscraper.create_scraper())
+    # Simple round-robin selection from the pool
+    return scraper_pool[int(time.time() * 1000) % MAX_SCRAPERS]
+
+async def verify_api_key(
     request: Request,
-    api_key: str = Depends(get_api_key),
-    client: httpx.AsyncClient = Depends(get_http_client)
-):
-    if not server_status["online"]:
-        raise HTTPException(status_code=HTTP_503_SERVICE_UNAVAILABLE, detail="Server under maintenance.")
+    api_key: str = Security(api_key_header)
+) -> bool:
+    """
+    Verifies the API key provided in the Authorization header.
+    Allows access without API key if the request comes from specific Hugging Face spaces.
+    """
+    referer = request.headers.get("referer", "")
+    if referer.startswith(("https://parthsadaria-lokiai.hf.space/playground",
+                           "https://parthsadaria-lokiai.hf.space/image-playground")):
+        return True
 
-    settings = get_settings()
-    usage_tracker.record_request(request, payload.model, "/chat/completions")
-    endpoint, headers, path = get_api_details(payload.model, settings)
+    if not api_key:
+        raise HTTPException(
+            status_code=HTTP_403_FORBIDDEN,
+            detail="No API key provided"
+        )
 
-    async def stream_generator():
-        try:
-            async with client.stream("POST", f"{endpoint}{path}", json=payload.dict(), headers=headers) as response:
-                response.raise_for_status()
-                async for chunk in response.aiter_bytes():
-                    yield chunk
-        except httpx.HTTPStatusError as e:
-            print(f"Upstream error: {e.response.status_code} - {e.response.text}")
-            yield json.dumps({"error": {"code": 502, "message": "Bad Gateway: Upstream service error."}}).encode()
-        except Exception as e:
-            print(f"Streaming error: {e}")
-            yield json.dumps({"error": {"code": 500, "message": "An internal error occurred."}}).encode()
+    if api_key.startswith('Bearer '):
+        api_key = api_key[7:]
 
-    return StreamingResponse(stream_generator(), media_type="text/event-stream")
+    valid_api_keys = get_env_vars().get('api_keys', [])
+    if not valid_api_keys or valid_api_keys == ['']:
+        raise HTTPException(
+            status_code=HTTP_403_FORBIDDEN,
+            detail="API keys not configured on server"
+        )
 
-# --- Image Generation Router ---
-@image_router.post("/images/generations")
-async def images_generations(
-    payload: ImageGenerationPayload,
-    request: Request,
-    api_key: str = Depends(get_api_key),
-    client: httpx.AsyncClient = Depends(get_http_client)
-):
-    if not server_status["online"]:
-         raise HTTPException(status_code=HTTP_503_SERVICE_UNAVAILABLE, detail="Server under maintenance.")
-
-    if payload.model not in MODEL_SETS["image"]:
-        raise HTTPException(status_code=400, detail=f"Image model '{payload.model}' not supported.")
-        
-    settings = get_settings()
-    usage_tracker.record_request(request, payload.model, "/images/generations")
-    endpoint, headers, _ = get_api_details(payload.model, settings)
+    if api_key not in set(valid_api_keys):
+        raise HTTPException(
+            status_code=HTTP_403_FORBIDDEN,
+            detail="Invalid API key"
+        )
 
-    try:
-        response = await client.post(endpoint, json=payload.dict(), headers=headers)
-        response.raise_for_status()
-        return JSONResponse(content=response.json())
-    except httpx.HTTPStatusError as e:
-        raise HTTPException(status_code=e.response.status_code, detail=e.response.json().get("detail", "Upstream error"))
-    except httpx.RequestError as e:
-        raise HTTPException(status_code=502, detail=f"Failed to connect to image service: {e}")
-
-# --- Usage & Health Router ---
-@usage_router.get("/usage", response_class=HTMLResponse)
-async def get_usage_dashboard(days: int = Query(7, ge=1, le=30)):
-    summary = usage_tracker.get_usage_summary(days=days)
-    # The generate_usage_html function from the previous version can be used here directly
-    # It has been moved to a separate file or helper for cleanliness in a real app
-    # For this example, it's defined below for completeness.
-    from usage_dashboard_generator import generate_usage_html
-    return HTMLResponse(content=generate_usage_html(summary))
-
-@usage_router.get("/health")
-async def health_check():
-    return {"status": "healthy" if server_status["online"] else "unhealthy", "version": app.version}
+    return True
 
-@usage_router.get("/models")
-async def get_models():
+@lru_cache(maxsize=1)
+def load_models_data():
+    """Loads model data from 'models.json' and caches it."""
     try:
-        with open(Path(__file__).parent / 'models.json', 'r') as f:
+        file_path = Path(__file__).parent / 'models.json'
+        with open(file_path, 'r') as f:
             return json.load(f)
-    except Exception:
-        raise HTTPException(status_code=500, detail="models.json not found or is invalid.")
+    except (FileNotFoundError, json.JSONDecodeError) as e:
+        print(f"Error loading models.json: {str(e)}")
+        return []
+
+@app.get("/api/v1/models")
+@app.get("/models")
+async def get_models():
+    """Returns the list of available models."""
+    models_data = load_models_data()
+    if not models_data:
+        raise HTTPException(status_code=500, detail="Error loading available models")
+    return models_data
+
+async def generate_search_async(query: str, systemprompt: Optional[str] = None, stream: bool = True):
+    """
+    Asynchronously generates a response using a search-based model.
+    Streams results if `stream` is True.
+    """
+    queue = asyncio.Queue()
+
+    async def _fetch_search_data():
+        """Internal helper to fetch data from the search API and put into queue."""
+        try:
+            headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
+            system_message = systemprompt or "Be Helpful and Friendly"
+            prompt = [{"role": "user", "content": query}]
+            prompt.insert(0, {"content": system_message, "role": "system"})
+            payload = {
+                "is_vscode_extension": True,
+                "message_history": prompt,
+                "requested_model": "searchgpt",
+                "user_input": prompt[-1]["content"],
+            }
+            secret_api_endpoint_3 = get_env_vars()['secret_api_endpoint_3']
+            if not secret_api_endpoint_3:
+                await queue.put({"error": "Search API endpoint not configured"})
+                return
+
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                async with client.stream("POST", secret_api_endpoint_3, json=payload, headers=headers) as response:
+                    if response.status_code != 200:
+                        error_detail = await response.text()
+                        await queue.put({"error": f"Search API returned status code {response.status_code}: {error_detail}"})
+                        return
+
+                    buffer = ""
+                    async for line in response.aiter_lines():
+                        if line.startswith("data: "):
+                            try:
+                                json_data = json.loads(line[6:])
+                                content = json_data.get("choices", [{}])[0].get("delta", {}).get("content", "")
+                                if content.strip():
+                                    cleaned_response = {
+                                        "created": json_data.get("created"),
+                                        "id": json_data.get("id"),
+                                        "model": "searchgpt",
+                                        "object": "chat.completion",
+                                        "choices": [
+                                            {
+                                                "message": {
+                                                    "content": content
+                                                }
+                                            }
+                                        ]
+                                    }
+                                    await queue.put({"data": f"data: {json.dumps(cleaned_response)}\n\n", "text": content})
+                            except json.JSONDecodeError:
+                                # If line is not valid JSON, treat it as raw text and pass through if it's the end of stream
+                                if line.strip() == "[DONE]":
+                                    continue # This is usually handled by the aiter_lines loop finishing
+                                print(f"Warning: Could not decode JSON from search API stream: {line}")
+                                await queue.put({"error": f"Invalid JSON from search API: {line}"})
+                                break # Stop processing on bad JSON
+                    await queue.put(None) # Signal end of stream
+        except Exception as e:
+            print(f"Error in _fetch_search_data: {e}")
+            await queue.put({"error": str(e)})
+            await queue.put(None)
+
+    asyncio.create_task(_fetch_search_data())
+    return queue
 
-# --- Utility & Pages Router ---
 @lru_cache(maxsize=10)
-def read_static_file(file_path):
+def read_html_file(file_path):
+    """Reads content of an HTML file and caches it."""
     try:
-        with open(Path(__file__).parent / file_path, "r", encoding="utf-8") as file:
+        with open(file_path, "r") as file:
             return file.read()
     except FileNotFoundError:
         return None
 
-@utility_router.get("/", response_class=HTMLResponse)
-async def root_page():
-    return HTMLResponse(content=read_static_file("index.html") or "<h1>Not Found</h1>")
+# Static file routes for basic web assets
+@app.get("/favicon.ico")
+async def favicon():
+    favicon_path = Path(__file__).parent / "favicon.ico"
+    return FileResponse(favicon_path, media_type="image/x-icon")
+
+@app.get("/banner.jpg")
+async def banner():
+    banner_path = Path(__file__).parent / "banner.jpg"
+    return FileResponse(banner_path, media_type="image/jpeg")
+
+@app.get("/ping")
+async def ping():
+    """Simple health check endpoint."""
+    return {"message": "pong", "response_time": "0.000000 seconds"}
+
+@app.get("/", response_class=HTMLResponse)
+async def root():
+    """Serves the main index.html file."""
+    html_content = read_html_file("index.html")
+    if html_content is None:
+        raise HTTPException(status_code=404, detail="index.html not found")
+    return HTMLResponse(content=html_content)
+
+@app.get("/script.js", response_class=HTMLResponse)
+async def script():
+    """Serves script.js."""
+    html_content = read_html_file("script.js")
+    if html_content is None:
+        raise HTTPException(status_code=404, detail="script.js not found")
+    return HTMLResponse(content=html_content)
+
+@app.get("/style.css", response_class=HTMLResponse)
+async def style():
+    """Serves style.css."""
+    html_content = read_html_file("style.css")
+    if html_content is None:
+        raise HTTPException(status_code=404, detail="style.css not found")
+    return HTMLResponse(content=html_content)
+
+@app.get("/dynamo", response_class=HTMLResponse)
+async def dynamic_ai_page(request: Request):
+    """
+    Generates a dynamic HTML page using an AI model based on user-agent and IP.
+    Note: The hardcoded API endpoint and bearer token should ideally be managed
+    more securely, perhaps via environment variables and proper authentication.
+    """
+    user_agent = request.headers.get('user-agent', 'Unknown User')
+    client_ip = request.client.host if request.client else "Unknown IP"
+    location = f"IP: {client_ip}"
+
+    prompt = f"""
+    Generate a dynamic HTML page for a user with the following details: with name "LOKI.AI"
+    - User-Agent: {user_agent}
+    - Location: {location}
+    - Style: Cyberpunk, minimalist, or retro
+
+    Make sure the HTML is clean and includes a heading, also have cool animations a motivational message, and a cool background.
+    Wrap the generated HTML in triple backticks (```).
+    """
+
+    payload = {
+        "model": "mistral-small-latest",
+        "messages": [{"role": "user", "content": prompt}]
+    }
+
+    # Using the local /chat/completions endpoint for internal model call
+    # This assumes the current server can proxy to Mistral.
+    # For production, consider direct calls if not proxying is needed.
+    headers = {
+        "Authorization": "Bearer playground" # Use a dedicated internal token if available
+    }
 
-@utility_router.get("/playground", response_class=HTMLResponse)
-async def playground_page():
-    return HTMLResponse(content=read_static_file("playground.html") or "<h1>Not Found</h1>")
-    
-@utility_router.get("/image-playground", response_class=HTMLResponse)
-async def image_playground_page():
-    return HTMLResponse(content=read_static_file("image-playground.html") or "<h1>Not Found</h1>")
-
-@utility_router.get("/scraper", response_class=PlainTextResponse)
-async def scrape_url(url: str = Query(..., description="URL to scrape")):
-    if not cloudscraper:
-        raise HTTPException(status_code=501, detail="Scraper library not installed.")
     try:
-        scraper = cloudscraper.create_scraper()
-        response = scraper.get(url)
-        response.raise_for_status()
-        return PlainTextResponse(content=response.text)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to scrape URL: {e}")
+        # Use httpx.AsyncClient for making an async request
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"http://localhost:7860/chat/completions", # Call self or internal API
+                json=payload,
+                headers=headers,
+                timeout=30.0
+            )
+        response.raise_for_status() # Raise an exception for bad status codes
+        data = response.json()
 
+        html_content = None
+        if data and 'choices' in data and len(data['choices']) > 0:
+            message_content = data['choices'][0].get('message', {}).get('content', '')
+            # Extract content within triple backticks
+            match = re.search(r"```(?:html)?(.*?)```", message_content, re.DOTALL)
+            if match:
+                html_content = match.group(1).strip()
+            else:
+                # Fallback: if no backticks, assume the whole content is HTML
+                html_content = message_content.strip()
 
-# --- Main Application Setup ---
-app.add_middleware(GZipMiddleware, minimum_size=1000)
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+        if not html_content:
+            raise HTTPException(status_code=500, detail="Failed to generate HTML content from AI.")
+        
+        return HTMLResponse(content=html_content)
+    except httpx.RequestError as e:
+        print(f"HTTPX Request Error in /dynamo: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to connect to internal AI service: {e}")
+    except httpx.HTTPStatusError as e:
+        print(f"HTTPX Status Error in /dynamo: {e.response.status_code} - {e.response.text}")
+        raise HTTPException(status_code=e.response.status_code, detail=f"Internal AI service responded with error: {e.response.text}")
+    except Exception as e:
+        print(f"An unexpected error occurred in /dynamo: {e}")
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {e}")
 
-# Include all the organized routers
-app.include_router(chat_router, prefix="/api/v1")
-app.include_router(chat_router) # For legacy /chat/completions
-app.include_router(image_router, prefix="/api/v1")
-app.include_router(image_router) # For legacy /images/generations
-app.include_router(usage_router)
-app.include_router(utility_router)
 
-@app.on_event("startup")
-async def startup_event():
-    # Pre-load settings and client to catch config errors early
+@app.get("/scraper", response_class=PlainTextResponse)
+async def scrape_site(url: str = Query(..., description="URL to scrape")):
+    """
+    Scrapes the content of a given URL using cloudscraper.
+    Uses await in front of get_scraper().get() for async execution.
+    """
     try:
-        get_settings()
+        # get_scraper() returns a synchronous scraper object, but we are running
+        # it in an async endpoint. For CPU-bound tasks like this, it's better
+        # to offload to a thread pool to not block the event loop.
+        # However, cloudscraper's get method is typically synchronous.
+        # If cloudscraper were truly async, we'd use await.
+        # For now, running in executor to prevent blocking.
+        loop = asyncio.get_running_loop()
+        response_text = await loop.run_in_executor(
+            executor,
+            lambda: get_scraper().get(url).text
+        )
+
+        if response_text and len(response_text.strip()) > 0:
+            return PlainTextResponse(response_text)
+        else:
+            raise HTTPException(status_code=500, detail="Scraping returned empty content.")
     except Exception as e:
-        print(f"FATAL: Could not load settings from environment variables. Error: {e}")
-        # In a real app, you might want to exit here
-    get_http_client()
-    print("--- LokiAI Server Started ---")
-    print(f"Version: {app.version}")
-    print("Usage tracking is active and will save data periodically.")
+        print(f"Cloudscraper failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Cloudscraper failed: {e}")
 
-@app.on_event("shutdown")
-async def shutdown_event():
-    client = get_http_client()
-    await client.aclose()
-    usage_tracker.save_data()
-    print("--- LokiAI Server Shutdown Complete ---")
+@app.get("/playground", response_class=HTMLResponse)
+async def playground():
+    """Serves the playground.html file."""
+    html_content = read_html_file("playground.html")
+    if html_content is None:
+        raise HTTPException(status_code=404, detail="playground.html not found")
+    return HTMLResponse(content=html_content)
 
+@app.get("/image-playground", response_class=HTMLResponse)
+async def image_playground():
+    """Serves the image-playground.html file."""
+    html_content = read_html_file("image-playground.html")
+    if html_content is None:
+        raise HTTPException(status_code=404, detail="image-playground.html not found")
+    return HTMLResponse(content=html_content)
 
-# Helper for usage dashboard - in a real project, this would be in its own file
-# I'm creating it here to make the example self-contained
-if not (Path(__file__).parent / "usage_dashboard_generator.py").exists():
-    with open(Path(__file__).parent / "usage_dashboard_generator.py", "w") as f:
-        f.write('''
-import json
-import datetime
+GITHUB_BASE = "[https://raw.githubusercontent.com/Parthsadaria/Vetra/main](https://raw.githubusercontent.com/Parthsadaria/Vetra/main)"
+
+FILES = {
+    "html": "index.html",
+    "css": "style.css",
+    "js": "script.js"
+}
+
+async def get_github_file(filename: str) -> Optional[str]:
+    """Fetches a file from a specified GitHub raw URL."""
+    url = f"{GITHUB_BASE}/{filename}"
+    async with httpx.AsyncClient() as client:
+        try:
+            res = await client.get(url, follow_redirects=True)
+            res.raise_for_status() # Raise an exception for HTTP errors (4xx or 5xx)
+            return res.text
+        except httpx.HTTPStatusError as e:
+            print(f"Error fetching {filename} from GitHub: {e.response.status_code} - {e.response.text}")
+            return None
+        except httpx.RequestError as e:
+            print(f"Request error fetching {filename} from GitHub: {e}")
+            return None
+
+@app.get("/vetra", response_class=HTMLResponse)
+async def serve_vetra():
+    """
+    Serves a dynamic HTML page by fetching HTML, CSS, and JS from GitHub
+    and embedding them into a single HTML response.
+    """
+    html = await get_github_file(FILES["html"])
+    css = await get_github_file(FILES["css"])
+    js = await get_github_file(FILES["js"])
+
+    if not html:
+        raise HTTPException(status_code=404, detail="index.html not found on GitHub")
+
+    final_html = html.replace(
+        "</head>",
+        f"<style>{css or '/* CSS not found */'}</style></head>"
+    ).replace(
+        "</body>",
+        f"<script>{js or '// JS not found'}</script></body>"
+    )
+
+    return HTMLResponse(content=final_html)
+
+@app.get("/searchgpt")
+async def search_gpt(q: str, request: Request, stream: Optional[bool] = False, systemprompt: Optional[str] = None):
+    """
+    Endpoint for search-based AI completion.
+    Records usage and streams results.
+    """
+    if not q:
+        raise HTTPException(status_code=400, detail="Query parameter 'q' is required")
+
+    # Record usage for searchgpt endpoint
+    usage_tracker.record_request(request=request, model="searchgpt", endpoint="/searchgpt")
 
-def generate_usage_html(usage_data: dict) -> str:
-    model_labels = json.dumps(list(usage_data['model_usage'].keys()))
-    model_values = json.dumps(list(usage_data['model_usage'].values()))
-    daily_labels = json.dumps(list(usage_data['daily_usage'].keys()))
-    daily_values = json.dumps([v['requests'] for v in usage_data['daily_usage'].values()])
+    queue = await generate_search_async(q, systemprompt=systemprompt, stream=True)
+
+    if stream:
+        async def stream_generator():
+            """Generator for streaming search results."""
+            collected_text = ""
+            while True:
+                item = await queue.get()
+                if item is None:
+                    break
+
+                if "error" in item:
+                    # Yield error as a data event so client can handle it gracefully
+                    yield f"data: {json.dumps({'error': item['error']})}\n\n"
+                    break
+
+                if "data" in item:
+                    yield item["data"]
+                    collected_text += item.get("text", "")
+
+        return StreamingResponse(
+            stream_generator(),
+            media_type="text/event-stream"
+        )
+    else:
+        # Non-streaming response: collect all chunks and return as JSON
+        collected_text = ""
+        while True:
+            item = await queue.get()
+            if item is None:
+                break
+
+            if "error" in item:
+                raise HTTPException(status_code=500, detail=item["error"])
+
+            collected_text += item.get("text", "")
+
+        return JSONResponse(content={"response": collected_text})
+
+header_url = os.getenv('HEADER_URL') # This variable should be configured in .env
+
+@app.post("/chat/completions")
+@app.post("/api/v1/chat/completions")
+async def get_completion(payload: Payload, request: Request, authenticated: bool = Depends(verify_api_key)):
+    """
+    Proxies chat completion requests to various AI model endpoints based on the model specified in the payload.
+    Records usage and handles streaming responses.
+    """
+    if not server_status:
+        raise HTTPException(
+            status_code=503,
+            detail="Server is under maintenance. Please try again later."
+        )
+
+    model_to_use = payload.model or "gpt-4o-mini" # Default model
+
+    # Validate if the requested model is available
+    if available_model_ids and model_to_use not in set(available_model_ids):
+        raise HTTPException(
+            status_code=400,
+            detail=f"Model '{model_to_use}' is not available. Check /models for the available model list."
+        )
+
+    # Record usage before making the external API call
+    usage_tracker.record_request(request=request, model=model_to_use, endpoint="/chat/completions")
+
+    payload_dict = payload.dict()
+    payload_dict["model"] = model_to_use # Ensure the payload has the resolved model name
+
+    stream_enabled = payload_dict.get("stream", True) # Default to streaming if not specified
+
+    env_vars = get_env_vars()
+
+    endpoint = None
+    custom_headers = {}
+    target_url_path = "/v1/chat/completions" # Default path for OpenAI-like APIs
+
+    # Determine the correct endpoint and headers based on the model
+    if model_to_use in mistral_models:
+        endpoint = env_vars['mistral_api']
+        custom_headers = {
+            "Authorization": f"Bearer {env_vars['mistral_key']}"
+        }
+    elif model_to_use in pollinations_models:
+        endpoint = env_vars['secret_api_endpoint_4']
+        custom_headers = {} # Pollinations.ai might not require auth
+    elif model_to_use in alternate_models:
+        endpoint = env_vars['secret_api_endpoint_2']
+        custom_headers = {}
+    elif model_to_use in claude_3_models:
+        endpoint = env_vars['secret_api_endpoint_5']
+        custom_headers = {} # Assuming no specific auth needed for this proxy
+    elif model_to_use in gemini_models:
+        endpoint = env_vars['secret_api_endpoint_6']
+        if not endpoint:
+             raise HTTPException(status_code=500, detail="Gemini API endpoint (SECRET_API_ENDPOINT_6) not configured.")
+        if not env_vars['gemini_key']:
+             raise HTTPException(status_code=500, detail="GEMINI_KEY not configured for Gemini models.")
+        custom_headers = {
+            "Authorization": f"Bearer {env_vars['gemini_key']}"
+        }
+        target_url_path = "/chat/completions" # Gemini's specific path
+    else:
+        # Default fallback for other models (e.g., OpenAI compatible APIs)
+        endpoint = env_vars['secret_api_endpoint']
+        custom_headers = {
+            "Origin": header_url,
+            "Priority": "u=1, i",
+            "Referer": header_url
+        }
+
+    if not endpoint:
+        raise HTTPException(status_code=500, detail=f"No API endpoint configured for model: {model_to_use}")
+
+    print(f"Proxying request for model '{model_to_use}' to endpoint: {endpoint}{target_url_path}")
+
+    async def real_time_stream_generator():
+        """Generator to stream responses from the upstream API."""
+        try:
+            async with httpx.AsyncClient(timeout=60.0) as client:
+                # Stream the request to the upstream API
+                async with client.stream("POST", f"{endpoint}{target_url_path}", json=payload_dict, headers=custom_headers) as response:
+                    # Handle non-2xx responses from the upstream API
+                    if response.status_code >= 400:
+                        error_messages = {
+                            400: "Bad request. Verify input data.",
+                            401: "Unauthorized. Invalid API key for upstream service.",
+                            403: "Forbidden. You do not have access to this resource on upstream.",
+                            404: "The requested resource was not found on upstream.",
+                            422: "Unprocessable entity. Check your payload for upstream API.",
+                            500: "Internal server error from upstream API."
+                        }
+                        detail_message = error_messages.get(response.status_code, f"Upstream error code: {response.status_code}")
+                        
+                        # Attempt to read upstream error response body for more detail
+                        try:
+                            error_body = await response.aread()
+                            error_json = json.loads(error_body.decode('utf-8'))
+                            if 'error' in error_json and 'message' in error_json['error']:
+                                detail_message += f" - Upstream detail: {error_json['error']['message']}"
+                            elif 'detail' in error_json:
+                                detail_message += f" - Upstream detail: {error_json['detail']}"
+                            else:
+                                detail_message += f" - Upstream raw: {error_body.decode('utf-8')[:200]}..." # Limit for logging
+                        except (json.JSONDecodeError, UnicodeDecodeError):
+                            detail_message += f" - Upstream raw: {error_body.decode('utf-8', errors='ignore')[:200]}..."
+                        
+                        raise HTTPException(status_code=response.status_code, detail=detail_message)
+
+                    # Yield each line from the upstream stream
+                    async for line in response.aiter_lines():
+                        if line:
+                            yield line + "\n"
+        except httpx.TimeoutException:
+            raise HTTPException(status_code=504, detail="Request to upstream AI service timed out.")
+        except httpx.RequestError as e:
+            raise HTTPException(status_code=502, detail=f"Failed to connect to upstream AI service: {str(e)}")
+        except Exception as e:
+            # Re-raise HTTPException if it's already one, otherwise wrap in a 500
+            if isinstance(e, HTTPException):
+                raise e
+            print(f"An unexpected error occurred during chat completion proxy: {e}")
+            raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
+
+    if stream_enabled:
+        return StreamingResponse(
+            real_time_stream_generator(),
+            media_type="text/event-stream",
+            headers={
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no" # Disable buffering for SSE
+            }
+        )
+    else:
+        # For non-streaming requests, collect all parts and return a single JSON response
+        response_content_lines = []
+        async for line in real_time_stream_generator():
+            response_content_lines.append(line)
+        
+        full_response_text = "".join(response_content_lines)
+        
+        # Parse the concatenated stream data. This often involves stripping "data: " prefix
+        # and combining JSON objects from each line.
+        parsed_data = []
+        for line in full_response_text.splitlines():
+            if line.startswith("data: "):
+                try:
+                    parsed_data.append(json.loads(line[6:]))
+                except json.JSONDecodeError:
+                    print(f"Warning: Could not decode JSON line in non-streaming response: {line}")
+        
+        # Attempt to reconstruct a single coherent JSON response
+        # This logic might need refinement based on actual API response format for non-streaming
+        final_json_response = {}
+        if parsed_data:
+            # Example: For OpenAI-like API, you might want the last 'choices' part
+            # This is a simplification and might need adjustment for other APIs
+            if 'choices' in parsed_data[-1]:
+                final_json_response = parsed_data[-1]
+            else:
+                # Fallback: just return the list of parsed objects
+                final_json_response = {"response_parts": parsed_data}
+
+        if not final_json_response:
+            # If nothing was parsed, indicate an issue
+            raise HTTPException(status_code=500, detail="No valid JSON response received from upstream API for non-streaming request.")
+
+        return JSONResponse(content=final_json_response)
+
+@app.post("/images/generations")
+async def create_image(payload: ImageGenerationPayload, request: Request, authenticated: bool = Depends(verify_api_key)):
+    """
+    Proxies image generation requests to a dedicated image generation API.
+    Records usage.
+    """
+    if not server_status:
+        raise HTTPException(
+            status_code=503,
+            detail="Server is under maintenance. Please try again later."
+        )
+
+    if payload.model not in supported_image_models:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Model '{payload.model}' is not supported for image generation. Supported models are: {', '.join(supported_image_models)}"
+        )
+
+    # Record usage for image generation endpoint
+    usage_tracker.record_request(request=request, model=payload.model, endpoint="/images/generations")
+
+    api_payload = {
+        "model": payload.model,
+        "prompt": payload.prompt,
+        "size": payload.size,
+        "n": payload.number # Often 'n' for number of images in APIs
+    }
+
+    target_api_url = get_env_vars().get('new_img') # Get the image API URL from env vars
+    if not target_api_url:
+        raise HTTPException(status_code=500, detail="Image generation API endpoint (NEW_IMG) not configured.")
+
+    try:
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            response = await client.post(target_api_url, json=api_payload)
+
+        response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
+
+        return JSONResponse(content=response.json())
+
+    except httpx.TimeoutException:
+        raise HTTPException(status_code=504, detail="Image generation request timed out.")
+    except httpx.RequestError as e:
+        raise HTTPException(status_code=502, detail=f"Error connecting to image generation service: {e}")
+    except httpx.HTTPStatusError as e:
+        error_detail = e.response.json().get("detail", f"Image generation failed with status code: {e.response.status_code}")
+        raise HTTPException(status_code=e.response.status_code, detail=error_detail)
+    except Exception as e:
+        print(f"An unexpected error occurred during image generation: {e}")
+        raise HTTPException(status_code=500, detail=f"An unexpected error occurred during image generation: {e}")
+
+@app.get("/usage")
+async def get_usage_json(days: int = 7):
+    """
+    Returns the raw usage data as JSON.
+    Can specify the number of days for the summary.
+    """
+    return usage_tracker.get_usage_summary(days)
+
+def generate_usage_html(usage_data: Dict[str, Any]):
+    """
+    Generates an HTML page to display usage statistics.
+    Includes tables for model, API endpoint usage, daily usage, and recent requests.
+    Also includes placeholders for Chart.js to render graphs.
+    """
+    # Prepare data for Chart.js
+    # Model Usage Chart Data
+    model_labels = list(usage_data['model_usage_period'].keys())
+    model_counts = list(usage_data['model_usage_period'].values())
     
-    recent_requests_rows = "".join([
-        f"""<tr>
-            <td>{datetime.datetime.fromisoformat(req['timestamp']).strftime('%Y-%m-%d %H:%M:%S')}</td>
+    # Endpoint Usage Chart Data
+    endpoint_labels = list(usage_data['endpoint_usage_period'].keys())
+    endpoint_counts = list(usage_data['endpoint_usage_period'].values())
+
+    # Daily Usage Chart Data
+    daily_dates = list(usage_data['daily_usage_period'].keys())
+    daily_requests = [data['requests'] for data in usage_data['daily_usage_period'].values()]
+    daily_unique_ips = [data['unique_ips_count'] for data in usage_data['daily_usage_period'].values()]
+
+    # Format table rows for HTML
+    model_usage_all_time_rows = "\n".join([
+        f"""
+        <tr>
+            <td>{model}</td>
+            <td>{stats['total_requests']}</td>
+            <td>{datetime.datetime.fromisoformat(stats['first_used']).strftime("%Y-%m-%d %H:%M")}</td>
+            <td>{datetime.datetime.fromisoformat(stats['last_used']).strftime("%Y-%m-%d %H:%M")}</td>
+        </tr>
+        """ for model, stats in usage_data['all_time_model_usage'].items()
+    ])
+
+    api_usage_all_time_rows = "\n".join([
+        f"""
+        <tr>
+            <td>{endpoint}</td>
+            <td>{stats['total_requests']}</td>
+            <td>{datetime.datetime.fromisoformat(stats['first_used']).strftime("%Y-%m-%d %H:%M")}</td>
+            <td>{datetime.datetime.fromisoformat(stats['last_used']).strftime("%Y-%m-%d %H:%M")}</td>
+        </tr>
+        """ for endpoint, stats in usage_data['all_time_endpoint_usage'].items()
+    ])
+
+    daily_usage_table_rows = "\n".join([
+        f"""
+        <tr>
+            <td>{date}</td>
+            <td>{data['requests']}</td>
+            <td>{data['unique_ips_count']}</td>
+        </tr>
+        """ for date, data in usage_data['daily_usage_period'].items()
+    ])
+
+    recent_requests_rows = "\n".join([
+        f"""
+        <tr>
+            <td>{datetime.datetime.fromisoformat(req['timestamp']).strftime("%Y-%m-%d %H:%M:%S")}</td>
             <td>{req['model']}</td>
             <td>{req['endpoint']}</td>
             <td>{req['ip_address']}</td>
-        </tr>""" for req in usage_data['recent_requests']
+            <td>{req['user_agent']}</td>
+        </tr>
+        """ for req in usage_data['recent_requests']
     ])
 
-    return f"""
+    html_content = f"""
     <!DOCTYPE html>
     <html lang="en">
     <head>
         <meta charset="UTF-8">
         <meta name="viewport" content="width=device-width, initial-scale=1.0">
-        <title>LokiAI - Usage Statistics</title>
-        <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
-        <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap" rel="stylesheet">
+        <title>Lokiai AI - Usage Statistics</title>
+        <link href="[https://fonts.googleapis.com/css2?family=Inter:wght@300;400;600;700&display=swap](https://fonts.googleapis.com/css2?family=Inter:wght@300;400;600;700&display=swap)" rel="stylesheet">
+        <script src="[https://cdn.jsdelivr.net/npm/chart.js](https://cdn.jsdelivr.net/npm/chart.js)"></script>
         <style>
-            body {{ font-family: 'Inter', sans-serif; background-color: #0B0F19; color: #E0E0E0; margin: 0; padding: 20px; }}
-            .container {{ max-width: 1400px; margin: auto; }}
-            h1, h2 {{ color: #FFFFFF; }}
-            .header {{ text-align: center; margin-bottom: 40px; }}
-            .header h1 {{ font-size: 3em; font-weight: 700; }}
-            .stats-grid {{ display: grid; grid-template-columns: repeat(auto-fit, minmax(280px, 1fr)); gap: 20px; margin-bottom: 40px; }}
-            .chart-grid {{ display: grid; grid-template-columns: 1fr 1fr; gap: 20px; margin-bottom: 40px; }}
-            .stat-card, .chart-container, .table-container {{ background: #1A2035; padding: 25px; border-radius: 12px; border: 1px solid #2A3045; }}
-            .stat-card h3 {{ margin-top: 0; color: #8E95A9; font-size: 1em; font-weight: 600; text-transform: uppercase; }}
-            .stat-card .value {{ font-size: 2.5em; font-weight: 700; color: #FFFFFF; }}
-            table {{ width: 100%; border-collapse: collapse; }}
-            th, td {{ padding: 14px; text-align: left; border-bottom: 1px solid #2A3045; }}
-            th {{ background-color: #2A3045; font-weight: 600; }}
-            @media (max-width: 768px) {{ .chart-grid {{ grid-template-columns: 1fr; }} }}
+            :root {{
+                --bg-dark: #0f1011;
+                --bg-darker: #070708;
+                --text-primary: #e6e6e6;
+                --text-secondary: #8c8c8c;
+                --border-color: #2c2c2c;
+                --accent-color: #3a6ee0;
+                --accent-hover: #4a7ef0;
+                --chart-bg-light: rgba(58, 110, 224, 0.2);
+                --chart-border-light: #3a6ee0;
+            }}
+            body {{
+                font-family: 'Inter', sans-serif;
+                background-color: var(--bg-dark);
+                color: var(--text-primary);
+                max-width: 1200px;
+                margin: 0 auto;
+                padding: 40px 20px;
+                line-height: 1.6;
+            }}
+            .logo {{
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                margin-bottom: 30px;
+            }}
+            .logo h1 {{
+                font-weight: 700;
+                font-size: 2.8em;
+                color: var(--text-primary);
+                margin-left: 15px;
+            }}
+            .logo img {{
+                width: 70px;
+                height: 70px;
+                border-radius: 12px;
+                box-shadow: 0 5px 15px rgba(0,0,0,0.2);
+            }}
+            .container {{
+                background-color: var(--bg-darker);
+                border-radius: 16px;
+                padding: 30px;
+                box-shadow: 0 20px 50px rgba(0,0,0,0.4);
+                border: 1px solid var(--border-color);
+            }}
+            h2, h3 {{
+                color: var(--text-primary);
+                border-bottom: 2px solid var(--border-color);
+                padding-bottom: 12px;
+                margin-top: 40px;
+                margin-bottom: 25px;
+                font-weight: 600;
+                font-size: 1.8em;
+            }}
+            .summary-grid {{
+                display: grid;
+                grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+                gap: 20px;
+                margin-bottom: 30px;
+            }}
+            .summary-card {{
+                background-color: var(--bg-dark);
+                border-radius: 10px;
+                padding: 20px;
+                text-align: center;
+                border: 1px solid var(--border-color);
+                box-shadow: 0 8px 20px rgba(0,0,0,0.2);
+                transition: transform 0.2s ease-in-out;
+            }}
+            .summary-card:hover {{
+                transform: translateY(-5px);
+            }}
+            .summary-card h3 {{
+                margin-top: 0;
+                font-size: 1.1em;
+                color: var(--text-secondary);
+                border-bottom: none;
+                padding-bottom: 0;
+                margin-bottom: 10px;
+            }}
+            .summary-card p {{
+                font-size: 2.2em;
+                font-weight: 700;
+                color: var(--accent-color);
+                margin: 0;
+            }}
+            table {{
+                width: 100%;
+                border-collapse: separate;
+                border-spacing: 0;
+                margin-bottom: 40px;
+                background-color: var(--bg-dark);
+                border-radius: 10px;
+                overflow: hidden;
+                box-shadow: 0 8px 20px rgba(0,0,0,0.2);
+            }}
+            th, td {{
+                border: 1px solid var(--border-color);
+                padding: 15px;
+                text-align: left;
+                transition: background-color 0.3s ease;
+            }}
+            th {{
+                background-color: #1a1a1a;
+                color: var(--text-primary);
+                font-weight: 600;
+                text-transform: uppercase;
+                font-size: 0.95em;
+            }}
+            tr:nth-child(even) {{
+                background-color: rgba(255,255,255,0.03);
+            }}
+            tr:hover {{
+                background-color: rgba(62,100,255,0.1);
+            }}
+            .chart-container {{
+                background-color: var(--bg-dark);
+                border-radius: 10px;
+                padding: 20px;
+                margin-bottom: 40px;
+                border: 1px solid var(--border-color);
+                box-shadow: 0 8px 20px rgba(0,0,0,0.2);
+                max-height: 400px; /* Limit chart height */
+                position: relative; /* For responsive canvas */
+            }}
+            canvas {{
+                max-width: 100% !important;
+                height: auto !important;
+            }}
+            @media (max-width: 768px) {{
+                body {{
+                    padding: 20px 10px;
+                }}
+                .container {{
+                    padding: 20px;
+                }}
+                .logo h1 {{
+                    font-size: 2em;
+                }}
+                .summary-card p {{
+                    font-size: 1.8em;
+                }}
+                h2, h3 {{
+                    font-size: 1.5em;
+                }}
+                table {{
+                    font-size: 0.85em;
+                }}
+                th, td {{
+                    padding: 10px;
+                }}
+            }}
         </style>
     </head>
     <body>
         <div class="container">
-            <div class="header"><h1>LokiAI Usage Dashboard</h1></div>
-            <div class="stats-grid">
-                <div class="stat-card"><h3>Total Requests</h3><p class="value">{usage_data['total_requests']}</p></div>
-                <div class="stat-card"><h3>Unique IPs (All Time)</h3><p class="value">{usage_data['unique_ip_count']}</p></div>
-                <div class="stat-card"><h3>Models Used (Last 7 Days)</h3><p class="value">{len(usage_data['model_usage'])}</p></div>
+            <div class="logo">
+                <img src="data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjAwIiBoZWlnaHQ9IjIwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMC9zdmciPjxwYXRoIGQ9Ik0xMDAgMzVMNTAgOTBoMTAwWiIgZmlsbD0iIzNhNmVlMCIvPjxjaXJjbGUgY3g9IjEwMCIgY3k9IjE0MCIgcj0iMzAiIGZpbGw9IiMzYTZlZTAiLz48L3N2Zz4=" alt="Lokiai AI Logo">
+                <h1>Lokiai AI Usage</h1>
             </div>
-            <div class="chart-grid">
-                <div class="chart-container"><canvas id="dailyUsageChart"></canvas></div>
-                <div class="chart-container"><canvas id="modelUsageChart"></canvas></div>
+
+            <div class="summary-grid">
+                <div class="summary-card">
+                    <h3>Total Requests (All Time)</h3>
+                    <p>{usage_data['total_requests']}</p>
+                </div>
+                <div class="summary-card">
+                    <h3>Unique IPs (All Time)</h3>
+                    <p>{usage_data['unique_ips_total_count']}</p>
+                </div>
+                <div class="summary-card">
+                    <h3>Models Used (Last {days} Days)</h3>
+                    <p>{len(usage_data['model_usage_period'])}</p>
+                </div>
+                <div class="summary-card">
+                    <h3>Endpoints Used (Last {days} Days)</h3>
+                    <p>{len(usage_data['endpoint_usage_period'])}</p>
+                </div>
             </div>
-            <div class="table-container">
-                <h2>Recent Requests</h2>
-                <table>
-                    <thead><tr><th>Timestamp (UTC)</th><th>Model</th><th>Endpoint</th><th>IP Address</th></tr></thead>
-                    <tbody>{recent_requests_rows}</tbody>
-                </table>
+
+            <h2>Daily Usage (Last {days} Days)</h2>
+            <div class="chart-container">
+                <canvas id="dailyRequestsChart"></canvas>
+            </div>
+            <table>
+                <thead>
+                    <tr>
+                        <th>Date</th>
+                        <th>Requests</th>
+                        <th>Unique IPs</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {daily_usage_table_rows}
+                </tbody>
+            </table>
+
+            <h2>Model Usage (Last {days} Days)</h2>
+            <div class="chart-container">
+                <canvas id="modelUsageChart"></canvas>
+            </div>
+            <h3>Model Usage (All Time Details)</h3>
+            <table>
+                <thead>
+                    <tr>
+                        <th>Model</th>
+                        <th>Total Requests</th>
+                        <th>First Used</th>
+                        <th>Last Used</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {model_usage_all_time_rows}
+                </tbody>
+            </table>
+
+            <h2>API Endpoint Usage (Last {days} Days)</h2>
+            <div class="chart-container">
+                <canvas id="endpointUsageChart"></canvas>
             </div>
+            <h3>API Endpoint Usage (All Time Details)</h3>
+            <table>
+                <thead>
+                    <tr>
+                        <th>Endpoint</th>
+                        <th>Total Requests</th>
+                        <th>First Used</th>
+                        <th>Last Used</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {api_usage_all_time_rows}
+                </tbody>
+            </table>
+
+            <h2>Recent Requests (Last 20)</h2>
+            <table>
+                <thead>
+                    <tr>
+                        <th>Timestamp</th>
+                        <th>Model</th>
+                        <th>Endpoint</th>
+                        <th>IP Address</th>
+                        <th>User Agent</th>
+                    </tr>
+                </thead>
+                <tbody>
+                    {recent_requests_rows}
+                </tbody>
+            </table>
         </div>
+
         <script>
-            const chartOptions = (ticksColor, gridColor) => ({{
-                plugins: {{ legend: {{ labels: {{ color: ticksColor }} }} }},
-                scales: {{ 
-                    y: {{ ticks: {{ color: ticksColor }}, grid: {{ color: gridColor }} }},
-                    x: {{ ticks: {{ color: ticksColor }}, grid: {{ color: 'transparent' }} }}
+            // Chart.js data and rendering logic
+            const modelLabels = {json.dumps(model_labels)};
+            const modelCounts = {json.dumps(model_counts)};
+            
+            const endpointLabels = {json.dumps(endpoint_labels)};
+            const endpointCounts = {json.dumps(endpoint_counts)};
+
+            const dailyDates = {json.dumps(daily_dates)};
+            const dailyRequests = {json.dumps(daily_requests)};
+            const dailyUniqueIps = {json.dumps(daily_unique_ips)};
+
+            // Model Usage Chart (Bar Chart)
+            new Chart(document.getElementById('modelUsageChart'), {{
+                type: 'bar',
+                data: {{
+                    labels: modelLabels,
+                    datasets: [{{
+                        label: 'Requests',
+                        data: modelCounts,
+                        backgroundColor: 'var(--chart-bg-light)',
+                        borderColor: 'var(--chart-border-light)',
+                        borderWidth: 1,
+                        borderRadius: 5,
+                    }}]
+                }},
+                options: {{
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    plugins: {{
+                        legend: {{
+                            labels: {{
+                                color: 'var(--text-primary)'
+                            }}
+                        }},
+                        title: {{
+                            display: true,
+                            text: 'Model Usage',
+                            color: 'var(--text-primary)'
+                        }}
+                    }},
+                    scales: {{
+                        x: {{
+                            ticks: {{
+                                color: 'var(--text-secondary)'
+                            }},
+                            grid: {{
+                                color: 'var(--border-color)'
+                            }}
+                        }},
+                        y: {{
+                            beginAtZero: true,
+                            ticks: {{
+                                color: 'var(--text-secondary)'
+                            }},
+                            grid: {{
+                                color: 'var(--border-color)'
+                            }}
+                        }}
+                    }}
                 }}
             }});
-            new Chart(document.getElementById('dailyUsageChart'), {{
-                type: 'line',
-                data: {{ labels: {daily_labels}, datasets: [{{ label: 'Requests per Day', data: {daily_values}, borderColor: '#3a6ee0', tension: 0.1, backgroundColor: 'rgba(58, 110, 224, 0.2)', fill: true }}] }},
-                options: chartOptions('#E0E0E0', '#2A3045')
-            }});
-            new Chart(document.getElementById('modelUsageChart'), {{
+
+            // Endpoint Usage Chart (Doughnut Chart)
+            new Chart(document.getElementById('endpointUsageChart'), {{
                 type: 'doughnut',
-                data: {{ labels: {model_labels}, datasets: [{{ label: 'Model Usage', data: {model_values}, backgroundColor: ['#3A6EE0', '#E94F37', '#44AF69', '#F4D35E', '#A06CD5'] }}] }},
-                options: {{ plugins: {{ legend: {{ position: 'right', labels: {{ color: '#E0E0E0' }} }} }} }}
+                data: {{
+                    labels: endpointLabels,
+                    datasets: [{{
+                        label: 'Requests',
+                        data: endpointCounts,
+                        backgroundColor: [
+                            '#3a6ee0', '#5b8bff', '#8dc4ff', '#b3d8ff', '#d0e8ff',
+                            '#FF6384', '#36A2EB', '#FFCE56', '#4BC0C0', '#9966FF'
+                        ],
+                        hoverOffset: 4
+                    }}]
+                }},
+                options: {{
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    plugins: {{
+                        legend: {{
+                            position: 'right',
+                            labels: {{
+                                color: 'var(--text-primary)'
+                            }}
+                        }},
+                        title: {{
+                            display: true,
+                            text: 'API Endpoint Usage',
+                            color: 'var(--text-primary)'
+                        }}
+                    }}
+                }}
+            }});
+
+            // Daily Requests Chart (Line Chart)
+            new Chart(document.getElementById('dailyRequestsChart'), {{
+                type: 'line',
+                data: {{
+                    labels: dailyDates,
+                    datasets: [
+                        {{
+                            label: 'Total Requests',
+                            data: dailyRequests,
+                            borderColor: 'var(--accent-color)',
+                            backgroundColor: 'rgba(58, 110, 224, 0.1)',
+                            fill: true,
+                            tension: 0.3
+                        }},
+                        {{
+                            label: 'Unique IPs',
+                            data: dailyUniqueIps,
+                            borderColor: '#FFCE56', // A distinct color for unique IPs
+                            backgroundColor: 'rgba(255, 206, 86, 0.1)',
+                            fill: true,
+                            tension: 0.3
+                        }}
+                    ]
+                }},
+                options: {{
+                    responsive: true,
+                    maintainAspectRatio: false,
+                    plugins: {{
+                        legend: {{
+                            labels: {{
+                                color: 'var(--text-primary)'
+                            }}
+                        }},
+                        title: {{
+                            display: true,
+                            text: 'Daily Requests and Unique IPs',
+                            color: 'var(--text-primary)'
+                        }}
+                    }},
+                    scales: {{
+                        x: {{
+                            ticks: {{
+                                color: 'var(--text-secondary)'
+                            }},
+                            grid: {{
+                                color: 'var(--border-color)'
+                            }}
+                        }},
+                        y: {{
+                            beginAtZero: true,
+                            ticks: {{
+                                color: 'var(--text-secondary)'
+                            }},
+                            grid: {{
+                                color: 'var(--border-color)'
+                            }}
+                        }}
+                    }}
+                }}
             }});
         </script>
     </body>
     </html>
     """
-''')
+    return html_content
+
+@app.get("/usage/page", response_class=HTMLResponse)
+async def usage_page(days: int = 7):
+    """
+    Serves a detailed HTML page with usage statistics and charts.
+    The 'days' query parameter can be used to specify the reporting period for charts.
+    """
+    usage_data = usage_tracker.get_usage_summary(days=days)
+    html_content = generate_usage_html(usage_data)
+    return HTMLResponse(content=html_content)
+
+@app.get("/meme")
+async def get_meme():
+    """
+    Fetches a random meme from meme-api.com and streams the image content.
+    Handles potential errors during fetching.
+    """
+    try:
+        client = get_async_client()
+        response = await client.get("[https://meme-api.com/gimme](https://meme-api.com/gimme)")
+        response.raise_for_status() # Raise an exception for bad status codes
+        response_data = response.json()
+
+        meme_url = response_data.get("url")
+        if not meme_url:
+            raise HTTPException(status_code=404, detail="No meme URL found in response.")
+
+        # Stream the image content back to the client
+        image_response = await client.get(meme_url, follow_redirects=True)
+        image_response.raise_for_status()
+
+        async def stream_with_larger_chunks():
+            """Streams binary data in larger chunks for efficiency."""
+            chunks = []
+            size = 0
+            # Define a larger chunk size for better streaming performance
+            chunk_size = 65536 # 64 KB
+            async for chunk in image_response.aiter_bytes(chunk_size=chunk_size):
+                chunks.append(chunk)
+                size += len(chunk)
+                if size >= chunk_size * 2: # Send chunks when accumulated size is significant
+                    yield b''.join(chunks)
+                    chunks = []
+                    size = 0
+            if chunks: # Yield any remaining chunks
+                yield b''.join(chunks)
+
+        return StreamingResponse(
+            stream_with_larger_chunks(),
+            media_type=image_response.headers.get("content-type", "image/png"), # Fallback to png
+            headers={'Cache-Control': 'max-age=3600'} # Cache memes for 1 hour
+        )
+    except httpx.HTTPStatusError as e:
+        print(f"Error fetching meme from upstream: {e.response.status_code} - {e.response.text}")
+        raise HTTPException(status_code=e.response.status_code, detail=f"Failed to fetch meme: {e.response.text}")
+    except httpx.RequestError as e:
+        print(f"Request error fetching meme: {e}")
+        raise HTTPException(status_code=502, detail=f"Could not connect to meme service: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred while getting meme: {e}")
+        raise HTTPException(status_code=500, detail="Failed to retrieve meme due to an unexpected error.")
+
+def load_model_ids(json_file_path: str) -> List[str]:
+    """
+    Loads model IDs from a JSON file.
+    This helps in dynamically determining available models.
+    """
+    try:
+        with open(json_file_path, 'r') as f:
+            models_data = json.load(f)
+            return [model['id'] for model in models_data if 'id' in model]
+    except Exception as e:
+        print(f"Error loading model IDs from {json_file_path}: {str(e)}")
+        return []
+
+@app.on_event("startup")
+async def startup_event():
+    """
+    Actions to perform on application startup:
+    - Load available model IDs.
+    - Initialize scraper pool.
+    - Check for missing environment variables and issue warnings.
+    """
+    global available_model_ids
+    # Load models from a local models.json file first
+    available_model_ids = load_model_ids("models.json")
+    print(f"Loaded {len(available_model_ids)} model IDs from models.json")
+
+    # Extend with hardcoded model lists for various providers
+    available_model_ids.extend(list(pollinations_models))
+    available_model_ids.extend(list(alternate_models))
+    available_model_ids.extend(list(mistral_models))
+    available_model_ids.extend(list(claude_3_models))
+    available_model_ids.extend(list(gemini_models)) # Add Gemini models explicitly
+
+    # Remove duplicates and store as a set for faster lookups
+    available_model_ids = list(set(available_model_ids))
+    print(f"Total unique available models after merging: {len(available_model_ids)}")
+
+    # Initialize scraper pool
+    for _ in range(MAX_SCRAPERS):
+        scraper_pool.append(cloudscraper.create_scraper())
+    print(f"Initialized Cloudscraper pool with {MAX_SCRAPERS} instances.")
+
+    # Environment variable check for critical services
+    env_vars = get_env_vars()
+    missing_vars = []
+
+    if not env_vars['api_keys'] or env_vars['api_keys'] == ['']:
+        missing_vars.append('API_KEYS')
+    if not env_vars['secret_api_endpoint']:
+        missing_vars.append('SECRET_API_ENDPOINT')
+    if not env_vars['secret_api_endpoint_2']:
+        missing_vars.append('SECRET_API_ENDPOINT_2')
+    if not env_vars['secret_api_endpoint_3']:
+        missing_vars.append('SECRET_API_ENDPOINT_3')
+    if not env_vars['secret_api_endpoint_4'] and any(model in pollinations_models for model in available_model_ids):
+        missing_vars.append('SECRET_API_ENDPOINT_4 (Pollinations.ai)')
+    if not env_vars['secret_api_endpoint_5'] and any(model in claude_3_models for model in available_model_ids):
+        missing_vars.append('SECRET_API_ENDPOINT_5 (Claude 3.x)')
+    if not env_vars['secret_api_endpoint_6'] and any(model in gemini_models for model in available_model_ids):
+        missing_vars.append('SECRET_API_ENDPOINT_6 (Gemini)')
+    if not env_vars['mistral_api'] and any(model in mistral_models for model in available_model_ids):
+        missing_vars.append('MISTRAL_API')
+    if not env_vars['mistral_key'] and any(model in mistral_models for model in available_model_ids):
+        missing_vars.append('MISTRAL_KEY')
+    if not env_vars['gemini_key'] and any(model in gemini_models for model in available_model_ids):
+        missing_vars.append('GEMINI_KEY')
+    if not env_vars['new_img'] and len(supported_image_models) > 0:
+        missing_vars.append('NEW_IMG (Image Generation)')
+    
+    if missing_vars:
+        print(f"WARNING: The following critical environment variables are missing or empty: {', '.join(missing_vars)}")
+        print("Some server functionality (e.g., specific AI models, image generation) may be limited or unavailable.")
+    else:
+        print("All critical environment variables appear to be configured.")
+
+    print("Server started successfully!")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """
+    Actions to perform on application shutdown:
+    - Close HTTPX client.
+    - Clear scraper pool.
+    - Save usage data to disk.
+    """
+    client = get_async_client()
+    await client.aclose() # Ensure the httpx client connection pool is closed
+    scraper_pool.clear() # Clear the scraper pool
+    usage_tracker.save_data() # Persist usage data on shutdown
+    print("Server shutdown complete!")
+
+@app.get("/health")
+async def health_check():
+    """
+    Provides a health check endpoint, reporting server status and missing critical environment variables.
+    """
+    env_vars = get_env_vars()
+    missing_critical_vars = []
+
+    # Re-check critical environment variables for health status
+    if not env_vars['api_keys'] or env_vars['api_keys'] == ['']:
+        missing_critical_vars.append('API_KEYS')
+    if not env_vars['secret_api_endpoint']:
+        missing_critical_vars.append('SECRET_API_ENDPOINT')
+    if not env_vars['secret_api_endpoint_2']:
+        missing_critical_vars.append('SECRET_API_ENDPOINT_2')
+    if not env_vars['secret_api_endpoint_3']:
+        missing_critical_vars.append('SECRET_API_ENDPOINT_3')
+    # Check for specific service endpoints only if corresponding models are configured/supported
+    if not env_vars['secret_api_endpoint_4'] and any(model in pollinations_models for model in available_model_ids):
+        missing_critical_vars.append('SECRET_API_ENDPOINT_4 (Pollinations.ai)')
+    if not env_vars['secret_api_endpoint_5'] and any(model in claude_3_models for model in available_model_ids):
+        missing_critical_vars.append('SECRET_API_ENDPOINT_5 (Claude 3.x)')
+    if not env_vars['secret_api_endpoint_6'] and any(model in gemini_models for model in available_model_ids):
+        missing_critical_vars.append('SECRET_API_ENDPOINT_6 (Gemini)')
+    if not env_vars['mistral_api'] and any(model in mistral_models for model in available_model_ids):
+        missing_critical_vars.append('MISTRAL_API')
+    if not env_vars['mistral_key'] and any(model in mistral_models for model in available_model_ids):
+        missing_critical_vars.append('MISTRAL_KEY')
+    if not env_vars['gemini_key'] and any(model in gemini_models for model in available_model_ids):
+        missing_critical_vars.append('GEMINI_KEY')
+    if not env_vars['new_img'] and len(supported_image_models) > 0:
+        missing_critical_vars.append('NEW_IMG (Image Generation)')
+
+    health_status = {
+        "status": "healthy" if not missing_critical_vars else "unhealthy",
+        "missing_env_vars": missing_critical_vars,
+        "server_status": server_status, # Reports global server status flag
+        "message": "Everything's lit! 🚀" if not missing_critical_vars else "Uh oh, some env vars are missing. 😬"
+    }
+    return JSONResponse(content=health_status)
 
 if __name__ == "__main__":
+    import uvicorn
+    # When running directly, ensure startup_event is called to load models and check env vars
+    # uvicorn handles startup/shutdown events automatically when run with `uvicorn.run()`
     uvicorn.run(app, host="0.0.0.0", port=7860)