llmapi-tracker 1.0.0__py3-none-any.whl

backend/app/routes/analytics.py

@@ -0,0 +1,91 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy import func
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..models import ApiUsage, Model, Project, Provider
+
+router = APIRouter(prefix="/analytics", tags=["Analytics"])
+
+
+@router.get("/overview")
+def overview(db: Session = Depends(get_db)):
+    rows = db.query(ApiUsage).all()
+    count = len(rows)
+    total_tokens = sum(r.total_tokens for r in rows)
+    total_cost = sum(r.total_cost for r in rows)
+    avg_latency = (sum(r.latency_ms for r in rows) / count) if count else 0
+    error_rate = ((sum(1 for r in rows if r.status != "success") / count) * 100) if count else 0
+    return {
+        "requests": count,
+        "tokens": total_tokens,
+        "cost": total_cost,
+        "average_latency_ms": avg_latency,
+        "error_rate": error_rate,
+    }
+
+
+@router.get("/cost")
+def cost(db: Session = Depends(get_db)):
+    rows = db.query(func.date(ApiUsage.timestamp).label("day"), func.sum(ApiUsage.total_cost)).group_by("day").all()
+    return [{"date": str(day), "cost": cost or 0} for day, cost in rows]
+
+
+@router.get("/tokens")
+def tokens(db: Session = Depends(get_db)):
+    rows = db.query(func.date(ApiUsage.timestamp).label("day"), func.sum(ApiUsage.input_tokens), func.sum(ApiUsage.output_tokens), func.sum(ApiUsage.thinking_tokens), func.sum(ApiUsage.cached_tokens)).group_by("day").all()
+    return [{"date": str(day), "input": i or 0, "output": o or 0, "thinking": t or 0, "cached": c or 0} for day, i, o, t, c in rows]
+
+
+@router.get("/latency")
+def latency(db: Session = Depends(get_db)):
+    rows = [row.latency_ms for row in db.query(ApiUsage).all()]
+    if not rows:
+        return {"average": 0, "p50": 0, "p95": 0, "p99": 0}
+    rows.sort()
+    count = len(rows)
+    return {
+        "average": sum(rows) / count,
+        "p50": rows[int(count * 0.5) - 1 if count > 1 else 0],
+        "p95": rows[int(count * 0.95) - 1 if count > 1 else 0],
+        "p99": rows[int(count * 0.99) - 1 if count > 1 else 0],
+    }
+
+
+@router.get("/errors")
+def errors(db: Session = Depends(get_db)):
+    rows = db.query(ApiUsage.error_type, func.count(ApiUsage.id)).filter(ApiUsage.status != "success").group_by(ApiUsage.error_type).all()
+    return [{"error_type": error_type or "Unknown", "count": count} for error_type, count in rows]
+
+
+@router.get("/by-project")
+def by_project(db: Session = Depends(get_db)):
+    rows = (
+        db.query(Project.name, func.count(ApiUsage.id), func.sum(ApiUsage.total_tokens), func.sum(ApiUsage.total_cost), func.avg(ApiUsage.latency_ms))
+        .join(ApiUsage, ApiUsage.project_id == Project.id)
+        .group_by(Project.name)
+        .all()
+    )
+    return [{"project": name, "requests": req or 0, "tokens": tokens or 0, "cost": cost or 0, "latency_ms": latency or 0} for name, req, tokens, cost, latency in rows]
+
+
+@router.get("/by-provider")
+def by_provider(db: Session = Depends(get_db)):
+    rows = (
+        db.query(Provider.name, func.count(ApiUsage.id), func.sum(ApiUsage.total_tokens), func.sum(ApiUsage.total_cost), func.avg(ApiUsage.latency_ms))
+        .join(ApiUsage, ApiUsage.provider_id == Provider.id)
+        .group_by(Provider.name)
+        .all()
+    )
+    return [{"provider": name, "requests": req or 0, "tokens": tokens or 0, "cost": cost or 0, "latency_ms": latency or 0} for name, req, tokens, cost, latency in rows]
+
+
+@router.get("/by-model")
+def by_model(db: Session = Depends(get_db)):
+    rows = (
+        db.query(Model.model_name, func.count(ApiUsage.id), func.sum(ApiUsage.total_tokens), func.sum(ApiUsage.total_cost), func.avg(ApiUsage.latency_ms))
+        .join(ApiUsage, ApiUsage.model_id == Model.id)
+        .group_by(Model.model_name)
+        .all()
+    )
+    return [{"model": name, "requests": req or 0, "tokens": tokens or 0, "cost": cost or 0, "latency_ms": latency or 0} for name, req, tokens, cost, latency in rows]

