feat: fallback to remote dashboard if not selfhosted

- Moves UI serving logic to `routstr/core/ui.py`.
- Implements a fallback mechanism: if the local UI build is missing (specifically index.html), it acts as a reverse proxy to a configured `fallback_ui_url` (default: https://api.routstr.com).
- Adds `FALLBACK_UI_URL` environment variable support.
- Ensures the application remains usable even without a local UI build.

.github/workflows/test.yml

@@ -59,30 +59,25 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 10
-
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
           node-version: "18"
-          cache: "pnpm"
-          cache-dependency-path: ui/pnpm-lock.yaml
+          cache: "npm"
+          cache-dependency-path: ui/package-lock.json
 
       - name: Install UI dependencies
         working-directory: ./ui
-        run: pnpm install --frozen-lockfile
+        run: npm ci
 
       - name: Run UI format check
         working-directory: ./ui
-        run: pnpm run format-check
+        run: npm run format-check
 
       - name: Run UI linting
         working-directory: ./ui
-        run: pnpm run lint
+        run: npm run lint
 
       - name: Run UI build
         working-directory: ./ui
-        run: pnpm run build
+        run: npm run build

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "routstr"
-version = "0.2.2"
+version = "0.2.1"
 description = "Payment proxy for your LLM endpoint using cashu and nostr."
 readme = "README.md"
 requires-python = ">=3.11"

routstr/auth.py

@@ -441,29 +441,6 @@ async def adjust_payment_for_tokens(
         },
     )
 