backend/app/routes/models.py

@@ -0,0 +1,29 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..models import Model
+from ..schemas import ModelCreate, ModelResponse
+
+router = APIRouter(prefix="/models", tags=["Models"])
+
+
+@router.get("", response_model=list[ModelResponse])
+def list_models(db: Session = Depends(get_db)):
+    return db.query(Model).order_by(Model.created_at.desc()).all()
+
+
+@router.post("", response_model=ModelResponse)
+def create_model(payload: ModelCreate, db: Session = Depends(get_db)):
+    row = (
+        db.query(Model)
+        .filter(Model.provider_id == payload.provider_id, Model.model_name == payload.model_name)
+        .first()
+    )
+    if row:
+        return row
+    row = Model(**payload.model_dump())
+    db.add(row)
+    db.commit()
+    db.refresh(row)
+    return row

backend/app/routes/pricing.py

@@ -0,0 +1,44 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..models import ModelPricing
+from ..schemas import PricingCreate, PricingResponse, PricingUpdate
+
+router = APIRouter(prefix="/pricing", tags=["Pricing"])
+
+
+@router.post("", response_model=PricingResponse)
+def create_pricing(pricing: PricingCreate, db: Session = Depends(get_db)):
+    row = ModelPricing(**pricing.model_dump())
+    db.add(row)
+    db.commit()
+    db.refresh(row)
+    return row
+
+
+@router.get("", response_model=list[PricingResponse])
+def list_pricing(db: Session = Depends(get_db)):
+    return db.query(ModelPricing).order_by(ModelPricing.effective_from.desc()).all()
+
+
+@router.put("/{pricing_id}", response_model=PricingResponse)
+def update_pricing(pricing_id: int, pricing: PricingUpdate, db: Session = Depends(get_db)):
+    row = db.query(ModelPricing).filter(ModelPricing.id == pricing_id).first()
+    if not row:
+        raise HTTPException(status_code=404, detail="Pricing not found")
+    for key, value in pricing.model_dump(exclude_unset=True).items():
+        setattr(row, key, value)
+    db.commit()
+    db.refresh(row)
+    return row
+
+
+@router.delete("/{pricing_id}")
+def delete_pricing(pricing_id: int, db: Session = Depends(get_db)):
+    row = db.query(ModelPricing).filter(ModelPricing.id == pricing_id).first()
+    if not row:
+        raise HTTPException(status_code=404, detail="Pricing not found")
+    db.delete(row)
+    db.commit()
+    return {"success": True}

backend/app/routes/projects.py

@@ -0,0 +1,55 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..models import Project
+from ..schemas import ProjectCreate, ProjectResponse, ProjectUpdate
+
+router = APIRouter(prefix="/projects", tags=["Projects"])
+
+
+@router.post("", response_model=ProjectResponse)
+def create_project(project: ProjectCreate, db: Session = Depends(get_db)):
+    existing = db.query(Project).filter(Project.name == project.name).first()
+    if existing:
+        return existing
+    row = Project(**project.model_dump())
+    db.add(row)
+    db.commit()
+    db.refresh(row)
+    return row
+
+
+@router.get("", response_model=list[ProjectResponse])
+def list_projects(db: Session = Depends(get_db)):
+    return db.query(Project).order_by(Project.created_at.desc()).all()
+
+
+@router.get("/{project_id}", response_model=ProjectResponse)
+def get_project(project_id: int, db: Session = Depends(get_db)):
+    row = db.query(Project).filter(Project.id == project_id).first()
+    if not row:
+        raise HTTPException(status_code=404, detail="Project not found")
+    return row
+
+
+@router.put("/{project_id}", response_model=ProjectResponse)
+def update_project(project_id: int, project: ProjectUpdate, db: Session = Depends(get_db)):
+    row = db.query(Project).filter(Project.id == project_id).first()
+    if not row:
+        raise HTTPException(status_code=404, detail="Project not found")
+    for key, value in project.model_dump(exclude_unset=True).items():
+        setattr(row, key, value)
+    db.commit()
+    db.refresh(row)
+    return row
+
+
+@router.delete("/{project_id}")
+def delete_project(project_id: int, db: Session = Depends(get_db)):
+    row = db.query(Project).filter(Project.id == project_id).first()
+    if not row:
+        raise HTTPException(status_code=404, detail="Project not found")
+    db.delete(row)
+    db.commit()
+    return {"success": True}

backend/app/routes/providers.py

@@ -0,0 +1,25 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..models import Provider
+from ..schemas import ProviderCreate, ProviderResponse
+
+router = APIRouter(prefix="/providers", tags=["Providers"])
+
+
+@router.get("", response_model=list[ProviderResponse])
+def list_providers(db: Session = Depends(get_db)):
+    return db.query(Provider).order_by(Provider.created_at.desc()).all()
+
+
+@router.post("", response_model=ProviderResponse)
+def create_provider(payload: ProviderCreate, db: Session = Depends(get_db)):
+    row = db.query(Provider).filter(Provider.name == payload.name).first()
+    if row:
+        return row
+    row = Provider(name=payload.name)
+    db.add(row)
+    db.commit()
+    db.refresh(row)
+    return row

backend/app/routes/usage.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from ..database import get_db
+from ..models import ApiUsage, Model, Project, Provider
+from ..schemas import UsageDataIn, UsageResponse
+from ..services.usage_service import create_usage
+
+router = APIRouter(prefix="/usage", tags=["Usage"])
+
+
+@router.post("", response_model=UsageResponse)
+def post_usage(payload: UsageDataIn, db: Session = Depends(get_db)):
+    return create_usage(db, payload.model_dump())
+
+
+@router.get("", response_model=list[UsageResponse])
+def list_usage(db: Session = Depends(get_db)):
+    return db.query(ApiUsage).order_by(ApiUsage.timestamp.desc()).limit(1000).all()
+
+
+@router.get("/{usage_id}", response_model=UsageResponse)
+def get_usage(usage_id: int, db: Session = Depends(get_db)):
+    row = db.query(ApiUsage).filter(ApiUsage.id == usage_id).first()
+    if not row:
+        raise HTTPException(status_code=404, detail="Usage not found")
+    return row