-    async def release_reservation_only() -> None:
-        """Fallback to release reservation without charging when main update fails."""
-        try:
-            release_stmt = (
-                update(ApiKey)
-                .where(col(ApiKey.hashed_key) == key.hashed_key)
-                .values(reserved_balance=col(ApiKey.reserved_balance) - deducted_max_cost)
-            )
-            await session.exec(release_stmt)  # type: ignore[call-overload]
-            await session.commit()
-            logger.warning(
-                "Released reservation without charging (fallback)",
-                extra={
-                    "key_hash": key.hashed_key[:8] + "...",
-                    "deducted_max_cost": deducted_max_cost,
-                },
-            )
-        except Exception as e:
-            logger.error(
-                "Failed to release reservation in fallback",
-                extra={"error": str(e), "key_hash": key.hashed_key[:8] + "..."},
-            )
-
     match await calculate_cost(response_data, deducted_max_cost, session):
         case MaxCostData() as cost:
             logger.debug(
@@ -488,7 +465,7 @@ async def adjust_payment_for_tokens(
             await session.commit()
             if result.rowcount == 0:
                 logger.error(
-                    "Failed to finalize max-cost payment - retrying reservation release",
+                    "Failed to finalize max-cost payment - insufficient reserved balance",
                     extra={
                         "key_hash": key.hashed_key[:8] + "...",
                         "deducted_max_cost": deducted_max_cost,
@@ -497,7 +474,6 @@ async def adjust_payment_for_tokens(
                         "model": model,
                     },
                 )
-                await release_reservation_only()
             else:
                 await session.refresh(key)
                 logger.info(
@@ -592,14 +568,13 @@ async def adjust_payment_for_tokens(
                     )
                 else:
                     logger.warning(
-                        "Failed to finalize additional charge - releasing reservation",
+                        "Failed to finalize additional charge (concurrent operation)",
                         extra={
                             "key_hash": key.hashed_key[:8] + "...",
                             "attempted_charge": total_cost_msats,
                             "model": model,
                         },
                     )
-                    await release_reservation_only()
             else:
                 # Refund some of the base cost
                 refund = abs(cost_difference)
@@ -628,7 +603,7 @@ async def adjust_payment_for_tokens(
 
                 if result.rowcount == 0:
                     logger.error(
-                        "Failed to finalize payment - releasing reservation",
+                        "Failed to finalize payment - insufficient reserved balance",
                         extra={
                             "key_hash": key.hashed_key[:8] + "...",
                             "deducted_max_cost": deducted_max_cost,
@@ -637,27 +612,28 @@ async def adjust_payment_for_tokens(
                             "model": model,
                         },
                     )
-                    await release_reservation_only()
-                else:
-                    cost.total_msats = total_cost_msats
-                    await session.refresh(key)
+                    # Still return the cost data even if we couldn't properly finalize
+                    # The reservation was already made, so the user has paid
 
-                    logger.info(
-                        "Refund processed successfully",
-                        extra={
-                            "key_hash": key.hashed_key[:8] + "...",
-                            "refunded_amount": refund,
-                            "new_balance": key.balance,
-                            "final_cost": cost.total_msats,
-                            "model": model,
-                        },
-                    )
+                cost.total_msats = total_cost_msats
+                await session.refresh(key)
+
+                logger.info(
+                    "Refund processed successfully",
+                    extra={
+                        "key_hash": key.hashed_key[:8] + "...",
+                        "refunded_amount": refund,
+                        "new_balance": key.balance,
+                        "final_cost": cost.total_msats,
+                        "model": model,
+                    },
+                )
 
             return cost.dict()
 
         case CostDataError() as error:
             logger.error(
-                "Cost calculation error during payment adjustment - releasing reservation",
+                "Cost calculation error during payment adjustment",
                 extra={
                     "key_hash": key.hashed_key[:8] + "...",
                     "model": model,
@@ -665,7 +641,6 @@ async def adjust_payment_for_tokens(
                     "error_code": error.code,
                 },
             )
-            await release_reservation_only()
 
             raise HTTPException(
                 status_code=400,
@@ -677,12 +652,7 @@ async def adjust_payment_for_tokens(
                     }
                 },
             )
-    # Fallback: should not reach here, but release reservation just in case
-    logger.error(
-        "Unexpected fallback in adjust_payment_for_tokens - releasing reservation",
-        extra={"key_hash": key.hashed_key[:8] + "...", "model": model},
-    )
-    await release_reservation_only()
+    # Fallback return to satisfy type checker; execution should not reach here
     return {
         "base_msats": deducted_max_cost,
         "input_msats": 0,

routstr/balance.py

@@ -154,8 +154,7 @@ async def refund_wallet_endpoint(
         return cached
 
     key: ApiKey = await validate_bearer_key(bearer_value, session)
-
-    remaining_balance_msats: int = key.total_balance
+    remaining_balance_msats: int = key.balance
 
     if key.refund_currency == "sat":
         remaining_balance = remaining_balance_msats // 1000

routstr/core/admin.py

@@ -3080,9 +3080,6 @@ async def get_logs_api(
     level: str | None = None,
     request_id: str | None = None,
     search: str | None = None,
-    status_codes: str | None = Query(None, description="Comma-separated status codes"),
-    methods: str | None = Query(None, description="Comma-separated HTTP methods"),
-    endpoints: str | None = Query(None, description="Comma-separated endpoints"),
     limit: int = 100,
 ) -> dict[str, object]:
     """
@@ -3093,32 +3090,16 @@ async def get_logs_api(
         level: Filter by log level
         request_id: Filter by request ID
         search: Search text in message and name fields (case-insensitive)
-        status_codes: Comma-separated list of HTTP status codes
-        methods: Comma-separated list of HTTP methods
-        endpoints: Comma-separated list of endpoints
         limit: Maximum number of entries to return
 
     Returns:
         Dict containing logs and filter metadata
     """
-    status_code_list = None
-    if status_codes:
-        try:
-            status_code_list = [int(s.strip()) for s in status_codes.split(",")]
-        except ValueError:
-            pass
-
-    method_list = [m.strip() for m in methods.split(",")] if methods else None
-    endpoint_list = [e.strip() for e in endpoints.split(",")] if endpoints else None
-
     log_entries = log_manager.search_logs(
         date=date,
         level=level,
         request_id=request_id,
         search_text=search,
-        status_codes=status_code_list,
-        methods=method_list,
-        endpoints=endpoint_list,
         limit=limit,
     )
 
@@ -3129,9 +3110,6 @@ async def get_logs_api(
         "level": level,
         "request_id": request_id,
         "search": search,
-        "status_codes": status_codes,
-        "methods": methods,
-        "endpoints": endpoints,
         "limit": limit,
     }
 

routstr/core/db.py

@@ -6,7 +6,7 @@ from typing import AsyncGenerator
 from alembic import command
 from alembic.config import Config
 from sqlalchemy.ext.asyncio.engine import create_async_engine
-from sqlmodel import Field, Relationship, SQLModel, func, select, update
+from sqlmodel import Field, Relationship, SQLModel, func, select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
 from .logging import get_logger
@@ -53,14 +53,6 @@ class ApiKey(SQLModel, table=True):  # type: ignore
         return self.balance - self.reserved_balance
 
 
-async def reset_all_reserved_balances(session: AsyncSession) -> None:
-    logger.info("Resetting all reserved balances to 0")
-    stmt = update(ApiKey).values(reserved_balance=0)
-    await session.exec(stmt)  # type: ignore[call-overload]
-    await session.commit()
-    logger.info("Reserved balances reset successfully")
-
-
 class ModelRow(SQLModel, table=True):  # type: ignore
     __tablename__ = "models"
     id: str = Field(primary_key=True)

routstr/core/log_manager.py

@@ -105,9 +105,6 @@ class LogManager:
         level: str | None = None,
         request_id: str | None = None,
         search_text: str | None = None,
-        status_codes: list[int] | None = None,
-        methods: list[str] | None = None,
-        endpoints: list[str] | None = None,
         limit: int = 100,
     ) -> list[dict[str, Any]]:
         """
@@ -137,13 +134,7 @@ class LogManager:
 
         for log_data in iterator:
             if not self._matches_filters(
-                log_data,
-                level,
-                request_id,
-                search_text_lower,
-                status_codes,
-                methods,
-                endpoints,
+                log_data, level, request_id, search_text_lower
             ):
                 continue
 
@@ -162,9 +153,6 @@ class LogManager:
         level: str | None,
         request_id: str | None,
         search_text_lower: str | None,
-        status_codes: list[int] | None = None,
-        methods: list[str] | None = None,
-        endpoints: list[str] | None = None,
     ) -> bool:
         if level and log_data.get("levelname", "").upper() != level.upper():
             return False
@@ -172,36 +160,6 @@ class LogManager:
         if request_id and log_data.get("request_id") != request_id:
             return False
 
-        if status_codes:
-            entry_status = log_data.get("status_code")
-            if entry_status is not None:
-                try:
-                    if int(entry_status) not in status_codes:
-                        return False
-                except (ValueError, TypeError):
-                    return False
-            else:
-                return False
-
-        if methods:
-            entry_method = log_data.get("method", "").upper()
-            if entry_method not in [m.upper() for m in methods]:
-                return False
-
-        if endpoints:
-            entry_path = log_data.get("path", "")
-            matched = False
-            for endpoint in endpoints:
-                clean_endpoint = endpoint.lstrip("/")
-                if entry_path.startswith(clean_endpoint):
-                    matched = True
-                    break
-                if clean_endpoint in entry_path:
-                    matched = True
-                    break
-            if not matched:
-                return False
-
         if search_text_lower:
             message = str(log_data.get("message", "")).lower()
             name = str(log_data.get("name", "")).lower()

routstr/core/main.py

@@ -1,13 +1,11 @@
 import asyncio
 import os
 from contextlib import asynccontextmanager
-from pathlib import Path
 from typing import AsyncGenerator
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse, RedirectResponse
-from fastapi.staticfiles import StaticFiles
+from fastapi.responses import RedirectResponse
 from starlette.exceptions import HTTPException
 
 from ..balance import balance_router, deprecated_wallet_router
@@ -27,15 +25,16 @@ from .logging import get_logger, setup_logging
 from .middleware import LoggingMiddleware
 from .settings import SettingsService
 from .settings import settings as global_settings
+from .ui import setup_ui
 
 # Initialize logging first
 setup_logging()
 logger = get_logger(__name__)
 
 if os.getenv("VERSION_SUFFIX") is not None:
-    __version__ = f"0.2.2-{os.getenv('VERSION_SUFFIX')}"
+    __version__ = f"0.2.1-{os.getenv('VERSION_SUFFIX')}"
 else:
-    __version__ = "0.2.2"
+    __version__ = "0.2.1"
 
 
 @asynccontextmanager
@@ -61,10 +60,6 @@ async def lifespan(_: FastAPI) -> AsyncGenerator[None, None]:
         # Initialize application settings (env -> computed -> DB precedence)
         async with create_session() as session:
             s = await SettingsService.initialize(session)
-            if s.reset_reserved_balance_on_startup:
-                from .db import reset_all_reserved_balances
-
-                await reset_all_reserved_balances(session)
 
         # Apply app metadata from settings
         try:
@@ -194,143 +189,8 @@ async def providers() -> RedirectResponse:
     return RedirectResponse("/v1/providers/")
 
 
-UI_DIST_PATH = Path(__file__).parent.parent.parent / "ui_out"
-
-if UI_DIST_PATH.exists() and UI_DIST_PATH.is_dir():
-    logger.info(f"Serving static UI from {UI_DIST_PATH}")
-
-    app.mount(
-        "/_next",
-        StaticFiles(directory=UI_DIST_PATH / "_next", check_dir=True),
-        name="next-static",
-    )
-
-    @app.get("/", include_in_schema=False)
-    async def serve_root_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "index.html")
-
-    # Add explicit route for /index.txt to redirect to /
-    @app.get("/index.txt", include_in_schema=False)
-    async def redirect_index_txt() -> RedirectResponse:
-        return RedirectResponse("/")
-
-    @app.get("/admin")
-    async def admin_redirect() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "index.html")
-
-    @app.get("/dashboard", include_in_schema=False)
-    async def serve_dashboard_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "index.html")
-
-    @app.get("/login", include_in_schema=False)
-    async def serve_login_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "login" / "index.html")
-
-    # Add explicit route for /login/index.txt to redirect to /login
-    @app.get("/login/index.txt", include_in_schema=False)
-    async def redirect_login_index_txt() -> RedirectResponse:
-        return RedirectResponse("/login")
-
-    @app.get("/model", include_in_schema=False)
-    async def serve_models_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "model" / "index.html")
-
-    # Add explicit route for /model/index.txt to redirect to /model
-    @app.get("/model/index.txt", include_in_schema=False)
-    async def redirect_model_index_txt() -> RedirectResponse:
-        return RedirectResponse("/model")
-
-    @app.get("/providers", include_in_schema=False)
-    async def serve_providers_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "providers" / "index.html")
-
-    # Add explicit route for /providers/index.txt to redirect to /providers
-    @app.get("/providers/index.txt", include_in_schema=False)
-    async def redirect_providers_index_txt() -> RedirectResponse:
-        return RedirectResponse("/providers")
-
-    @app.get("/settings", include_in_schema=False)
-    async def serve_settings_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "settings" / "index.html")
-
-    # Add explicit route for /settings/index.txt to redirect to /settings
-    @app.get("/settings/index.txt", include_in_schema=False)
-    async def redirect_settings_index_txt() -> RedirectResponse:
-        return RedirectResponse("/settings")
-
-    @app.get("/transactions", include_in_schema=False)
-    async def serve_transactions_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "transactions" / "index.html")
-
-    # Add explicit route for /transactions/index.txt to redirect to /transactions
-    @app.get("/transactions/index.txt", include_in_schema=False)
-    async def redirect_transactions_index_txt() -> RedirectResponse:
-        return RedirectResponse("/transactions")
-
-    @app.get("/balances", include_in_schema=False)
-    async def serve_balances_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "balances" / "index.html")
-
-    # Add explicit route for /balances/index.txt to redirect to /balances
-    @app.get("/balances/index.txt", include_in_schema=False)
-    async def redirect_balances_index_txt() -> RedirectResponse:
-        return RedirectResponse("/balances")
-
-    @app.get("/logs", include_in_schema=False)
-    async def serve_logs_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "logs" / "index.html")
-
-    # Add explicit route for /logs/index.txt to redirect to /logs
-    @app.get("/logs/index.txt", include_in_schema=False)
-    async def redirect_logs_index_txt() -> RedirectResponse:
-        return RedirectResponse("/logs")
-
-    @app.get("/usage", include_in_schema=False)
-    async def serve_usage_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "usage" / "index.html")
-
-    # Add explicit route for /usage/index.txt to redirect to /usage
-    @app.get("/usage/index.txt", include_in_schema=False)
-    async def redirect_usage_index_txt() -> RedirectResponse:
-        return RedirectResponse("/usage")
-
-    @app.get("/unauthorized", include_in_schema=False)
-    async def serve_unauthorized_ui() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "unauthorized" / "index.html")
-
-    # Add explicit route for /unauthorized/index.txt to redirect to /unauthorized
-    @app.get("/unauthorized/index.txt", include_in_schema=False)
-    async def redirect_unauthorized_index_txt() -> RedirectResponse:
-        return RedirectResponse("/unauthorized")
-
-    @app.get("/favicon.ico", include_in_schema=False)
-    async def serve_favicon() -> FileResponse:
-        icon_path = UI_DIST_PATH / "icon.ico"
-        if icon_path.exists():
-            return FileResponse(icon_path)
-        return FileResponse(UI_DIST_PATH / "favicon.ico")
-
-    @app.get("/icon.ico", include_in_schema=False)
-    async def serve_icon() -> FileResponse:
-        return FileResponse(UI_DIST_PATH / "icon.ico")
-
-    app.mount(
-        "/static", StaticFiles(directory=UI_DIST_PATH, check_dir=True), name="ui-static"
-    )
-else:
-    logger.warning(
-        f"UI dist directory not found at {UI_DIST_PATH}, skipping static file serving"
-    )
-
-    @app.get("/", include_in_schema=False)
-    async def root_fallback() -> dict:
-        return {
-            "name": global_settings.name,
-            "description": global_settings.description,
-            "version": __version__,
-            "status": "running",
-            "ui": "not available",
-        }
+# Setup UI routes (local serving or proxy fallback)
+setup_ui(app, __version__)
 
 
 app.include_router(models_router)

routstr/core/settings.py

@@ -6,7 +6,7 @@ import os
 from datetime import datetime, timezone
 from typing import Any
 
-from pydantic.v1 import BaseModel, BaseSettings, Field, validator
+from pydantic.v1 import BaseModel, BaseSettings, Field
 from sqlmodel.ext.asyncio.session import AsyncSession
 
 
@@ -37,13 +37,6 @@ class Settings(BaseSettings):
 
     # Cashu
     cashu_mints: list[str] = Field(default_factory=list, env="CASHU_MINTS")
-
-    @validator("cashu_mints", pre=True, each_item=True)
-    def normalize_mint_url(cls, v: str) -> str:
-        if isinstance(v, str):
-            return v.rstrip("/")
-        return v
-
     receive_ln_address: str = Field(default="", env="RECEIVE_LN_ADDRESS")
     primary_mint: str = Field(default="", env="PRIMARY_MINT_URL")
     primary_mint_unit: str = Field(default="sat", env="PRIMARY_MINT_UNIT")
@@ -61,9 +54,6 @@ class Settings(BaseSettings):
     tolerance_percentage: float = Field(default=1.0, env="TOLERANCE_PERCENTAGE")
     # Minimum per-request charge in millisatoshis when model pricing is free/zero
     min_request_msat: int = Field(default=1, env="MIN_REQUEST_MSAT")
-    reset_reserved_balance_on_startup: bool = Field(
-        default=True, env="RESET_RESERVED_BALANCE_ON_STARTUP"
-    )  # deactivate in horizontal scaling setups
 
     # Network
     cors_origins: list[str] = Field(default_factory=lambda: ["*"], env="CORS_ORIGINS")
@@ -99,6 +89,9 @@ class Settings(BaseSettings):
     # Discovery
     relays: list[str] = Field(default_factory=list, env="RELAYS")
 
+    # Cloud UI
+    fallback_ui_url: str = Field(default="https://api.routstr.com", env="FALLBACK_UI_URL")
+
 
 def _compute_primary_mint(cashu_mints: list[str]) -> str:
     return cashu_mints[0] if cashu_mints else "https://mint.minibits.cash/Bitcoin"

routstr/core/ui.py

@@ -0,0 +1,252 @@
+from pathlib import Path
+from typing import Any
+
+import httpx
+from fastapi import FastAPI, Request
+from fastapi.responses import FileResponse, RedirectResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+
+from .logging import get_logger
+from .settings import settings as global_settings
+
+logger = get_logger(__name__)
+
+
+def setup_ui(app: FastAPI, version: str) -> None:
+    UI_DIST_PATH = Path(__file__).parent.parent.parent / "ui_out"
+
+    # Check if we have a valid local UI build
+    # We require at least the index.html to be present because the directory might exist
+    # but be empty (e.g. Docker volume mount before build completes)
+    has_local_ui = (
+        UI_DIST_PATH.exists()
+        and UI_DIST_PATH.is_dir()
+        and (UI_DIST_PATH / "index.html").exists()
+    )
+
+    if has_local_ui:
+        logger.info(f"Serving static UI from {UI_DIST_PATH}")
+
+        app.mount(
+            "/_next",
+            StaticFiles(directory=UI_DIST_PATH / "_next", check_dir=True),
+            name="next-static",
+        )
+
+        @app.get("/", include_in_schema=False)
+        async def serve_root_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "index.html")
+
+        # Add explicit route for /index.txt to redirect to /
+        @app.get("/index.txt", include_in_schema=False)
+        async def redirect_index_txt() -> RedirectResponse:
+            return RedirectResponse("/")
+
+        @app.get("/admin", include_in_schema=False)
+        async def admin_redirect() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "index.html")
+
+        @app.get("/dashboard", include_in_schema=False)
+        async def serve_dashboard_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "index.html")
+
+        @app.get("/login", include_in_schema=False)
+        async def serve_login_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "login" / "index.html")
+
+        # Add explicit route for /login/index.txt to redirect to /login
+        @app.get("/login/index.txt", include_in_schema=False)
+        async def redirect_login_index_txt() -> RedirectResponse:
+            return RedirectResponse("/login")
+
+        @app.get("/model", include_in_schema=False)
+        async def serve_models_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "model" / "index.html")
+
+        # Add explicit route for /model/index.txt to redirect to /model
+        @app.get("/model/index.txt", include_in_schema=False)
+        async def redirect_model_index_txt() -> RedirectResponse:
+            return RedirectResponse("/model")
+
+        @app.get("/providers", include_in_schema=False)
+        async def serve_providers_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "providers" / "index.html")
+
+        # Add explicit route for /providers/index.txt to redirect to /providers
+        @app.get("/providers/index.txt", include_in_schema=False)
+        async def redirect_providers_index_txt() -> RedirectResponse:
+            return RedirectResponse("/providers")
+
+        @app.get("/settings", include_in_schema=False)
+        async def serve_settings_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "settings" / "index.html")
+
+        # Add explicit route for /settings/index.txt to redirect to /settings
+        @app.get("/settings/index.txt", include_in_schema=False)
+        async def redirect_settings_index_txt() -> RedirectResponse:
+            return RedirectResponse("/settings")
+
+        @app.get("/transactions", include_in_schema=False)
+        async def serve_transactions_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "transactions" / "index.html")
+
+        # Add explicit route for /transactions/index.txt to redirect to /transactions
+        @app.get("/transactions/index.txt", include_in_schema=False)
+        async def redirect_transactions_index_txt() -> RedirectResponse:
+            return RedirectResponse("/transactions")
+
+        @app.get("/balances", include_in_schema=False)
+        async def serve_balances_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "balances" / "index.html")
+
+        # Add explicit route for /balances/index.txt to redirect to /balances
+        @app.get("/balances/index.txt", include_in_schema=False)
+        async def redirect_balances_index_txt() -> RedirectResponse:
+            return RedirectResponse("/balances")
+
+        @app.get("/logs", include_in_schema=False)
+        async def serve_logs_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "logs" / "index.html")
+
+        # Add explicit route for /logs/index.txt to redirect to /logs
+        @app.get("/logs/index.txt", include_in_schema=False)
+        async def redirect_logs_index_txt() -> RedirectResponse:
+            return RedirectResponse("/logs")
+
+        @app.get("/usage", include_in_schema=False)
+        async def serve_usage_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "usage" / "index.html")
+
+        # Add explicit route for /usage/index.txt to redirect to /usage
+        @app.get("/usage/index.txt", include_in_schema=False)
+        async def redirect_usage_index_txt() -> RedirectResponse:
+            return RedirectResponse("/usage")
+
+        @app.get("/unauthorized", include_in_schema=False)
+        async def serve_unauthorized_ui() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "unauthorized" / "index.html")
+
+        # Add explicit route for /unauthorized/index.txt to redirect to /unauthorized
+        @app.get("/unauthorized/index.txt", include_in_schema=False)
+        async def redirect_unauthorized_index_txt() -> RedirectResponse:
+            return RedirectResponse("/unauthorized")
+
+        @app.get("/favicon.ico", include_in_schema=False)
+        async def serve_favicon() -> FileResponse:
+            icon_path = UI_DIST_PATH / "icon.ico"
+            if icon_path.exists():
+                return FileResponse(icon_path)
+            return FileResponse(UI_DIST_PATH / "favicon.ico")
+
+        @app.get("/icon.ico", include_in_schema=False)
+        async def serve_icon() -> FileResponse:
+            return FileResponse(UI_DIST_PATH / "icon.ico")
+
+        app.mount(
+            "/static",
+            StaticFiles(directory=UI_DIST_PATH, check_dir=True),
+            name="ui-static",
+        )
+    else:
+        logger.info(
+            f"Local UI not found at {UI_DIST_PATH} (checked for index.html), falling back to cloud/proxy"
+        )
+        if global_settings.fallback_ui_url:
+            logger.info(f"Proxying UI to {global_settings.fallback_ui_url}")
+
+            async def _proxy_ui_request(request: Request, path: str = "") -> Any:
+                # Clean up the target URL
+                base_url = global_settings.fallback_ui_url.rstrip("/")
+                target_url = f"{base_url}/{path.lstrip('/')}"
+
+                headers = dict(request.headers)
+                headers.pop("host", None)
+                headers.pop("content-length", None)
+
+                client = httpx.AsyncClient()
+                try:
+                    rp_req = client.build_request("GET", target_url, headers=headers)
+                    rp_resp = await client.send(rp_req, stream=True)
+
+                    async def stream_response() -> Any:
+                        try:
+                            async for chunk in rp_resp.aiter_raw():
+                                yield chunk
+                        finally:
+                            await rp_resp.aclose()
+                            await client.aclose()
+
+                    response_headers = dict(rp_resp.headers)
+                    # Filter out hop-by-hop headers and others that shouldn't be proxied directly
+                    for key in [
+                        "transfer-encoding",
+                        "connection",
+                        "keep-alive",
+                        "host",
+                    ]:
+                        response_headers.pop(key, None)
+
+                    return StreamingResponse(
+                        stream_response(),
+                        status_code=rp_resp.status_code,
+                        headers=response_headers,
+                    )
+                except Exception as e:
+                    await client.aclose()
+                    logger.error(f"Failed to proxy UI request to {target_url}: {e}")
+                    return {"error": "UI Proxy Error", "details": str(e)}
+
+            @app.get("/", include_in_schema=False)
+            async def proxy_root_ui(request: Request) -> Any:
+                return await _proxy_ui_request(request, "")
+
+            @app.get("/_next/{path:path}", include_in_schema=False)
+            async def proxy_next_assets(request: Request, path: str) -> Any:
+                return await _proxy_ui_request(request, f"_next/{path}")
+
+            @app.get("/static/{path:path}", include_in_schema=False)
+            async def proxy_static_assets(request: Request, path: str) -> Any:
+                return await _proxy_ui_request(request, f"static/{path}")
+
+            # Proxy common assets that might be at root
+            @app.get("/favicon.ico", include_in_schema=False)
+            async def proxy_favicon(request: Request) -> Any:
+                return await _proxy_ui_request(request, "favicon.ico")
+
+            @app.get("/icon.ico", include_in_schema=False)
+            async def proxy_icon(request: Request) -> Any:
+                return await _proxy_ui_request(request, "icon.ico")
+
+            # SPA routes
+            for route in [
+                "/admin",
+                "/dashboard",
+                "/login",
+                "/model",
+                "/providers",
+                "/settings",
+                "/transactions",
+                "/balances",
+                "/logs",
+                "/usage",
+                "/unauthorized",
+            ]:
+
+                @app.get(route, include_in_schema=False)
+                async def proxy_spa_route(request: Request) -> Any:
+                    return await _proxy_ui_request(request, "")
+
+        else:
+            logger.warning(
+                f"UI dist directory not found at {UI_DIST_PATH} and no fallback_ui_url configured"
+            )
+
+            @app.get("/", include_in_schema=False)
+            async def root_fallback() -> dict[str, Any]:
+                return {
+                    "name": global_settings.name,
+                    "description": global_settings.description,
+                    "version": version,
+                    "status": "running",
+                    "ui": "not available",
+                }

routstr/payment/cost_calculation.py

@@ -48,6 +48,13 @@ async def calculate_cost(  # todo: can be sync
         },
     )
 
+    cost_data = MaxCostData(
+        base_msats=max_cost,
+        input_msats=0,
+        output_msats=0,
+        total_msats=max_cost,
+    )
+
     if "usage" not in response_data or response_data["usage"] is None:
         logger.warning(
             "No usage data in response, using base cost only",
@@ -56,12 +63,7 @@ async def calculate_cost(  # todo: can be sync
                 "model": response_data.get("model", "unknown"),
             },
         )
-        return MaxCostData(
-            base_msats=0,
-            input_msats=0,
-            output_msats=0,
-            total_msats=0,
-        )
+        return cost_data
 
     usage_data = response_data["usage"]
 
@@ -176,12 +178,7 @@ async def calculate_cost(  # todo: can be sync
                 "model": response_data.get("model", "unknown"),
             },
         )
-        return MaxCostData(
-            base_msats=max_cost,
-            input_msats=0,
-            output_msats=0,
-            total_msats=max_cost,
-        )
+        return cost_data
 
     input_tokens = usage_data.get("prompt_tokens", 0)
     output_tokens = usage_data.get("completion_tokens", 0)
@@ -195,16 +192,8 @@ async def calculate_cost(  # todo: can be sync
     )
 
     # added for response api
-    input_tokens = (
-        input_tokens
-        if input_tokens != 0
-        else response_data.get("usage", {}).get("input_tokens", 0)
-    )
-    output_tokens = (
-        output_tokens
-        if output_tokens != 0
-        else response_data.get("usage", {}).get("output_tokens", 0)
-    )
+    input_tokens = input_tokens if input_tokens != 0 else  response_data.get("usage", {}).get("input_tokens", 0)
+    output_tokens = output_tokens if output_tokens != 0 else  response_data.get("usage", {}).get("output_tokens", 0)
 
     input_msats = round(input_tokens / 1000 * MSATS_PER_1K_INPUT_TOKENS, 3)
 

routstr/payment/lnurl.py

@@ -283,7 +283,7 @@ async def raw_send_to_lnurl(
             f"({min_sendable_sat} - {max_sendable_sat} {unit})"
         )
 
-    estimated_fees_sat = int(max(math.ceil((amount_msat / 1000) * 0.01), 2)) + 1
+    estimated_fees_sat = int(max(math.ceil((amount_msat / 1000) * 0.01), 2))
     estimated_fees_msat = estimated_fees_sat * 1000
     final_amount = amount_msat - estimated_fees_msat
 

routstr/proxy.py

@@ -16,7 +16,6 @@ from .core.db import (
     create_session,
     get_session,
 )
-from .core.settings import settings
 from .payment.helpers import (
     calculate_discounted_max_cost,
     check_token_balance,
@@ -26,7 +25,6 @@ from .payment.helpers import (
 from .payment.models import Model
 from .upstream import BaseUpstreamProvider
 from .upstream.helpers import init_upstreams
-from .wallet import deserialize_token_from_string
 
 logger = get_logger(__name__)
 proxy_router = APIRouter()
@@ -148,24 +146,6 @@ async def proxy(
     else:
         model_id = request_body_dict.get("model", "unknown")
 
-    if "https://testnut.cashu.space" in settings.cashu_mints:
-        try:
-            token_str = None
-            if x_cashu_header := headers.get("x-cashu"):
-                token_str = x_cashu_header
-            elif auth_header := headers.get("authorization"):
-                parts = auth_header.split(" ")
-                if len(parts) > 1 and not parts[1].startswith("sk-"):
-                    token_str = parts[1]
-
-            if token_str:
-                token_obj = deserialize_token_from_string(token_str)
-                if token_obj.mint == "https://testnut.cashu.space":
-                    model_id = "mock/gpt-420-mock"
-                    request_body_dict["model"] = model_id
-        except Exception:
-            pass
-
     model_obj = get_model_instance(model_id)
     if not model_obj:
         return create_error_response(
@@ -357,7 +337,7 @@ def extract_model_from_responses_request(request_body_dict: dict[str, Any]) -> s
 
     logger.warning(
         "No model found in Responses API request",
-        extra={"body_keys": list(request_body_dict.keys())},
+        extra={"body_keys": list(request_body_dict.keys())}
     )
     return "unknown"
 

routstr/upstream/base.py

@@ -234,11 +234,7 @@ class BaseUpstreamProvider:
                     )
 
                 # Handle model in input field (alternative format)
-                if (
-                    "input" in data
-                    and isinstance(data["input"], dict)
-                    and "model" in data["input"]
-                ):
+                if "input" in data and isinstance(data["input"], dict) and "model" in data["input"]:
                     original_model = model_obj.id
                     transformed_model = self.transform_model_name(original_model)
                     data["input"]["model"] = transformed_model
@@ -447,11 +443,6 @@ class BaseUpstreamProvider:
                 async with create_session() as new_session:
                     fresh_key = await new_session.get(key.__class__, key.hashed_key)
                     if not fresh_key:
-                        logger.warning(
-                            "Key not found when finalizing streaming payment",
-                            extra={"key_hash": key.hashed_key[:8] + "..."},
-                        )
-                        usage_finalized = True
                         return None
                     try:
                         fallback: dict = {
@@ -480,7 +471,6 @@ class BaseUpstreamProvider:
                                 "key_hash": key.hashed_key[:8] + "...",
                             },
                         )
-                        usage_finalized = True
                         return None
 
             try:
@@ -590,10 +580,8 @@ class BaseUpstreamProvider:
                         "key_hash": key.hashed_key[:8] + "...",
                     },
                 )
+                await finalize_without_usage()
                 raise
-            finally:
-                if not usage_finalized:
-                    await finalize_without_usage()
 
         # Remove inaccurate encoding headers from upstream response
         response_headers = dict(response.headers)
@@ -746,11 +734,6 @@ class BaseUpstreamProvider:
                 async with create_session() as new_session:
                     fresh_key = await new_session.get(key.__class__, key.hashed_key)
                     if not fresh_key:
-                        logger.warning(
-                            "Key not found when finalizing Responses API streaming payment",
-                            extra={"key_hash": key.hashed_key[:8] + "..."},
-                        )
-                        usage_finalized = True
                         return None
                     try:
                         fallback: dict = {
@@ -779,7 +762,6 @@ class BaseUpstreamProvider:
                                 "key_hash": key.hashed_key[:8] + "...",
                             },
                         )
-                        usage_finalized = True
                         return None
 
             try:
@@ -797,13 +779,8 @@ class BaseUpstreamProvider:
 
                                     # Track reasoning tokens for Responses API
                                     if usage := obj.get("usage", {}):
-                                        if (
-                                            isinstance(usage, dict)
-                                            and "reasoning_tokens" in usage
-                                        ):
-                                            reasoning_tokens += usage.get(
-                                                "reasoning_tokens", 0
-                                            )
+                                        if isinstance(usage, dict) and "reasoning_tokens" in usage:
+                                            reasoning_tokens += usage.get("reasoning_tokens", 0)
                             except json.JSONDecodeError:
                                 pass
                     except Exception:
@@ -904,10 +881,8 @@ class BaseUpstreamProvider:
                         "key_hash": key.hashed_key[:8] + "...",
                     },
                 )
+                await finalize_without_usage()
                 raise
-            finally:
-                if not usage_finalized:
-                    await finalize_without_usage()
 
         # Remove inaccurate encoding headers from upstream response
         response_headers = dict(response.headers)
@@ -958,8 +933,8 @@ class BaseUpstreamProvider:
                     "model": response_json.get("model", "unknown"),
                     "has_usage": "usage" in response_json,
                     "has_reasoning_tokens": "usage" in response_json
-                    and isinstance(response_json.get("usage"), dict)
-                    and "reasoning_tokens" in response_json["usage"],
+                        and isinstance(response_json.get("usage"), dict)
+                        and "reasoning_tokens" in response_json["usage"],
                 },
             )
 
@@ -1026,208 +1001,6 @@ class BaseUpstreamProvider:
             )
             raise
 
-    async def _finalize_generic_streaming_payment(
-        self, key_hash: str, max_cost: int, path: str
-    ) -> None:
-        """Background task to finalize payment for generic streaming requests."""
-        async with create_session() as session:
-            key = await session.get(ApiKey, key_hash)
-            if not key:
-                logger.warning(
-                    "Key not found during background payment finalization",
-                    extra={"key_hash": key_hash[:8] + "..."},
-                )
-                return
-
-            try:
-                # Finalize with "unknown" model and no usage to release reservation/charge max cost
-                await adjust_payment_for_tokens(
-                    key,
-                    {"model": "unknown", "usage": None},
-                    session,
-                    max_cost,
-                )
-                logger.info(
-                    "Finalized generic streaming payment in background",
-                    extra={
-                        "path": path,
-                        "key_hash": key_hash[:8] + "...",
-                    },
-                )
-            except Exception as e:
-                logger.error(
-                    "Error finalizing generic streaming payment in background",
-                    extra={
-                        "error": str(e),
-                        "key_hash": key_hash[:8] + "...",
-                        "path": path,
-                    },
-                )
-
-    async def handle_streaming_messages_completion(
-        self, response: httpx.Response, key: ApiKey, max_cost_for_model: int
-    ) -> StreamingResponse:
-        async def stream_with_cost(
-            max_cost_for_model: int,
-        ) -> AsyncGenerator[bytes, None]:
-            stored_chunks: list[bytes] = []
-            usage_finalized: bool = False
-            last_model_seen: str | None = None
-            input_tokens: int = 0
-            output_tokens: int = 0
-
-            async def finalize_without_usage() -> bytes | None:
-                nonlocal usage_finalized
-                if usage_finalized:
-                    return None
-                async with create_session() as new_session:
-                    fresh_key = await new_session.get(key.__class__, key.hashed_key)
-                    if not fresh_key:
-                        usage_finalized = True
-                        return None
-                    try:
-                        fallback: dict = {
-                            "model": last_model_seen or "unknown",
-                            "usage": None,
-                        }
-                        cost_data = await adjust_payment_for_tokens(
-                            fresh_key, fallback, new_session, max_cost_for_model
-                        )
-                        usage_finalized = True
-                        return f"event: cost\ndata: {json.dumps({'cost': cost_data})}\n\n".encode()
-                    except Exception:
-                        usage_finalized = True
-                        return None
-
-            try:
-                async for chunk in response.aiter_bytes():
-                    stored_chunks.append(chunk)
-                    try:
-                        decoded_chunk = chunk.decode("utf-8", errors="ignore")
-                        for line in decoded_chunk.split("\n"):
-                            if line.startswith("data: "):
-                                try:
-                                    data = json.loads(line[6:])
-                                    if isinstance(data, dict):
-                                        msg = data.get("message", {})
-                                        if msg and msg.get("model"):
-                                            last_model_seen = str(msg.get("model"))
-
-                                        if usage := msg.get("usage"):
-                                            input_tokens += usage.get("input_tokens", 0)
-                                            output_tokens += usage.get(
-                                                "output_tokens", 0
-                                            )
-
-                                        if usage := data.get("usage"):
-                                            input_tokens += usage.get("input_tokens", 0)
-                                            output_tokens += usage.get(
-                                                "output_tokens", 0
-                                            )
-                                except json.JSONDecodeError:
-                                    pass
-                    except Exception:
-                        pass
-
-                    yield chunk
-
-                usage_data = {
-                    "input_tokens": input_tokens,
-                    "output_tokens": output_tokens,
-                }
-
-                if input_tokens > 0 or output_tokens > 0:
-                    async with create_session() as new_session:
-                        fresh_key = await new_session.get(key.__class__, key.hashed_key)
-                        if fresh_key:
-                            try:
-                                combined_data = {
-                                    "model": last_model_seen or "unknown",
-                                    "usage": usage_data,
-                                }
-                                cost_data = await adjust_payment_for_tokens(
-                                    fresh_key,
-                                    combined_data,
-                                    new_session,
-                                    max_cost_for_model,
-                                )
-                                usage_finalized = True
-                                yield f"event: cost\ndata: {json.dumps({'cost': cost_data})}\n\n".encode()
-                            except Exception:
-                                pass
-
-                if not usage_finalized:
-                    maybe_cost_event = await finalize_without_usage()
-                    if maybe_cost_event is not None:
-                        yield maybe_cost_event
-
-            except Exception:
-                if not usage_finalized:
-                    await finalize_without_usage()
-                raise
-            finally:
-                if not usage_finalized:
-                    await finalize_without_usage()
-
-        response_headers = dict(response.headers)
-        response_headers.pop("content-encoding", None)
-        response_headers.pop("content-length", None)
-
-        return StreamingResponse(
-            stream_with_cost(max_cost_for_model),
-            status_code=response.status_code,
-            headers=response_headers,
-        )
-
-    async def handle_non_streaming_messages_completion(
-        self,
-        response: httpx.Response,
-        key: ApiKey,
-        session: AsyncSession,
-        deducted_max_cost: int,
-        path: str,
-    ) -> Response:
-        try:
-            content = await response.aread()
-            response_json = json.loads(content)
-
-            if path.endswith("count_tokens") and "usage" not in response_json:
-                input_tokens = response_json.get("input_tokens", 0)
-                response_json["usage"] = {"input_tokens": input_tokens}
-
-            cost_data = await adjust_payment_for_tokens(
-                key, response_json, session, deducted_max_cost
-            )
-            response_json["cost"] = cost_data
-
-            allowed_headers = {
-                "content-type",
-                "cache-control",
-                "date",
-                "vary",
-                "access-control-allow-origin",
-                "access-control-allow-methods",
-                "access-control-allow-headers",
-                "access-control-allow-credentials",
-                "access-control-expose-headers",
-                "access-control-max-age",
-            }
-
-            response_headers = {
-                k: v
-                for k, v in response.headers.items()
-                if k.lower() in allowed_headers
-            }
-
-            return Response(
-                content=json.dumps(response_json).encode(),
-                status_code=response.status_code,
-                headers=response_headers,
-                media_type="application/json",
-            )
-        except Exception:
-            raise
-
     async def forward_request(
         self,
         request: Request,
@@ -1321,54 +1094,7 @@ class BaseUpstreamProvider:
                     await client.aclose()
                 return mapped_error
 
-            if (
-                path.endswith("chat/completions")
-                or path.endswith("embeddings")
-                or path.endswith("messages")
-                or path.endswith("messages/count_tokens")
-            ):
-                if path.endswith("messages"):
-                    client_wants_streaming = False
-                    if request_body:
-                        try:
-                            request_data = json.loads(request_body)
-                            client_wants_streaming = request_data.get("stream", False)
-                        except json.JSONDecodeError:
-                            pass
-
-                    content_type = response.headers.get("content-type", "")
-                    upstream_is_streaming = "text/event-stream" in content_type
-                    is_streaming = client_wants_streaming and upstream_is_streaming
-
-                    if is_streaming and response.status_code == 200:
-                        result = await self.handle_streaming_messages_completion(
-                            response, key, max_cost_for_model
-                        )
-                        background_tasks = BackgroundTasks()
-                        background_tasks.add_task(response.aclose)
-                        background_tasks.add_task(client.aclose)
-                        result.background = background_tasks
-                        return result
-
-                    if response.status_code == 200:
-                        try:
-                            return await self.handle_non_streaming_messages_completion(
-                                response, key, session, max_cost_for_model, path
-                            )
-                        finally:
-                            await response.aclose()
-                            await client.aclose()
-
-                if path.endswith("messages/count_tokens"):
-                    if response.status_code == 200:
-                        try:
-                            return await self.handle_non_streaming_messages_completion(
-                                response, key, session, max_cost_for_model, path
-                            )
-                        finally:
-                            await response.aclose()
-                            await client.aclose()
-
+            if path.endswith("chat/completions") or path.endswith("embeddings"):
                 if path.endswith("chat/completions"):
                     client_wants_streaming = False
                     if request_body:
@@ -1426,12 +1152,6 @@ class BaseUpstreamProvider:
             background_tasks = BackgroundTasks()
             background_tasks.add_task(response.aclose)
             background_tasks.add_task(client.aclose)
-            background_tasks.add_task(
-                self._finalize_generic_streaming_payment,
-                key.hashed_key,
-                max_cost_for_model,
-                path,
-            )
 
             logger.debug(
                 "Streaming non-chat response",
@@ -1635,15 +1355,9 @@ class BaseUpstreamProvider:
             background_tasks = BackgroundTasks()
             background_tasks.add_task(response.aclose)
             background_tasks.add_task(client.aclose)
-            background_tasks.add_task(
-                self._finalize_generic_streaming_payment,
-                key.hashed_key,
-                max_cost_for_model,
-                path,
-            )
 
             logger.debug(
-                "Streaming non-Responses API response",
+                "Streaming non-chat response",
                 extra={
                     "path": path,
                     "status_code": response.status_code,
@@ -2789,10 +2503,7 @@ class BaseUpstreamProvider:
                         usage_data = data_json["usage"]
                         model = data_json.get("model")
                         # Track reasoning tokens for Responses API
-                        if (
-                            isinstance(usage_data, dict)
-                            and "reasoning_tokens" in usage_data
-                        ):
+                        if isinstance(usage_data, dict) and "reasoning_tokens" in usage_data:
                             reasoning_tokens = usage_data.get("reasoning_tokens", 0)
                     elif "model" in data_json and not model:
                         model = data_json["model"]

routstr/upstream/fake.py

@@ -1,265 +0,0 @@
-import asyncio
-import json
-import random
-from typing import AsyncIterator
-
-from fastapi import Request
-from fastapi.responses import Response, StreamingResponse
-
-from ..core.db import ApiKey, AsyncSession
-from ..payment.models import Architecture, Model, Pricing
-from .base import BaseUpstreamProvider
-
-
-class MockUpstreamProvider(BaseUpstreamProvider):
-    """Fack Mock Upstream provider specifically for Testing."""
-
-    provider_type = "mock"
-
-    async def forward_request(
-        self,
-        request: Request,
-        path: str,
-        headers: dict,
-        request_body: bytes | None,
-        key: ApiKey,
-        max_cost_for_model: int,
-        session: AsyncSession,
-        model_obj: Model,
-    ) -> Response | StreamingResponse:
-        if path.endswith("chat/completions"):
-            is_streaming = False
-            if request_body:
-                request_data = json.loads(request_body)
-                is_streaming = request_data.get("stream", False)
-
-            if is_streaming:
-
-                async def fake_streaming_response(
-                    chunk_size: int | None = None,
-                ) -> AsyncIterator[bytes]:
-                    suffix = random.randint(1000, 9999)
-                    req_id = f"gen-mock-stream-{suffix}"
-                    created = 1766138895
-                    model = "mock/gpt-420-mock"
-
-                    def make_chunk(
-                        delta: dict,
-                        finish_reason: str | None = None,
-                        usage: dict | None = None,
-                    ) -> bytes:
-                        chunk = {
-                            "id": req_id,
-                            "provider": "MockProvider",
-                            "model": model,
-                            "object": "chat.completion.chunk",
-                            "created": created,
-                            "choices": [
-                                {
-                                    "index": 0,
-                                    "delta": delta,
-                                    "finish_reason": finish_reason,
-                                    "native_finish_reason": "completed"
-                                    if finish_reason
-                                    else None,
-                                    "logprobs": None,
-                                }
-                            ],
-                        }
-                        if usage:
-                            chunk["usage"] = usage
-                        return f"data: {json.dumps(chunk)}\n\n".encode()
-
-                    # 1. Initial chunk
-                    yield make_chunk({"role": "assistant", "content": ""})
-                    await asyncio.sleep(0.02)
-
-                    # 2. Reasoning chunks
-                    reasoning_tokens = ["Mock", " reason", "ing", "..."]
-                    for token in reasoning_tokens:
-                        delta = {
-                            "role": "assistant",
-                            "content": "",
-                            "reasoning": token,
-                            "reasoning_details": [
-                                {
-                                    "type": "reasoning.summary",
-                                    "summary": token,
-                                    "format": "openai-responses-v1",
-                                    "index": 0,
-                                }
-                            ],
-                        }
-                        yield make_chunk(delta)
-                        await asyncio.sleep(0.03)
-
-                    # 3. Content chunks
-                    content_tokens = ["This", " is", " a", " mock", " stream", "."]
-                    for token in content_tokens:
-                        yield make_chunk({"role": "assistant", "content": token})
-                        await asyncio.sleep(0.03)
-
-                    # 4. Finish chunk
-                    yield make_chunk(
-                        {"role": "assistant", "content": ""}, finish_reason="stop"
-                    )
-
-                    # 5. Usage chunk
-                    usage_data = {
-                        "prompt_tokens": 10,
-                        "completion_tokens": 20,
-                        "total_tokens": 30,
-                        "cost": 0.001,
-                        "is_byok": False,
-                        "prompt_tokens_details": {
-                            "cached_tokens": 0,
-                            "audio_tokens": 0,
-                            "video_tokens": 0,
-                        },
-                        "cost_details": {
-                            "upstream_inference_cost": None,
-                            "upstream_inference_prompt_cost": 0,
-                            "upstream_inference_completions_cost": 0.001,
-                        },
-                        "completion_tokens_details": {
-                            "reasoning_tokens": 10,
-                            "image_tokens": 0,
-                        },
-                    }
-
-                    usage_chunk = {
-                        "id": req_id,
-                        "provider": "MockProvider",
-                        "model": model,
-                        "object": "chat.completion.chunk",
-                        "created": created,
-                        "choices": [
-                            {
-                                "index": 0,
-                                "delta": {"role": "assistant", "content": ""},
-                                "finish_reason": None,
-                                "native_finish_reason": None,
-                                "logprobs": None,
-                            }
-                        ],
-                        "usage": usage_data,
-                    }
-                    yield f"data: {json.dumps(usage_chunk)}\n\n".encode()
-
-                    # 6. DONE
-                    yield b"data: [DONE]\n\n"
-
-                    # 7. Cost
-                    cost_chunk = {
-                        "cost": {
-                            "base_msats": 0,
-                            "input_msats": 2,
-                            "output_msats": 10,
-                            "total_msats": 12,
-                        }
-                    }
-                    yield f"data: {json.dumps(cost_chunk)}\n\n".encode()
-
-                return StreamingResponse(
-                    fake_streaming_response(),
-                    200,
-                )
-
-            else:
-                suffix = random.randint(1000, 9999)
-                content_dict = {
-                    "id": f"gen-mock-{suffix}",
-                    "provider": "MockProvider",
-                    "model": "mock/gpt-5-mini",
-                    "object": "chat.completion",
-                    "created": 1766138655,
-                    "choices": [
-                        {
-                            "logprobs": None,
-                            "finish_reason": "length",
-                            "native_finish_reason": "max_output_tokens",
-                            "index": 0,
-                            "message": {
-                                "role": "assistant",
-                                "content": f"Mock Content {suffix}",
-                                "refusal": None,
-                                "reasoning": f"Mock Reasoning {suffix}",
-                                "reasoning_details": [
-                                    {
-                                        "format": "openai-responses-v1",
-                                        "index": 0,
-                                        "type": "reasoning.summary",
-                                        "summary": f"Mock Summary {suffix}",
-                                    },
-                                    {
-                                        "id": f"rs_mock_{suffix}",
-                                        "format": "openai-responses-v1",
-                                        "index": 0,
-                                        "type": "reasoning.encrypted",
-                                        "data": "mock_encrypted_data",
-                                    },
-                                ],
-                            },
-                        }
-                    ],
-                    "usage": {
-                        "prompt_tokens": 10,
-                        "completion_tokens": 10,
-                        "total_tokens": 20,
-                        "cost": 0,
-                        "is_byok": False,
-                        "prompt_tokens_details": {
-                            "cached_tokens": 0,
-                            "audio_tokens": 0,
-                            "video_tokens": 0,
-                        },
-                        "cost_details": {
-                            "upstream_inference_cost": None,
-                            "upstream_inference_prompt_cost": 0,
-                            "upstream_inference_completions_cost": 0,
-                        },
-                        "completion_tokens_details": {
-                            "reasoning_tokens": 5,
-                            "image_tokens": 0,
-                        },
-                    },
-                    "cost": {
-                        "base_msats": 0,
-                        "input_msats": 0,
-                        "output_msats": 0,
-                        "total_msats": 0,
-                    },
-                }
-                return Response(json.dumps(content_dict).encode(), 200)
-
-        elif path.endswith("embeddings"):
-            raise NotImplementedError
-        elif path.endswith("responses"):
-            raise NotImplementedError
-        else:
-            raise NotImplementedError
-
-    async def fetch_models(self) -> list[Model]:
-        return [
-            Model(
-                id="mock/gpt-420-mock",
-                name="mock/gpt-420-mock",
-                created=0,
-                description="mock model for testing",
-                context_length=8192,
-                architecture=Architecture(
-                    modality="text",
-                    input_modalities=["text"],
-                    output_modalities=["text"],
-                    tokenizer="",
-                    instruct_type=None,
-                ),
-                pricing=Pricing(prompt=0.01, completion=0.01),
-            ),
-        ]
-
-    def transform_model_name(self, model_id: str) -> str:
-        return "fake-model"
-
-    async def get_balance(self) -> float | None:
-        return 420.69

routstr/upstream/gemini.py

@@ -187,44 +187,11 @@ class GeminiUpstreamProvider(BaseUpstreamProvider):
                 )
 
                 async def stream_with_cost() -> AsyncGenerator[bytes, None]:
-                    payment_finalized = False
-
-                    async def finalize_payment() -> None:
-                        nonlocal payment_finalized
-                        if payment_finalized:
-                            return
-                        from ..auth import adjust_payment_for_tokens
-                        from ..core.db import create_session
-
-                        async with create_session() as new_session:
-                            fresh_key = await new_session.get(
-                                key.__class__, key.hashed_key
-                            )
-                            if fresh_key:
-                                try:
-                                    await adjust_payment_for_tokens(
-                                        fresh_key,
-                                        {
-                                            "model": model_obj.id,
-                                            "usage": final_usage_data,
-                                        },
-                                        new_session,
-                                        max_cost_for_model,
-                                    )
-                                    payment_finalized = True
-                                except Exception as cost_error:
-                                    logger.error(
-                                        "Error finalizing Gemini streaming payment in fallback",
-                                        extra={
-                                            "error": str(cost_error),
-                                            "key_hash": key.hashed_key[:8] + "...",
-                                        },
-                                    )
-
                     try:
                         async for chunk in response_generator:
                             sse_data = f"data: {json.dumps(chunk)}\n\n"
                             yield sse_data.encode()
+
                     except Exception as e:
                         logger.error(
                             "Error in Gemini streaming response",
@@ -235,9 +202,6 @@ class GeminiUpstreamProvider(BaseUpstreamProvider):
                             },
                         )
                         raise
-                    finally:
-                        if not payment_finalized:
-                            await finalize_payment()
 
                 return StreamingResponse(
                     stream_with_cost(),

routstr/upstream/helpers.py

@@ -218,14 +218,6 @@ async def init_upstreams() -> list[BaseUpstreamProvider]:
         results = await asyncio.gather(*tasks)
         upstreams = [p for p in results if p is not None]
 
-        if "https://testnut.cashu.space" in settings.cashu_mints:
-            from .fake import MockUpstreamProvider
-
-            mock_provider = MockUpstreamProvider("mock", "mock")
-            await mock_provider.refresh_models_cache()
-            upstreams.append(mock_provider)
-            logger.info("Initialized MockUpstreamProvider for testnut mint")
-
         return upstreams
 
 

routstr/wallet.py

@@ -81,7 +81,7 @@ async def swap_to_primary_mint(
         amount_msat = token_amount
     else:
         raise ValueError("Invalid unit")
-    estimated_fee_sat = math.ceil(max(amount_msat // 1000 * 0.01, 2)) + 1
+    estimated_fee_sat = math.ceil(max(amount_msat // 1000 * 0.01, 2))
     amount_msat_after_fee = amount_msat - estimated_fee_sat * 1000
     primary_wallet = await get_wallet(settings.primary_mint, settings.primary_mint_unit)
 
@@ -313,8 +313,6 @@ async def periodic_payout() -> None:
         try:
             async with db.create_session() as session:
                 for mint_url in settings.cashu_mints:
-                    if mint_url == "https://testnut.cashu.space":
-                        continue
                     for unit in ["sat", "msat"]:
                         wallet = await get_wallet(mint_url, unit)
                         proofs = get_proofs_per_mint_and_unit(

scripts/reproduce_bug_staging.py

@@ -1,101 +0,0 @@
-import asyncio
-
-import httpx
-
-BASE_URL = input("Enter routstr URL: ")
-API_KEY = input("Enter key or token: ")
-
-
-async def get_balance(client: httpx.AsyncClient) -> int:
-    response = await client.get("/v1/balance/info")
-    response.raise_for_status()
-    data = response.json()
-    print(f"Current Balance Info: {data}")
-    return data.get("reserved", 0)
-
-
-async def reproduce() -> None:
-    headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
-
-    async with httpx.AsyncClient(
-        base_url=BASE_URL, headers=headers, timeout=30.0
-    ) as client:
-        print("Checking initial balance...")
-        try:
-            initial_reserved = await get_balance(client)
-        except Exception as e:
-            print(f"Failed to get balance: {e}")
-            return
-
-        print("\nStarting streaming request...")
-        try:
-            # Create a separate client for the stream so we can close it independently if needed,
-            # but usually just breaking the loop and exiting the context manager is enough.
-            # However, to be sure we simulate a harsh disconnect, we can just cancel the task or close the client.
-
-            async with client.stream(
-                "POST",
-                "/v1/chat/completions",
-                json={
-                    "model": "gpt-5-nano",
-                    "messages": [
-                        {
-                            "role": "user",
-                            "content": "Write a long poem about the ocean.",
-                        }
-                    ],
-                    "stream": True,
-                },
-            ) as response:
-                print(f"Stream status: {response.status_code}")
-                if response.status_code != 200:
-                    err_bytes = await response.aread()
-                    try:
-                        err_str = err_bytes.decode()
-                    except Exception:
-                        err_str = repr(err_bytes)
-                    print(f"Error: {err_str}")
-                    return
-
-                print("Stream started. Reading a few chunks...")
-                count = 0
-                async for chunk in response.aiter_bytes():
-                    print(f"Received chunk: {len(chunk)} bytes")
-                    count += 1
-                    if count >= 3:
-                        print("Simulating client disconnect (breaking stream)...")
-                        break
-
-        except Exception as e:
-            print(f"Stream interrupted (expected): {e}")
-
-        # Wait a bit for the server to realize we disconnected (though with asyncio it might be immediate or depend on keepalive)
-        print("\nWaiting for server to process disconnect...")
-        await asyncio.sleep(21)
-
-        print("\nChecking final balance...")
-        try:
-            final_reserved = await get_balance(client)
-        except Exception:
-            # Retry once if connection was closed
-            async with httpx.AsyncClient(
-                base_url=BASE_URL, headers=headers, timeout=30.0
-            ) as new_client:
-                final_reserved = await get_balance(new_client)
-
-        if final_reserved > initial_reserved:
-            print(
-                f"\n[FAIL] Bug reproduced! Reserved balance increased: {initial_reserved} -> {final_reserved}"
-            )
-            print(f"Accumulated reserved balance: {final_reserved - initial_reserved}")
-        else:
-            print(
-                f"\n[PASS] Reserved balance released correctly: {initial_reserved} -> {final_reserved}"
-            )
-
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(reproduce())
-    except KeyboardInterrupt:
-        pass

ui/Dockerfile

@@ -4,22 +4,17 @@ FROM base AS deps
 RUN apk add --no-cache libc6-compat
 WORKDIR /app
 
-RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
-
-COPY package.json pnpm-lock.yaml* ./
-RUN pnpm install --frozen-lockfile
+COPY package.json yarn.lock* package-lock.json* pnpm-lock.yaml* .npmrc* ./
+RUN npm i
 
 FROM base AS builder
 WORKDIR /app
-
-RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
-
 COPY --from=deps /app/node_modules ./node_modules
 COPY . .
 
 ENV NEXT_TELEMETRY_DISABLED=1
 
-RUN pnpm run build
+RUN npm run build
 FROM base AS runner
 WORKDIR /app
 

ui/Dockerfile.build

@@ -6,14 +6,12 @@ RUN apk add --no-cache libc6-compat
 WORKDIR /app
 
 # Copy package files
-COPY package.json pnpm-lock.yaml* ./
-RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
-RUN pnpm install --frozen-lockfile
+COPY package.json package-lock.json* pnpm-lock.yaml* ./
+RUN npm ci
 
 # Build the UI
 FROM base AS builder
 WORKDIR /app
-RUN corepack enable pnpm && corepack prepare pnpm@latest --activate
 COPY --from=deps /app/node_modules ./node_modules
 COPY . .
 
@@ -29,7 +27,7 @@ ENV NODE_ENV=production
 ENV NEXT_TELEMETRY_DISABLED=1
 
 # Build the application
-RUN pnpm run build && \
+RUN npm run build && \
     echo "UI build completed at $(date)"
 
 # Use the builder stage as the final stage

ui/app/logs/log-filters.tsx

@@ -21,17 +21,7 @@ import {
   PopoverTrigger,
 } from '@/components/ui/popover';
 import { Calendar } from '@/components/ui/calendar';
-import { Badge } from '@/components/ui/badge';
-import {
-  Command,
-  CommandEmpty,
-  CommandGroup,
-  CommandInput,
-  CommandItem,
-  CommandList,
-} from '@/components/ui/command';
-import { Checkbox } from '@/components/ui/checkbox';
-import { CalendarIcon, Filter, X, Plus } from 'lucide-react';
+import { CalendarIcon, Filter, X } from 'lucide-react';
 import { useState, useEffect } from 'react';
 import { format } from 'date-fns';
 import { cn } from '@/lib/utils';
@@ -41,17 +31,11 @@ interface LogFiltersProps {
   selectedLevel: string;
   requestId: string;
   searchText: string;
-  selectedStatusCodes: string[];
-  selectedMethods: string[];
-  selectedEndpoints: string[];
   limit: number;
   onDateChange: (date: string) => void;
   onLevelChange: (level: string) => void;
   onRequestIdChange: (requestId: string) => void;
   onSearchTextChange: (searchText: string) => void;
-  onStatusCodesChange: (statusCodes: string[]) => void;
-  onMethodsChange: (methods: string[]) => void;
-  onEndpointsChange: (endpoints: string[]) => void;
   onLimitChange: (limit: number) => void;
   onClearFilters: () => void;
 }
@@ -59,87 +43,16 @@ interface LogFiltersProps {
 const LOG_LEVELS = ['TRACE', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'];
 const PRESET_LIMITS = ['25', '50', '100', '200', '500', '1000'];
 
-const STATUS_CODE_OPTIONS = [
-  '200',
-  '201',
-  '204',
-  '400',
-  '401',
-  '402',
-  '403',
-  '404',
-  '422',
-  '429',
-  '500',
-  '502',
-  '503',
-  '504',
-];
-
-const METHOD_OPTIONS = [
-  'GET',
-  'POST',
-  'PUT',
-  'DELETE',
-  'PATCH',
-  'OPTIONS',
-  'HEAD',
-];
-
-const ENDPOINT_OPTIONS = [
-  '/chat/completions',
-  '/v1/chat/completions',
-  '/models',
-  '/v1/models',
-  '/responses',
-  '/v1/responses',
-  'v1/embeddings/models',
-  '/embeddings/models',
-];
-
-interface FilterBadgeProps {
-  value: string;
-  onRemove: (value: string) => void;
-}
-
-function FilterBadge({ value, onRemove }: FilterBadgeProps) {
-  return (
-    <Badge
-      variant='secondary'
-      className='flex items-center gap-1 px-1 font-normal'
-    >
-      {value}
-      <button
-        type='button'
-        onClick={(e) => {
-          e.preventDefault();
-          e.stopPropagation();
-          onRemove(value);
-        }}
-        className='hover:bg-muted-foreground/20 rounded-full'
-      >
-        <X className='h-3 w-3' />
-      </button>
-    </Badge>
-  );
-}
-
 export function LogFilters({
   selectedDate,
   selectedLevel,
   requestId,
   searchText,
-  selectedStatusCodes,
-  selectedMethods,
-  selectedEndpoints,
   limit,
   onDateChange,
   onLevelChange,
   onRequestIdChange,
   onSearchTextChange,
-  onStatusCodesChange,
-  onMethodsChange,
-  onEndpointsChange,
   onLimitChange,
   onClearFilters,
 }: LogFiltersProps) {
@@ -155,10 +68,6 @@ export function LogFilters({
       : undefined
   );
 
-  const [statusSearch, setStatusSearch] = useState('');
-  const [methodSearch, setMethodSearch] = useState('');
-  const [endpointSearch, setEndpointSearch] = useState('');
-
   useEffect(() => {
     const currentIsPreset = PRESET_LIMITS.includes(limit.toString());
     setIsCustom(!currentIsPreset);
@@ -220,31 +129,6 @@ export function LogFilters({
     }
   };
 
-  const toggleSelection = (
-    current: string[],
-    value: string,
-    onChange: (val: string[]) => void
-  ) => {
-    if (current.includes(value)) {
-      onChange(current.filter((v) => v !== value));
-    } else {
-      onChange([...current, value]);
-    }
-  };
-
-  const handleQuickStatusCode = (range: '4xx' | '5xx') => {
-    const codes = STATUS_CODE_OPTIONS.filter((c) => c.startsWith(range[0]));
-    const newSelection = new Set([...selectedStatusCodes]);
-    const allIncluded = codes.every((c) => selectedStatusCodes.includes(c));
-
-    if (allIncluded) {
-      codes.forEach((c) => newSelection.delete(c));
-    } else {
-      codes.forEach((c) => newSelection.add(c));
-    }
-    onStatusCodesChange(Array.from(newSelection));
-  };
-
   return (
     <Card className='mb-6'>
       <CardHeader>
@@ -253,8 +137,7 @@ export function LogFilters({
           Filters
         </CardTitle>
         <CardDescription>
-          Filter logs by date, level, request ID, text search, status code,
-          method, endpoint and limit
+          Filter logs by date, level, request ID, text search, and limit
         </CardDescription>
       </CardHeader>
       <CardContent>
@@ -314,337 +197,6 @@ export function LogFilters({
             </Select>
           </div>
 
-          <div className='space-y-2'>
-            <Label>Status Codes</Label>
-            <Popover>
-              <PopoverTrigger asChild>
-                <Button
-                  variant='outline'
-                  className='w-full justify-start text-left font-normal'
-                >
-                  <div className='flex flex-wrap gap-1'>
-                    {selectedStatusCodes.length > 0 ? (
-                      selectedStatusCodes.map((code) => (
-                        <FilterBadge
-                          key={code}
-                          value={code}
-                          onRemove={(val) =>
-                            toggleSelection(
-                              selectedStatusCodes,
-                              val,
-                              onStatusCodesChange
-                            )
-                          }
-                        />
-                      ))
-                    ) : (
-                      <span className='text-muted-foreground'>All codes</span>
-                    )}
-                  </div>
-                </Button>
-              </PopoverTrigger>
-              <PopoverContent className='w-64 p-0' align='start'>
-                <Command>
-                  <CommandInput
-                    placeholder='Search or add status code...'
-                    value={statusSearch}
-                    onValueChange={setStatusSearch}
-                  />
-                  <CommandList>
-                    {selectedStatusCodes.length > 0 && (
-                      <CommandGroup heading='Selected'>
-                        {selectedStatusCodes.map((code) => (
-                          <CommandItem
-                            key={`selected-${code}`}
-                            onSelect={() =>
-                              toggleSelection(
-                                selectedStatusCodes,
-                                code,
-                                onStatusCodesChange
-                              )
-                            }
-                          >
-                            <Checkbox checked={true} className='mr-2' />
-                            {code}
-                          </CommandItem>
-                        ))}
-                      </CommandGroup>
-                    )}
-                    {statusSearch &&
-                      !STATUS_CODE_OPTIONS.includes(statusSearch) &&
-                      !selectedStatusCodes.includes(statusSearch) && (
-                        <CommandGroup heading='Custom'>
-                          <CommandItem
-                            onSelect={() => {
-                              if (/^\d+$/.test(statusSearch)) {
-                                toggleSelection(
-                                  selectedStatusCodes,
-                                  statusSearch,
-                                  onStatusCodesChange
-                                );
-                                setStatusSearch('');
-                              }
-                            }}
-                          >
-                            <Plus className='mr-2 h-4 w-4' />
-                            Add &quot;{statusSearch}&quot;
-                          </CommandItem>
-                        </CommandGroup>
-                      )}
-                    <CommandEmpty>No results found.</CommandEmpty>
-                    <CommandGroup heading='Quick Filters'>
-                      <CommandItem
-                        onSelect={() => handleQuickStatusCode('4xx')}
-                      >
-                        <Checkbox
-                          checked={STATUS_CODE_OPTIONS.filter((c) =>
-                            c.startsWith('4')
-                          ).every((c) => selectedStatusCodes.includes(c))}
-                          className='mr-2'
-                        />
-                        4xx Errors
-                      </CommandItem>
-                      <CommandItem
-                        onSelect={() => handleQuickStatusCode('5xx')}
-                      >
-                        <Checkbox
-                          checked={STATUS_CODE_OPTIONS.filter((c) =>
-                            c.startsWith('5')
-                          ).every((c) => selectedStatusCodes.includes(c))}
-                          className='mr-2'
-                        />
-                        5xx Errors
-                      </CommandItem>
-                    </CommandGroup>
-                    <CommandGroup heading='Common Codes'>
-                      {STATUS_CODE_OPTIONS.filter(
-                        (code) => !selectedStatusCodes.includes(code)
-                      ).map((code) => (
-                        <CommandItem
-                          key={code}
-                          onSelect={() =>
-                            toggleSelection(
-                              selectedStatusCodes,
-                              code,
-                              onStatusCodesChange
-                            )
-                          }
-                        >
-                          <Checkbox checked={false} className='mr-2' />
-                          {code}
-                        </CommandItem>
-                      ))}
-                    </CommandGroup>
-                  </CommandList>
-                </Command>
-              </PopoverContent>
-            </Popover>
-          </div>
-
-          <div className='space-y-2'>
-            <Label>HTTP Methods</Label>
-            <Popover>
-              <PopoverTrigger asChild>
-                <Button
-                  variant='outline'
-                  className='w-full justify-start text-left font-normal'
-                >
-                  <div className='flex flex-wrap gap-1'>
-                    {selectedMethods.length > 0 ? (
-                      selectedMethods.map((method) => (
-                        <FilterBadge
-                          key={method}
-                          value={method}
-                          onRemove={(val) =>
-                            toggleSelection(
-                              selectedMethods,
-                              val,
-                              onMethodsChange
-                            )
-                          }
-                        />
-                      ))
-                    ) : (
-                      <span className='text-muted-foreground'>All methods</span>
-                    )}
-                  </div>
-                </Button>
-              </PopoverTrigger>
-              <PopoverContent className='w-64 p-0' align='start'>
-                <Command>
-                  <CommandInput
-                    placeholder='Search or add method...'
-                    value={methodSearch}
-                    onValueChange={setMethodSearch}
-                  />
-                  <CommandList>
-                    {selectedMethods.length > 0 && (
-                      <CommandGroup heading='Selected'>
-                        {selectedMethods.map((method) => (
-                          <CommandItem
-                            key={`selected-${method}`}
-                            onSelect={() =>
-                              toggleSelection(
-                                selectedMethods,
-                                method,
-                                onMethodsChange
-                              )
-                            }
-                          >
-                            <Checkbox checked={true} className='mr-2' />
-                            {method}
-                          </CommandItem>
-                        ))}
-                      </CommandGroup>
-                    )}
-                    {methodSearch &&
-                      !METHOD_OPTIONS.includes(methodSearch.toUpperCase()) &&
-                      !selectedMethods.includes(methodSearch.toUpperCase()) && (
-                        <CommandGroup heading='Custom'>
-                          <CommandItem
-                            onSelect={() => {
-                              toggleSelection(
-                                selectedMethods,
-                                methodSearch.toUpperCase(),
-                                onMethodsChange
-                              );
-                              setMethodSearch('');
-                            }}
-                          >
-                            <Plus className='mr-2 h-4 w-4' />
-                            Add &quot;{methodSearch.toUpperCase()}&quot;
-                          </CommandItem>
-                        </CommandGroup>
-                      )}
-                    <CommandEmpty>No results found.</CommandEmpty>
-                    <CommandGroup>
-                      {METHOD_OPTIONS.filter(
-                        (method) => !selectedMethods.includes(method)
-                      ).map((method) => (
-                        <CommandItem
-                          key={method}
-                          onSelect={() =>
-                            toggleSelection(
-                              selectedMethods,
-                              method,
-                              onMethodsChange
-                            )
-                          }
-                        >
-                          <Checkbox checked={false} className='mr-2' />
-                          {method}
-                        </CommandItem>
-                      ))}
-                    </CommandGroup>
-                  </CommandList>
-                </Command>
-              </PopoverContent>
-            </Popover>
-          </div>
-
-          <div className='space-y-2'>
-            <Label>Endpoints</Label>
-            <Popover>
-              <PopoverTrigger asChild>
-                <Button
-                  variant='outline'
-                  className='w-full justify-start text-left font-normal'
-                >
-                  <div className='flex flex-wrap gap-1 overflow-hidden'>
-                    {selectedEndpoints.length > 0 ? (
-                      selectedEndpoints.map((endpoint) => (
-                        <FilterBadge
-                          key={endpoint}
-                          value={endpoint}
-                          onRemove={(val) =>
-                            toggleSelection(
-                              selectedEndpoints,
-                              val,
-                              onEndpointsChange
-                            )
-                          }
-                        />
-                      ))
-                    ) : (
-                      <span className='text-muted-foreground'>
-                        All endpoints
-                      </span>
-                    )}
-                  </div>
-                </Button>
-              </PopoverTrigger>
-              <PopoverContent className='w-80 p-0' align='start'>
-                <Command>
-                  <CommandInput
-                    placeholder='Search or add endpoint pattern...'
-                    value={endpointSearch}
-                    onValueChange={setEndpointSearch}
-                  />
-                  <CommandList>
-                    {selectedEndpoints.length > 0 && (
-                      <CommandGroup heading='Selected'>
-                        {selectedEndpoints.map((endpoint) => (
-                          <CommandItem
-                            key={`selected-${endpoint}`}
-                            onSelect={() =>
-                              toggleSelection(
-                                selectedEndpoints,
-                                endpoint,
-                                onEndpointsChange
-                              )
-                            }
-                          >
-                            <Checkbox checked={true} className='mr-2' />
-                            {endpoint}
-                          </CommandItem>
-                        ))}
-                      </CommandGroup>
-                    )}
-                    {endpointSearch &&
-                      !ENDPOINT_OPTIONS.includes(endpointSearch) &&
-                      !selectedEndpoints.includes(endpointSearch) && (
-                        <CommandGroup heading='Custom'>
-                          <CommandItem
-                            onSelect={() => {
-                              toggleSelection(
-                                selectedEndpoints,
-                                endpointSearch,
-                                onEndpointsChange
-                              );
-                              setEndpointSearch('');
-                            }}
-                          >
-                            <Plus className='mr-2 h-4 w-4' />
-                            Add &quot;{endpointSearch}&quot;
-                          </CommandItem>
-                        </CommandGroup>
-                      )}
-                    <CommandEmpty>No results found.</CommandEmpty>
-                    <CommandGroup heading='Common Endpoints'>
-                      {ENDPOINT_OPTIONS.filter(
-                        (endpoint) => !selectedEndpoints.includes(endpoint)
-                      ).map((endpoint) => (
-                        <CommandItem
-                          key={endpoint}
-                          onSelect={() =>
-                            toggleSelection(
-                              selectedEndpoints,
-                              endpoint,
-                              onEndpointsChange
-                            )
-                          }
-                        >
-                          <Checkbox checked={false} className='mr-2' />
-                          {endpoint}
-                        </CommandItem>
-                      ))}
-                    </CommandGroup>
-                  </CommandList>
-                </Command>
-              </PopoverContent>
-            </Popover>
-          </div>
-
           <div className='space-y-2'>
             <Label htmlFor='request-id'>Request ID</Label>
             <Input

ui/app/logs/page.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { useState, useEffect } from 'react';
+import { useState } from 'react';
 import { useQuery } from '@tanstack/react-query';
 import { AppSidebar } from '@/components/app-sidebar';
 import { SiteHeader } from '@/components/site-header';
@@ -22,66 +22,15 @@ import { LogFilters } from './log-filters';
 import { LogEntryCard } from './log-entry-card';
 import { LogDetailsDialog } from './log-details-dialog';
 
-const STORAGE_KEY = 'routstr-log-filters';
-
 export default function LogsPage() {
   const [selectedDate, setSelectedDate] = useState<string>('all');
   const [selectedLevel, setSelectedLevel] = useState<string>('all');
   const [requestId, setRequestId] = useState<string>('');
   const [searchText, setSearchText] = useState<string>('');
-  const [selectedStatusCodes, setSelectedStatusCodes] = useState<string[]>([]);
-  const [selectedMethods, setSelectedMethods] = useState<string[]>([]);
-  const [selectedEndpoints, setSelectedEndpoints] = useState<string[]>([]);
   const [limit, setLimit] = useState<number>(100);
   const [selectedLog, setSelectedLog] = useState<LogEntry | null>(null);
   const [isDialogOpen, setIsDialogOpen] = useState<boolean>(false);
 
-  // Load filters from localStorage on mount
-  useEffect(() => {
-    const saved = localStorage.getItem(STORAGE_KEY);
-    if (saved) {
-      try {
-        const parsed = JSON.parse(saved);
-        if (parsed.selectedDate) setSelectedDate(parsed.selectedDate);
-        if (parsed.selectedLevel) setSelectedLevel(parsed.selectedLevel);
-        if (parsed.requestId) setRequestId(parsed.requestId);
-        if (parsed.searchText) setSearchText(parsed.searchText);
-        if (parsed.selectedStatusCodes)
-          setSelectedStatusCodes(parsed.selectedStatusCodes);
-        if (parsed.selectedMethods) setSelectedMethods(parsed.selectedMethods);
-        if (parsed.selectedEndpoints)
-          setSelectedEndpoints(parsed.selectedEndpoints);
-        if (parsed.limit) setLimit(parsed.limit);
-      } catch (e) {
-        console.error('Failed to load filters from localStorage', e);
-      }
-    }
-  }, []);
-
-  // Save filters to localStorage whenever they change
-  useEffect(() => {
-    const filters = {
-      selectedDate,
-      selectedLevel,
-      requestId,
-      searchText,
-      selectedStatusCodes,
-      selectedMethods,
-      selectedEndpoints,
-      limit,
-    };
-    localStorage.setItem(STORAGE_KEY, JSON.stringify(filters));
-  }, [
-    selectedDate,
-    selectedLevel,
-    requestId,
-    searchText,
-    selectedStatusCodes,
-    selectedMethods,
-    selectedEndpoints,
-    limit,
-  ]);
-
   const {
     data: logsData,
     refetch: refetchLogs,
@@ -93,9 +42,6 @@ export default function LogsPage() {
       selectedLevel,
       requestId,
       searchText,
-      selectedStatusCodes,
-      selectedMethods,
-      selectedEndpoints,
       limit,
     ],
     queryFn: () =>
@@ -104,16 +50,6 @@ export default function LogsPage() {
         level: selectedLevel === 'all' ? undefined : selectedLevel,
         request_id: requestId || undefined,
         search: searchText || undefined,
-        status_codes:
-          selectedStatusCodes.length > 0
-            ? selectedStatusCodes.join(',')
-            : undefined,
-        methods:
-          selectedMethods.length > 0 ? selectedMethods.join(',') : undefined,
-        endpoints:
-          selectedEndpoints.length > 0
-            ? selectedEndpoints.join(',')
-            : undefined,
         limit: limit,
       }),
     refetchInterval: 30000,
@@ -124,9 +60,6 @@ export default function LogsPage() {
     setSelectedLevel('all');
     setRequestId('');
     setSearchText('');
-    setSelectedStatusCodes([]);
-    setSelectedMethods([]);
-    setSelectedEndpoints([]);
     setLimit(100);
   };
 
@@ -167,17 +100,11 @@ export default function LogsPage() {
             selectedLevel={selectedLevel}
             requestId={requestId}
             searchText={searchText}
-            selectedStatusCodes={selectedStatusCodes}
-            selectedMethods={selectedMethods}
-            selectedEndpoints={selectedEndpoints}
             limit={limit}
             onDateChange={setSelectedDate}
             onLevelChange={setSelectedLevel}
             onRequestIdChange={setRequestId}
             onSearchTextChange={setSearchText}
-            onStatusCodesChange={setSelectedStatusCodes}
-            onMethodsChange={setSelectedMethods}
-            onEndpointsChange={setSelectedEndpoints}
             onLimitChange={setLimit}
             onClearFilters={handleClearFilters}
           />
@@ -195,22 +122,13 @@ export default function LogsPage() {
               {(selectedDate !== 'all' ||
                 selectedLevel !== 'all' ||
                 requestId ||
-                searchText ||
-                selectedStatusCodes.length > 0 ||
-                selectedMethods.length > 0 ||
-                selectedEndpoints.length > 0) && (
+                searchText) && (
                 <CardDescription className='text-xs sm:text-sm'>
                   Showing logs
                   {selectedDate !== 'all' && ` for ${selectedDate}`}
                   {selectedLevel !== 'all' && ` with level ${selectedLevel}`}
                   {requestId && ` with request ID ${requestId}`}
                   {searchText && ` matching "${searchText}"`}
-                  {selectedStatusCodes.length > 0 &&
-                    ` with status ${selectedStatusCodes.join(', ')}`}
-                  {selectedMethods.length > 0 &&
-                    ` with method ${selectedMethods.join(', ')}`}
-                  {selectedEndpoints.length > 0 &&
-                    ` with endpoint ${selectedEndpoints.join(', ')}`}
                 </CardDescription>
               )}
             </CardHeader>

ui/app/logs/types.ts

@@ -17,9 +17,6 @@ export interface LogsResponse {
   level: string | null;
   request_id: string | null;
   search: string | null;
-  status_codes: string | null;
-  methods: string | null;
-  endpoints: string | null;
   limit: number;
 }
 

ui/app/providers/page.tsx

@@ -208,12 +208,7 @@ function ProviderBalance({
     return <Skeleton className='h-9 w-24' />;
   }
 
-  if (
-    error ||
-    !balanceData?.ok ||
-    balanceData.balance_data === undefined ||
-    balanceData.balance_data === null
-  ) {
+  if (error || !balanceData?.ok || !balanceData.balance_data) {
     return null;
   }
 

ui/package.json

@@ -15,7 +15,6 @@
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/modifiers": "^9.0.0",
     "@dnd-kit/sortable": "^10.0.0",
-    "@dnd-kit/utilities": "^3.2.2",
     "@hookform/resolvers": "^5.0.1",
     "@radix-ui/react-alert-dialog": "^1.1.10",
     "@radix-ui/react-avatar": "^1.1.6",
@@ -41,17 +40,17 @@
     "@radix-ui/react-toggle": "^1.1.6",
     "@radix-ui/react-toggle-group": "^1.1.6",
     "@radix-ui/react-tooltip": "^1.2.3",
-    "@tanstack/react-query": "^5.90.16",
+    "@tanstack/react-query": "^5.74.4",
     "@tanstack/react-table": "^8.21.3",
     "axios": "^1.13.2",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
-    "date-fns": "^4.1.0",
+    "date-fns": "^3.6.0",
     "embla-carousel-react": "^8.6.0",
     "input-otp": "^1.4.2",
-    "lucide-react": "^0.562.0",
-    "next": "15.5.9",
+    "lucide-react": "^0.501.0",
+    "next": "15.3.1",
     "next-themes": "^0.4.6",
     "qrcode": "^1.5.4",
     "qrcode.react": "^4.2.0",
@@ -68,21 +67,21 @@
     "zustand": "^5.0.3"
   },
   "devDependencies": {
-    "@eslint/eslintrc": "^3.3.3",
-    "@tailwindcss/postcss": "^4.1.18",
-    "@tanstack/react-query-devtools": "^5.91.2",
+    "@eslint/eslintrc": "^3",
+    "@tailwindcss/postcss": "^4",
+    "@tanstack/react-query-devtools": "^5.74.4",
     "@types/node": "^20",
     "@types/qrcode": "^1.5.6",
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "eslint": "^9.25.0",
-    "eslint-config-next": "15.5.9",
+    "eslint-config-next": "15.3.1",
     "eslint-config-prettier": "^10.1.2",
     "eslint-plugin-prettier": "^5.2.6",
     "eslint-plugin-react": "^7.37.5",
     "prettier": "^3.5.3",
     "prettier-plugin-tailwindcss": "^0.6.11",
-    "tailwindcss": "^4.1.18",
+    "tailwindcss": "^4",
     "typescript": "^5"
   }
 }

ui/tsconfig.json

@@ -22,12 +22,6 @@
       "@/*": ["./*"]
     }
   },
-  "include": [
-    "next-env.d.ts",
-    "**/*.ts",
-    "**/*.tsx",
-    ".next/types/**/*.ts",
-    ".next/dev/types/**/*.ts"
-  ],
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
   "exclude": ["node_modules"]
 }

uv.lock

@@ -1878,7 +1878,7 @@ wheels = [
 
 [[package]]
 name = "routstr"
-version = "0.2.2"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "aiosqlite" },