backend/app/schemas.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ProjectBase(BaseModel):
+    name: str
+    description: Optional[str] = None
+    environment: str = "development"
+
+
+class ProjectCreate(ProjectBase):
+    pass
+
+
+class ProjectUpdate(BaseModel):
+    name: Optional[str] = None
+    description: Optional[str] = None
+    environment: Optional[str] = None
+
+
+class ProjectResponse(ProjectBase):
+    id: int
+    created_at: datetime
+    model_config = ConfigDict(from_attributes=True)
+
+
+class ProviderCreate(BaseModel):
+    name: str
+
+
+class ProviderResponse(ProviderCreate):
+    id: int
+    created_at: datetime
+    model_config = ConfigDict(from_attributes=True)
+
+
+class ModelCreate(BaseModel):
+    provider_id: int
+    model_name: str
+    model_type: str = "text"
+
+
+class ModelResponse(ModelCreate):
+    id: int
+    created_at: datetime
+    model_config = ConfigDict(from_attributes=True)
+
+
+class PricingCreate(BaseModel):
+    model_id: int
+    input_price_per_1m: float = 0.0
+    output_price_per_1m: float = 0.0
+    thinking_price_per_1m: float = 0.0
+    cached_input_price_per_1m: float = 0.0
+    currency: str = "USD"
+    effective_from: datetime
+    effective_to: Optional[datetime] = None
+
+
+class PricingUpdate(BaseModel):
+    input_price_per_1m: Optional[float] = None
+    output_price_per_1m: Optional[float] = None
+    thinking_price_per_1m: Optional[float] = None
+    cached_input_price_per_1m: Optional[float] = None
+    currency: Optional[str] = None
+    effective_from: Optional[datetime] = None
+    effective_to: Optional[datetime] = None
+
+
+class PricingResponse(PricingCreate):
+    id: int
+    created_at: datetime
+    updated_at: datetime
+    model_config = ConfigDict(from_attributes=True)
+
+
+class UsageDataIn(BaseModel):
+    project: str
+    provider: str
+    model: str
+    internal_request_id: str
+    provider_request_id: Optional[str] = None
+    input_tokens: int = 0
+    output_tokens: int = 0
+    thinking_tokens: int = 0
+    cached_tokens: int = 0
+    total_tokens: int = 0
+    audio_seconds: float = 0.0
+    characters: int = 0
+    request_count: int = 1
+    latency_ms: float = 0.0
+    status: str = "success"
+    http_status_code: Optional[int] = None
+    error_type: Optional[str] = None
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    capture_content: bool = False
+
+
+class UsageResponse(BaseModel):
+    id: int
+    project_id: int
+    provider_id: int
+    model_id: int
+    internal_request_id: str
+    provider_request_id: Optional[str]
+    timestamp: datetime
+    input_tokens: int
+    output_tokens: int
+    thinking_tokens: int
+    cached_tokens: int
+    total_tokens: int
+    input_cost: float
+    output_cost: float
+    thinking_cost: float
+    cached_cost: float
+    total_cost: float
+    audio_seconds: float
+    characters: int
+    request_count: int
+    latency_ms: float
+    status: str
+    http_status_code: Optional[int]
+    error_type: Optional[str]
+    metadata_json: dict[str, Any]
+    capture_content: bool
+    model_config = ConfigDict(from_attributes=True)

backend/app/services/__init__.py

@@ -0,0 +1 @@
+

backend/app/services/cost_service.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class PricingSnapshot:
+    input_price_per_1m: float = 0.0
+    output_price_per_1m: float = 0.0
+    thinking_price_per_1m: float = 0.0
+    cached_input_price_per_1m: float = 0.0
+
+
+def calculate_costs(
+    *,
+    pricing: PricingSnapshot,
+    input_tokens: int = 0,
+    output_tokens: int = 0,
+    thinking_tokens: int = 0,
+    cached_tokens: int = 0,
+) -> dict[str, float]:
+    input_cost = (input_tokens / 1_000_000) * pricing.input_price_per_1m
+    output_cost = (output_tokens / 1_000_000) * pricing.output_price_per_1m
+    thinking_cost = (thinking_tokens / 1_000_000) * pricing.thinking_price_per_1m
+    cached_cost = (cached_tokens / 1_000_000) * pricing.cached_input_price_per_1m
+    total_cost = input_cost + output_cost + thinking_cost + cached_cost
+    return {
+        "input_cost": input_cost,
+        "output_cost": output_cost,
+        "thinking_cost": thinking_cost,
+        "cached_cost": cached_cost,
+        "total_cost": total_cost,
+    }

backend/app/services/usage_service.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from sqlalchemy.orm import Session
+
+from ..models import ApiUsage, Model, ModelPricing, Project, Provider
+from .cost_service import PricingSnapshot, calculate_costs
+
+
+def _get_or_create_project(db: Session, name: str) -> Project:
+    project = db.query(Project).filter(Project.name == name).first()
+    if project:
+        return project
+    project = Project(name=name, environment="development")
+    db.add(project)
+    db.commit()
+    db.refresh(project)
+    return project
+
+
+def _get_or_create_provider(db: Session, name: str) -> Provider:
+    provider = db.query(Provider).filter(Provider.name == name).first()
+    if provider:
+        return provider
+    provider = Provider(name=name)
+    db.add(provider)
+    db.commit()
+    db.refresh(provider)
+    return provider
+
+
+def _get_or_create_model(db: Session, provider_id: int, model_name: str) -> Model:
+    model = (
+        db.query(Model)
+        .filter(Model.provider_id == provider_id, Model.model_name == model_name)
+        .first()
+    )
+    if model:
+        return model
+    model = Model(provider_id=provider_id, model_name=model_name, model_type="text")
+    db.add(model)
+    db.commit()
+    db.refresh(model)
+    return model
+
+
+def get_applicable_pricing(db: Session, model_id: int, timestamp: datetime) -> ModelPricing | None:
+    pricing = (
+        db.query(ModelPricing)
+        .filter(
+            ModelPricing.model_id == model_id,
+            ModelPricing.effective_from <= timestamp,
+            ((ModelPricing.effective_to.is_(None)) | (ModelPricing.effective_to >= timestamp)),
+        )
+        .order_by(ModelPricing.effective_from.desc())
+        .first()
+    )
+    if pricing:
+        return pricing
+    return (
+        db.query(ModelPricing)
+        .filter(ModelPricing.model_id == model_id)
+        .order_by(ModelPricing.effective_from.desc())
+        .first()
+    )
+
+
+def create_usage(db: Session, payload: dict[str, Any]) -> ApiUsage:
+    project = _get_or_create_project(db, payload["project"])
+    provider = _get_or_create_provider(db, payload["provider"])
+    model = _get_or_create_model(db, provider.id, payload["model"])
+    timestamp = payload.get("timestamp") or datetime.utcnow()
+    pricing = get_applicable_pricing(db, model.id, timestamp)
+    snapshot = PricingSnapshot(
+        input_price_per_1m=getattr(pricing, "input_price_per_1m", 0.0),
+        output_price_per_1m=getattr(pricing, "output_price_per_1m", 0.0),
+        thinking_price_per_1m=getattr(pricing, "thinking_price_per_1m", 0.0),
+        cached_input_price_per_1m=getattr(pricing, "cached_input_price_per_1m", 0.0),
+    )
+    costs = calculate_costs(
+        pricing=snapshot,
+        input_tokens=payload.get("input_tokens", 0),
+        output_tokens=payload.get("output_tokens", 0),
+        thinking_tokens=payload.get("thinking_tokens", 0),
+        cached_tokens=payload.get("cached_tokens", 0),
+    )
+    usage = ApiUsage(
+        project_id=project.id,
+        provider_id=provider.id,
+        model_id=model.id,
+        internal_request_id=payload["internal_request_id"],
+        provider_request_id=payload.get("provider_request_id"),
+        timestamp=timestamp,
+        input_tokens=payload.get("input_tokens", 0),
+        output_tokens=payload.get("output_tokens", 0),
+        thinking_tokens=payload.get("thinking_tokens", 0),
+        cached_tokens=payload.get("cached_tokens", 0),
+        total_tokens=payload.get("total_tokens", 0),
+        input_cost=costs["input_cost"],
+        output_cost=costs["output_cost"],
+        thinking_cost=costs["thinking_cost"],
+        cached_cost=costs["cached_cost"],
+        total_cost=costs["total_cost"],
+        audio_seconds=payload.get("audio_seconds", 0.0),
+        characters=payload.get("characters", 0),
+        request_count=payload.get("request_count", 1),
+        latency_ms=payload.get("latency_ms", 0.0),
+        status=payload.get("status", "success"),
+        http_status_code=payload.get("http_status_code"),
+        error_type=payload.get("error_type"),
+        metadata_json=payload.get("metadata", {}),
+        capture_content=payload.get("capture_content", False),
+    )
+    db.add(usage)
+    db.commit()
+    db.refresh(usage)
+    return usage

backend/app/static/assets/index-3YVy8dav.css

@@ -0,0 +1 @@
+*,:before,:after{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }::backdrop{--tw-border-spacing-x: 0;--tw-border-spacing-y: 0;--tw-translate-x: 0;--tw-translate-y: 0;--tw-rotate: 0;--tw-skew-x: 0;--tw-skew-y: 0;--tw-scale-x: 1;--tw-scale-y: 1;--tw-pan-x: ;--tw-pan-y: ;--tw-pinch-zoom: ;--tw-scroll-snap-strictness: proximity;--tw-gradient-from-position: ;--tw-gradient-via-position: ;--tw-gradient-to-position: ;--tw-ordinal: ;--tw-slashed-zero: ;--tw-numeric-figure: ;--tw-numeric-spacing: ;--tw-numeric-fraction: ;--tw-ring-inset: ;--tw-ring-offset-width: 0px;--tw-ring-offset-color: #fff;--tw-ring-color: rgb(59 130 246 / .5);--tw-ring-offset-shadow: 0 0 #0000;--tw-ring-shadow: 0 0 #0000;--tw-shadow: 0 0 #0000;--tw-shadow-colored: 0 0 #0000;--tw-blur: ;--tw-brightness: ;--tw-contrast: ;--tw-grayscale: ;--tw-hue-rotate: ;--tw-invert: ;--tw-saturate: ;--tw-sepia: ;--tw-drop-shadow: ;--tw-backdrop-blur: ;--tw-backdrop-brightness: ;--tw-backdrop-contrast: ;--tw-backdrop-grayscale: ;--tw-backdrop-hue-rotate: ;--tw-backdrop-invert: ;--tw-backdrop-opacity: ;--tw-backdrop-saturate: ;--tw-backdrop-sepia: ;--tw-contain-size: ;--tw-contain-layout: ;--tw-contain-paint: ;--tw-contain-style: }*,:before,:after{box-sizing:border-box;border-width:0;border-style:solid;border-color:#e5e7eb}:before,:after{--tw-content: ""}html,:host{line-height:1.5;-webkit-text-size-adjust:100%;-moz-tab-size:4;-o-tab-size:4;tab-size:4;font-family:ui-sans-serif,system-ui,sans-serif,"Apple Color Emoji","Segoe UI Emoji",Segoe UI Symbol,"Noto Color Emoji";font-feature-settings:normal;font-variation-settings:normal;-webkit-tap-highlight-color:transparent}body{margin:0;line-height:inherit}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-feature-settings:normal;font-variation-settings:normal;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}button,input,optgroup,select,textarea{font-family:inherit;font-feature-settings:inherit;font-variation-settings:inherit;font-size:100%;font-weight:inherit;line-height:inherit;letter-spacing:inherit;color:inherit;margin:0;padding:0}button,select{text-transform:none}button,input:where([type=button]),input:where([type=reset]),input:where([type=submit]){-webkit-appearance:button;background-color:transparent;background-image:none}:-moz-focusring{outline:auto}:-moz-ui-invalid{box-shadow:none}progress{vertical-align:baseline}::-webkit-inner-spin-button,::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}blockquote,dl,dd,h1,h2,h3,h4,h5,h6,hr,figure,p,pre{margin:0}fieldset{margin:0;padding:0}legend{padding:0}ol,ul,menu{list-style:none;margin:0;padding:0}dialog{padding:0}textarea{resize:vertical}input::-moz-placeholder,textarea::-moz-placeholder{opacity:1;color:#9ca3af}input::placeholder,textarea::placeholder{opacity:1;color:#9ca3af}button,[role=button]{cursor:pointer}:disabled{cursor:default}img,svg,video,canvas,audio,iframe,embed,object{display:block;vertical-align:middle}img,video{max-width:100%;height:auto}[hidden]:where(:not([hidden=until-found])){display:none}.collapse{visibility:collapse}.fixed{position:fixed}.flex{display:flex}.table{display:table}.grid{display:grid}.hidden{display:none}.border{border-width:1px}.blur{--tw-blur: blur(8px);filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}.filter{filter:var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow)}:root{color-scheme:dark;font-family:Inter,ui-sans-serif,system-ui,sans-serif;background:#0b1020;color:#e5eefb}html,body,#root{height:100%;margin:0}body{background:radial-gradient(circle at top left,rgba(96,165,250,.18),transparent 28%),linear-gradient(180deg,#0b1020,#0f172a)}.app{display:grid;grid-template-columns:260px 1fr;min-height:100vh}.sidebar{padding:24px;background:#0f172aeb;border-right:1px solid rgba(148,163,184,.16)}.brand{font-size:20px;font-weight:700;margin-bottom:24px}.sidebar a{display:block;padding:10px 12px;border-radius:10px;color:#bfd0f1;text-decoration:none;margin-bottom:6px}.sidebar a.active{background:#60a5fa29;color:#fff}.content{padding:28px}.page{background:#111827b8;border:1px solid rgba(148,163,184,.16);border-radius:20px;padding:28px}